Programmazione orientata agli oggetti in Python
Contenuti:
L'apprendimento della programmazione orientata agli oggetti in Python dalle basi è stata spiegata qui discutendo i seguenti argomenti con esempi.
- Classe e oggetto
- Costruttore
- Eredità
- Incapsulamento
- Polimorfismo
- Getter e setter
- Operatore di sovraccarico e funzione
Classe e oggetto:
Nella programmazione orientata agli oggetti, classe viene utilizzato per dichiarare la struttura dei dati definita dall'utente che contiene l'insieme di attributi. Gli attributi possono essere le variabili di classe, le variabili di istanza e i metodi. Le variabili che sono accessibili da tutte le istanze della classe sono chiamate variabili di classe. Le funzioni dichiarate all'interno della classe sono chiamate metodi. Le variabili definite all'interno di qualsiasi metodo di classe e accessibili dall'istanza corrente della classe sono chiamate variabili di istanza. Una classe viene dichiarata in Python definendo la parola chiave di classe seguita da un nome di classe e un colon (:). La sintassi della classe è definita di seguito.
Sintassi della classe:
Classe ClassName:Variabili;
Metodi;
Un'istanza o una copia di una classe è chiamata oggetto utilizzato per accedere alle variabili di classe e ai metodi di classe. Una lezione è inutile senza dichiarare un oggetto perché il classe contiene solo la descrizione dell'oggetto che non alloca alcuna memoria. IL oggetto è dichiarato menzionando il nome della classe con la prima staffa di avvio e fine. Se la classe contiene qualsiasi metodo di costruttore con i parametri, è necessario definire il valore dei parametri al momento di oggetto dichiarazione. La sintassi dell'oggetto è riportata di seguito.
Sintassi dell'oggetto:
Object_name = class_name ()O
Object_name = class_name (valore1, valore2, ...)La dichiarazione di una classe semplice e la dichiarazione oggetto di quella classe hanno mostrato nel seguente script. Una classe di nome 'Libro'è stato dichiarato qui che contiene tre variabili di classe (book_name, autore_name e prezzo) e un metodo chiamato book_discount_price (). Il metodo calcolerà il prezzo del libro dopo uno sconto del 5% e stampa i dettagli del libro con l'originale e il prezzo di sconto. La variabile oggetto denominata Objbook è stata definita nello script per creare l'istanza della classe e chiamare il metodo della classe.
ClasseBobject.Py
# Definisci la classelibro di classe:
# Definisci e inizializza le variabili di classe
book_name = "Impara Python nel modo duro"
Author_name = "Zed Shaw"
Prezzo = 22
# Definisci il metodo di classe per visualizzare i dettagli del libro con il prezzo di sconto
def book_discount_price (self):
# Calcola il prezzo di sconto dopo lo sconto del 5%
d_price = self.Prezzo - Self.Prezzo * 0.05
# Stampa Dettagli del libro
Print ("Nome del libro: \ nauthor Nome: \ Noriginal Price: $ \ ndiscount Price: $ \ n"
.formato (sé.book_name, self.autore_name, self.prezzo, d_price))
# Crea un oggetto della classe
objbook = book ()
Stampa ("Informazioni sul libro dopo lo sconto:")
# Chiama il metodo della classe
objbook.book_discount_price ()
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra.
Costruttore:
Il costruttore è un metodo di una classe chiamata automaticamente al momento della dichiarazione di quella classe. Viene utilizzato principalmente per inizializzare l'oggetto di una variabile. def La parola chiave viene utilizzata per dichiarare qualsiasi metodo in una dichiarazione di classe Python e il nome del metodo del costruttore è __dentro__() in Python. Due tipi di costruttori possono essere dichiarati in Python. Questi sono il costruttore senza parametri e il costruttore parametrizzato. Gli usi di entrambi i costruttori hanno mostrato in questa parte di questo tutorial.
UN. costruttore senza parametri
Il costruttore che contiene solo un argomento chiamato se stesso è chiamato costruttore di parametri o predefinito. Non è richiesto alcun parametro per passare al momento della dichiarazione di oggetti di una classe che contiene il costruttore senza parametri. Il modo per dichiarare un costruttore senza parametri è stato mostrato nel seguente script. Qui, il Cliente La classe contiene il costruttore senza parametri che inizializzerà le variabili a quattro classi quando verrà creato qualsiasi oggetto di classe. Successivamente, un oggetto della classe denominata objcustomer è stato dichiarato di accedere alle variabili della classe.
default_constructor.Py
# Definisci la classe dei clientiCliente di classe:
# Dichiarare costruttore senza parametro
def __init __ (self):
# Inizializza le variabili di classe
se stesso.Id = 'd-67455'
se stesso.name = 'sakib hasan'
se stesso.Account_Type = 'Saving'
se stesso.Saldo = 5000000
# Crea oggetto della classe cliente
objcustomer = cliente ()
Stampa ("Informazioni di base del cliente: \ n")
# Stampa i valori delle proprietà dell'oggetto
print ("id: \ nname: \ naccount type: \ nBalance: "
.Formato (objcustomer.Id, objcustomer.nome, objcustomer.account_type, objcustomer.bilancia))
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra.
B. Costruttore parametrizzato
Il costruttore che contiene uno o più argomenti con il 'se stesso'L'argomento è chiamato costruttore parametrizzato. Devi passare i valori dei parametri al momento della creazione di oggetti della classe. Il modo per dichiarare il costruttore parametrizzato è stato mostrato nel seguente script. Qui, il Cliente La classe è dichiarata con un costruttore parametrizzato e due metodi. Il metodo chiamato Balance_After_Deposite () è definito per aggiungere l'importo del deposito con il saldo. Il metodo chiamato Balance_after_withDraw () è definito per detrarre l'importo del prelievo dal saldo. Successivamente, la variabile oggetto è definita per visualizzare i dettagli di base del cliente, il saldo dopo il deposito e il saldo dopo il prelievo.
parametrited_constructor.Py
# Definisci la classe dei clientiCliente di classe:
# Dichiara il costruttore con il parametro
def __init __ (self, cust_id, cust_name, cust_balance):
# Inizializza le variabili
se stesso.Id = cust_id
se stesso.name = cust_name
se stesso.Balance = Cust_Balance
# Aggiungi importo con il saldo
Def Balance_After_Deposite (self, Deposit_amount):
se stesso.Saldo += deposito_amount
# Stampa il saldo corrente
print ("Deposit mmmount: \ ncurrent Balance: \ n".Formato (deposit_amount, self.bilancia))
# Sottrai importo dal saldo
Def Balance_After_withDraw (self, prelievi_amount):
se stesso.Saldo -= prelievo
# Stampa il saldo corrente
print ("prelevare mmmount: \ ncurrent Balance: \ n".formato (prelievo_amount, self.bilancia))
# Crea oggetto della classe cliente
Objcustomer = Cliente ('M-231234', 'Mir Sabbir', 200000)
# Stampa le informazioni di base del cliente
print ("Dettagli del cliente: \ nid: \ nname: \ nopening Balance: \ n"
.Formato (objcustomer.Id, objcustomer.nome, objcustomer.bilancia))
# Aggiungi l'importo del deposito
objcustomer.Balance_After_Deposite (30000)
# Sottrai l'importo del prelievo
objcustomer.Balance_after_withDraw (10000)
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra. Qui, il saldo di apertura è 200000. Il saldo diventa 220000 dopo aver aggiunto 30000 e dedotto 10000.
Eredità:
Una delle caratteristiche di base della programmazione orientata agli oggetti è l'eredità. Il modo per creare una nuova classe da una classe esistente è chiamato eredità. La classe esistente è chiamata classe madre o classe base e la nuova classe ereditata è chiamata bambino o classe derivata. La classe figlio conterrà le caratteristiche della classe base dopo l'eredità. Come si può applicare l'eredità nella classe Python nell'esempio seguente. Nella sceneggiatura, il 'Alunno'è la classe genitore e il'StudentDetails'è la classe figlio. Entrambe le classi hanno i costruttori parametrizzati. La classe genitore ha un metodo chiamato Visualizza base () Per stampare l'ID, il nome e le variabili di posta elettronica della classe madre. La classe figlio ha un metodo chiamato displayInfo () Per stampare i valori del lotto e variabili semestre della classe figlio. Il costruttore della classe genitore è chiamato costruttore di classe figlio. Dopo la dichiarazione della classe, l'oggetto della classe genitore è stato dichiarato con valori di tre parametri per inizializzare le variabili di classe della classe genitore e il metodo della classe genitore è stato chiamato per visualizzare questi valori. Successivamente, l'oggetto della classe figlio è stato dichiarato con valori a tre parametri per inizializzare le variabili di classe della classe figlio e il metodo della classe figlio è stato chiamato per visualizzare questi valori.
eredità.Py
# Definisci la classe genitoreStudente di classe:
# Definisci il costruttore della classe genitore
def __init __ (self, id, name, email):
# Inizializza le variabili della classe principale
se stesso.Id = id
se stesso.nome = nome
se stesso.email = email
# Definisci il metodo della classe genitore
def DisplayBasic (self):
# Stampa i valori delle variabili della classe genitore
print ("id: \ nname: \ nemail: ".formato (sé.Id, sé.Nome, Self.e-mail))
# Definisci la classe figlio
Classe StudentDetails (Studente):
# Definisci il costruttore di classe per bambini
def __init __ (self, id, name, e -mail, repart, batch, sem, cgpa):
# Chiama il costruttore della classe madre
Alunno.__init __ (self, id, name, email)
# Inizializza le variabili della classe figlio
se stesso.Dipartimento = Dept
se stesso.batch = batch
se stesso.semestre = sem
se stesso.CGPA = CGPA
# Definisci il metodo della classe figlio
def DisplayInfo (self):
Alunno.DisplayBasic (self)
# Stampa i valori delle variabili della classe figlio
print ("Dipartimento: \ nBatch: \ nSemerter: "
.formato (sé.Dipartimento, Self.Batch, Self.semestre))
# Crea l'oggetto della classe genitore
ObjStudent = Student ('674534', 'Rakib Hasan', '[email protected] ')
Stampa ("Informazioni di base dello studente: \ n")
# Chiama il metodo della classe genitore
objstudent.DisplayBasic ()
# Crea l'oggetto della classe figlio
ObjStudentDetails = StudentDetails ('783412', 'Zannatul Ferdous', '[email protected] ',' cse ', 48, 10, 3.89)
Print ("Informazioni sui dettagli di Nstudent: \ n")
# Chiama il metodo della classe figlio
ObjstudentDetails.displayInfo ()
# Stampa un valore di proprietà della classe figlio
print ("cgpa: ".Formato (ObjstudentDetails.cgpa))
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra.
Incapsulamento:
Un'altra caratteristica di base della programmazione orientata agli oggetti è l'incapsulamento. Il modo per nascondere le variabili e i metodi particolari di una classe è chiamato incapsulamento. Viene utilizzato per impostare la restrizione per l'accesso ai dati particolari. Lo scopo principale di questa funzione è fornire la sicurezza dei dati mediante nascondersi i dati. L'incapsulamento può essere implementato in Python dichiarando i membri dei dati privati o protetti della classe. In che modo l'incapsulamento può essere implementato in Python ha mostrato nell'esempio seguente. Nella sceneggiatura, il Aggiungere la classe ha creato ereditando il Numero classe. Un membro privato di nome '__risultato'Ha dichiarato nella classe figlio per archiviare la somma di due numeri e questa variabile è accessibile solo all'interno della classe figlio. Il costruttore della classe genitore inizializzerà due variabili di classe con i numeri. Secondo lo script, il costruttore della classe figlio chiamerà il costruttore della classe genitore, calcolerà la somma delle variabili di classe e stampano il risultato dell'aggiunta. Dopo la dichiarazione di classe, l'oggetto della classe figlio è stato dichiarato. Successivamente, il membro privato della classe Child ha utilizzato nella funzione di stampa che genererà un errore.
encalsulation.Py
# Definisci la classe genitoreNumero di classe:
def __init __ (self):
# Inizializza i membri pubblici della classe madre
se stesso.N1 = 10
se stesso.N2 = 30
# Definisci la classe figlio
Classe Aggiungi (numero):
def __init __ (self):
# Chiama il costruttore genitore
Numero.__in se stesso)
"
Memorizzare il risultato dell'aggiunta in un membro privato
della classe bambino
"
se stesso.__Result = self.N1 + Self.N2
# Stampa il risultato dell'aggiunta
print ("Il risultato di Aggiungi = \ n".formato (sé.__risultato))
# Crea l'oggetto della classe figlio
objadd = add ()
# Stampa la proprietà privata della classe figlio
Stampa (Objadd.__risultato)
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra. Quando è stato definito l'oggetto, è stato chiamato il metodo del costruttore e la somma di 10 e 30 ha stampato. Il messaggio di errore è apparso per aver tentato di accedere al membro privato dall'esterno della classe.
Polimorfismo:
Un'altra caratteristica di base della programmazione orientata agli oggetti è il polimorfismo. Il significato di poli è "molti", e morfismo è "forme". Il modo per dichiarare la stessa funzione più volte per scopi diversi è chiamato polimorfismo. La codifica diventa più facile per l'utilizzo di questa funzione dell'OOP. Questa funzione può essere implementata utilizzando la sceneggiatura Python, come il polimorfismo in diverse classi, il polimorfismo in classi ereditate, ecc. In che modo il polimorfismo può essere implementato in diverse classi usando lo script Python ha mostrato nell'esempio seguente. Nella sceneggiatura, sono state dichiarate due classi non correlate denominate rettangolo e cerchio. Entrambe le classi hanno il costruttore parametrizzato e un metodo chiamato la zona(). Qui, entrambe le classi contengono lo stesso metodo, ma lo scopo del metodo è diverso. Nella classe rettangolare, il costruttore inizializzerà due variabili denominate altezza E larghezza, e il la zona() Il metodo calcolerà l'area del rettangolo. Nella classe Circle, il costruttore inizializzerà una variabile denominata raggio, e il la zona() Il metodo calcolerà l'area del cerchio. Dopo aver dichiarato la classe, due valori numerici verranno prelevati dall'utente per passare i valori di altezza e larghezza al costruttore del Rettangolo classe al momento della dichiarazione degli oggetti. Successivamente, il la zona() metodo del Rettangolo La classe verrà chiamata per stampare l'area del rettangolo in base ai valori di input. Successivamente, un valore di un numero verrà preso dall'utente per passare il valore del raggio al costruttore del Cerchio classe al momento della creazione di oggetti. , IL la zona() metodo del Cerchio la classe verrà chiamata per stampare l'area del cerchio in base al valore di input.
polimorfismo.Py
# Definisci la classe rettangoloRettangolo di classe:
# Definisci il costruttore
def __init __ (self, altezza, larghezza):
# Inizializza le variabili di classe
se stesso.altezza = altezza
se stesso.larghezza = larghezza
# Definisci il metodo per calcolare l'area del rettangolo
area def (self):
area = self.Altezza * Self.larghezza
print ("L'area del rettangolo è \ n".formato (area))
# Definisci la classe Circle
Circolo di classe:
# Definisci il costruttore
def __init __ (sé, raggio):
# Inizializza la variabile di classe
se stesso.raggio = raggio
# Definire il metodo per calcolare l'area del cerchio
area def (self):
area = 3.14 * Self.raggio * self.raggio
print ("L'area del cerchio è \ n".formato (area))
# Prendi i valori di altezza e larghezza dall'utente
altezza = int (input ("Immettere l'altezza del rettangolo:")
larghezza = int (input ("Immettere la larghezza del rettangolo:"))
# Crea l'oggetto della classe rettangolo
objrectangle = rettangolo (altezza, larghezza)
# Chiama Area () Metodo per stampare l'area del rettangolo
objrectangle.la zona()
# Prendi il valore del raggio dall'utente
raggio = int (input ("Immettere il raggio del rettangolo:"))
# Crea l'oggetto della classe Circle
objcircle = cerchio (raggio)
# Metodo di chiamata () per stampare l'area del cerchio
OB0000000000000000000000000000000000000000000000000000000000000000000000 di.la zona()
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra. Secondo l'output, 5 ha preso come valore di altezza e 2 ha preso come valore di larghezza. Per questi valori, l'area del rettan0gle è 10 (5 × 2) che è stata stampata. Successivamente, 2 ha preso il valore del raggio e l'area del cerchio è 12.56 (3.14x2x2) che è stato stampato.
Getter e setter:
Il metodo utilizzato per leggere il valore della proprietà è chiamato getter e il metodo utilizzato per impostare il valore della proprietà è chiamato setter. Nella programmazione orientata agli oggetti, il getter viene utilizzato per accedere agli attributi privati della classe e il setter viene utilizzato per impostare i valori degli attributi privati della classe. Gli scopi principali di questa funzione sono garantire l'incapsulamento dei dati e la convalida dei dati. Il getter e il setter possono essere implementati utilizzando la funzione normale o @property decoratore. Entrambi i modi di implementare Setter e Getter sono stati mostrati in questa parte del tutorial.
Setter e Getter usando la funzione normale:
Il seguente script mostra come la funzione normale può essere utilizzata per impiantare i metodi di getter e setter. Nella sceneggiatura, il Persona La classe contiene i metodi personalizzati getter e setter per leggere i valori delle variabili di classe privata e impostare il valore della variabile e -mail che è un membro privato. Il valore vuoto è passato per la variabile e -mail al momento della creazione di oggetti e il metodo di setter personalizzato è stato utilizzato per impostare il valore dell'email. Il metodo personalizzato getter restituirà tutti i valori della variabile di classe come elenco.
Custom_setter_getter.Py
# Definisci la classePersona di classe:
def __init __ (self, nome, e -mail, telefono):
# Definisci le variabili dei membri privati
se stesso.__Name = nome
se stesso.__Email = email
se stesso.__Phone = telefono
# Definisci Custom Getter
def get_person_data (self):
Stampa ("Il metodo Gettter personalizzato è chiamato")
restituire [Self.__Name, Self.__mail, sé.__telefono]
# Definisci il setter personalizzato
def set_person_data (self, email):
Print ("Il metodo del setter personalizzato è chiamato")
se stesso.__Email = email
# Crea oggetto della classe
objperson = persona ('Rifat bin Hasan', ", '01855435626')
# Imposta il valore e -mail utilizzando il setter personalizzato
objperson.set_person_data ('[email protected] ')
# Leggi tutti i valori dei membri dei dati utilizzando Getter personalizzato
persona = objperson.get_person_data ()
# Stampa i valori di ritorno
print ("Nome: \ nemail: \ nphone: ".Formato (persona [0], persona [1], persona [2])
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra.
Setter e getter usando @Property Decorator:
Il seguente script mostra come il decoratore @Property può essere utilizzato per impiantare i metodi GETTER e Setter. Nello script, il setter e il setter hanno dichiarato utilizzando @Property Decorator per impostare il valore della variabile del nome, un membro della classe privata. Dopo aver dichiarato la classe, l'oggetto della classe è stato definito e il valore della variabile del nome è stato assegnato e recuperato utilizzando Setter e Getter.
decorator_setter_getter.Py
# Definisci la classePersona di classe:
def __init __ (self, name = "):
# Definisci le variabili dei membri privati
se stesso.__Name = nome
# Definisci Custom Getter
@proprietà
def nome (self):
print ("Il metodo getter è chiamato")
Restituisci se stessi.__nome
# Definisci il setter personalizzato
@nome.setter
def nome (self, name):
print ("Il metodo setter è chiamato")
se stesso.__Name = nome
# Crea oggetto della classe
objperson = persona ()
# Imposta il valore e -mail utilizzando il setter personalizzato
objperson.name = 'Zanifer Ali'
print ("Il nome della persona è \ n".Formato (objperson.nome))
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra.
Operatore di sovraccarico e funzione:
Quando qualsiasi funzione o operatore viene utilizzato per uno scopo diverso in base al parametro della funzione o agli operandi anziché all'uso normale della funzione o dell'operatore, viene chiamato sovraccarico. La funzione di riusabilità può essere implementata nella programmazione orientata agli oggetti utilizzando il sovraccarico dell'operatore e il sovraccarico delle funzioni. È una caratteristica utile di OOP, ma l'uso in eccesso di questa funzione crea difficoltà a gestire il codice. In questo tutorial è stato mostrato il semplice utilizzo del sovraccarico dell'operatore e il sovraccarico di funzioni nella classe Python.
Sovraccarico dell'operatore:
L'operatore viene utilizzato su due operandi. Lo scopo di ciascun operatore è diverso. Ad esempio, ci sono molti usi dell'operatore "+", come può essere utilizzato per l'aggiunta, combinando due stringhe, ecc. Ma quando l'operatore '+' viene utilizzato per uno scopo diverso, si chiama sovraccarico dell'operatore. Le funzioni speciali vengono utilizzate per diversi tipi di sovraccarico dell'operatore. La funzione speciale è dichiarata usando "__" all'inizio e alla fine del nome della funzione. Molte funzioni speciali di diversi tipi di operatori esistono in Python per il sovraccarico dell'operatore. L'operatore può essere matematico, confronto operatore, operatore di assegnazione, eccetera. L'uso della funzione speciale dell'operatore matematico è stato mostrato in questa parte di questo tutorial per comprendere il concetto di sovraccarico dell'operatore in Python.
Operatore matematico:
Gli operatori che vengono utilizzati per le operazioni aritmetiche sono chiamati operatori matematici. Questi operatori possono essere utilizzati per uno scopo speciale utilizzando una funzione speciale. Alcune funzioni speciali dell'operatore matematico sono menzionate di seguito.
| Nome dell'operatore | Simbolo | Funzione speciale |
|---|---|---|
| Aggiunta | + | __add __ (sé, altro) |
| Sottrazione | - | __sub __ (sé, altro) |
| Moltiplicazione | * | __mul __ (sé, altro) |
| Divisione | / | __TrueDiv __ (sé, altro) |
| Modulo | % | __Mod __ (sé, altro) |
| Energia | ** | __Pow __ (sé, altro) |
Utilizzando la funzione speciale dell'operatore di alimentazione (**):
__Pow __ () La funzione speciale viene utilizzata per sovraccaricare l'operatore di alimentazione. Lo scopo principale dell'operatore di alimentazione è di calcolare il valore di alimentazione di un particolare numero. Ma se richiediamo di calcolare i valori di alimentazione utilizzando i valori dei punti, allora l'operatore di alimentazione generale non funzionerà. Supponiamo che ci siano due punti (3, 2) e (2, 4). Abbiamo bisogno della somma di 32 e 24. In questo caso, dobbiamo utilizzare la funzione speciale dell'operatore di alimentazione. La funzione __Pow __ () può calcolare la somma dei poteri in base ai valori dei punti mostrati nel seguente script. La classe SUMOFPOWER contiene un costruttore parametrizzato per inizializzare due variabili di classe, __Pow __ () funzione per calcolare la somma di due poteri in base ai valori dei punti e __Str __ () funzione per stampare l'oggetto della classe. Successivamente, sono stati dichiarati due oggetti della classe. L'operatore di alimentazione ha utilizzato due variabili di oggetto nella stampa () funzione per chiamare il file __Pow __ () funzione per completare l'operazione.
Operator_Overloading.Py
# Definisci la classeSUMOFPOWER DI CLASSE:
# Definisci il costruttore di classe
def __init __ (self, n1, n2):
se stesso.A = N1
se stesso.B = N2
# Sovraccarico dell'operatore di alimentazione
def __pow __ (sé, altro):
a = self.un ** altro.UN
b = sé.fastidio.B
se stesso.risultato = a + b
restituire sumofpowers (a, b)
# funzione stringa per stampare oggetto della classe
def __str __ (self):
Restituisci STR (Self.a)+'+'+str (self.B)
# Crea il primo oggetto
pow1 = sumofpowers (3, 2)
# Crea il secondo oggetto
POW2 = SUMOFPOWERS (2, 4)
# Calcola i poteri e stampa la somma dei poteri
Print ("The Sum of Powers =", Pow1 ** Pow2, "=", Pow1.risultato)
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra. 32 è 9 e 24 è 16. La somma di 9 e 16 è 25 che si mostra nell'output.
Sovraccarico di funzioni:
A volte dobbiamo scrivere più metodi che sono abbastanza simili ma differiscono solo in alcune parti. In questo caso, un singolo metodo può essere definito per eseguire le stesse attività usando il sovraccarico delle funzioni. La complessità del codice può essere rimossa e il codice diventa più chiaro utilizzando il sovraccarico delle funzioni. L'output della funzione dipende dall'argomento passato alla funzione. In che modo il sovraccarico della funzione può essere implementato in Python ha mostrato nel seguente script. Lo scopo principale dello script è quello di eseguire quattro tipi di operazioni aritmetiche con il valore predefinito o i valori passati al momento della creazione di oggetti. Il metodo chiamato Calcola () è stato usato qui per fare le operazioni aritmetiche. Il metodo è stato chiamato quattro volte nella sceneggiatura per svolgere quattro tipi di attività. Quando il metodo chiama senza alcun argomento, allora visualizzerà un messaggio. Quando il metodo chiama con "+" come valore dell'argomento, calcolerà i valori predefiniti. Quando il metodo chiama con '-' e un valore numerico come valori dell'argomento, sottraggerà il secondo valore predefinito dal valore dell'argomento. Quando il metodo chiama con '*' e due valori numerici come valori di argomento, calcolerà due valori di argomento.
function_overloading.Py
# Definisci la classearitmetica di classe:
# Definisci la variabile di classe
risultato = 0
# Definisci il metodo della classe
DEF Calcola (self, operator = "", numero1 = 25, numero2 = 35):
# Calcola la somma
se operatore == "+":
se stesso.risultato = numero1 + numero2
print ('Il risultato dell'aggiunta è '.formato (sé.risultato))
# Calcola la sottrazione
Operatore Elif == "-":
se stesso.risultato = numero1 - numero2
print ('Il risultato della sottrazione è '.formato (sé.risultato))
# Calcola la moltiplicazione
Operatore Elif == "*":
se stesso.risultato = numero1 * numero2
print ('Il risultato della moltiplicazione è '.formato (sé.risultato))
# Calcola la divisione
Operatore Elif == "/":
se stesso.risultato = numero1 / numero2
print ('Il risultato della divisione è '.formato (sé.risultato))
altro:
Stampa ("Nessun operatore è dato")
# Crea l'oggetto della classe
objarithmetic = aritmetic ()
# Chiama il metodo senza argomento
objaritmetico.calcolare()
# Chiama il metodo con un argomento
objaritmetico.Calcola ('+')
# Chiama il metodo con due argomenti
objaritmetico.Calcola ('-', 50)
# Chiama il metodo con tre argomenti
objaritmetico.Calcola ('*', 2, 3)
Produzione:
Verrà visualizzato il seguente output dopo aver eseguito lo script sopra. 'Nessun operatore è dato'Il messaggio ha stampato per chiamare il metodo senza alcun argomento. La somma di 25 e 35 è stata stampata per chiamare il metodo con un argomento. Il valore di sottrazione di 50-35 è stato stampato per chiamare il metodo con due valori di argomento. Il valore di moltiplicazione di 3 e 2 ha stampato per chiamare il metodo con tre valori di argomento. In questo modo, lo script è stato implementato il sovraccarico di funzioni per utilizzare la stessa funzione più volte.
Conclusione:
La programmazione di base orientata agli oggetti in Python è stata spiegata in questo tutorial usando esempi di Python molto semplici. Le caratteristiche più comuni dell'OOP sono discusse qui per aiutare i lettori a conoscere il modo di OOP in Python e in grado di scrivere il programma Python usando classe e oggetto.