eredità di Python
ast Python module |
code Python module |
COM PHP module |
dis Python module |
Ev PHP module |
http Python module |
imp Python module |
io Python module |
keyword Python module |
nis Python module |
os Python module |
PS PHP module |
Python functions |
re Python module |
SPL PHP module |
StackOverflow |
struct Python module |
Sync PHP module |
time Python module
Michael Zippo
31.10.2021
L’ereditarietà Python si verifica quando una sottoclasse utilizza il codice di un’altra classe. L’ereditarietà è una caratteristica essenziale nei linguaggi orientati agli oggetti come Python che rende la codifica più semplice ed efficiente.
Python è un linguaggio orientato agli oggetti, il che significa che supporta la creazione di blocchi di codice riutilizzabili per rendere il codice più efficiente. Uno dei modi in cui ciò avviene è tramite l’ereditarietà, in cui una sottoclasse può utilizzare il codice di un’altra classe.
Ad esempio, potresti avere una classe che memorizza "conti bancari" e desideri creare un sottoclasse che memorizza "conti bancari oro" che può fare riferimento ad attributi nei "conti bancari" classe esistente.
In questo tutorial, analizzeremo le basi dell’ereditarietà in Python. Discuteremo anche di come funzionano le classi Python padre e figlio e come sovrascrivere attributi e metodi quando si lavora con oggetti classi.
Eredità Python
Eredità è un termine che viene utilizzato per descrivere una classe Python all’interno di un’altra classe. Le classi chiamate sottoclassi o classi figlie possono ereditare valori da classi genitori, in modo simile a come i bambini ereditano le caratteristiche dai loro genitori nel mondo reale.
L’ereditarietà è utile perché ci permette di creare sottoclassi che hanno gli stessi tipi di valore di una classe genitore, senza dover dichiarare quei tipi più volte.
Genitore Classi
Le classi madri (chiamate anche classi base creano la struttura principale a cui possono accedere le sottoclassi. Possiamo creare più sottoclassi senza dover dichiarare di nuovo lo stesso insieme di valori comuni che derivano metodi di classe dalla classe genitore.
Usiamo un esempio per illustrare come funzionerebbe in azione. Diciamo che abbiamo un programma che funziona con due diversi tipi di conto bancario: genitore e figlio.
L’81% dei partecipanti ha dichiarato di sentirsi più sicuro delle proprie prospettive di lavoro nel settore tecnologico dopo aver partecipato a un bootcamp. amp oggi.
Il laureato medio del bootcamp ha trascorso meno di sei mesi nella transizione di carriera, dall’avvio di un bootcamp alla ricerca del primo lavoro.
Entrambi questi conti sono conti bancari, quindi avranno valori simili. Ma ciascuno di questi account potrebbe richiedere le proprie informazioni univoche. Ad esempio, il conto di un genitore può supportare uno scoperto, mentre il conto del figlio può funzionare solo con il suo saldo.
Quindi, se volessimo creare un programma con questi valori, definiremmo prima una classe per il nostro conto bancario (una classe genitore), quindi creare classi figlie per i due tipi di conti bancari —genitore e figlio—che vogliamo sostenere.
Ecco un esempio di dichiarazione di una classe padre per un conto bancario:
Abbiamo creato la classe BankAccount che memorizza tre valori: nome, cognome e saldo. Possiamo anche aggiungere metodi alla nostra classe, in questo modo:
La nostra classe ora memorizza tre valori, oltre a due nuovi metodi: dettagli e saldo. Il metodo dettagli può essere utilizzato per conoscere il nome e il cognome dell’intestatario del conto e il metodo saldo restituirà il saldo dell’intestatario del conto.
Ogni metodo e variabile che dichiariamo nella nostra classe BankAccount sarà accessibile nella nostra classe figlio.
Per illustrare la nostra classe in azione, creiamo un conto bancario di esempio. Possiamo farlo utilizzando il seguente codice:
Questo creerà un account per John Appleseed che contiene $ 100. Ora che abbiamo il nostro conto pronto, possiamo iniziare a fare riferimento ad esso come faremmo con qualsiasi altra classe. Ecco un esempio di noi che eseguiamo il metodo getBalance() all’interno del nostro conto bancario per scoprire quanto soldi che abbiamo:
Il nostro programma restituisce quanto segue:
Classi figlie
Nell’esempio sopra, abbiamo dichiarato una classe madre che conserva conti bancari. Ma cosa succede se volessimo memorizzare informazioni su un tipo specifico di account come l’account di un minore di 18 anni? è qui che entrano in gioco le classi figlie.
Le classi figlie, o sottoclassi, ereditano i valori dalla classe padre. Ciò significa che ogni classe figlia sarà in grado di fare riferimento ai metodi e alle variabili che dichiariamo nella nostra classe genitore.
Quindi, diciamo che vogliamo creare una classe figlia per un ChildBankAccount . Questo account dovrebbe essere in grado di restituire le informazioni sul conto bancario di un utente, il suo nome e il suo saldo, e dovrebbe anche avere un nuovo valore chiamato restricted. Questo valore verrà memorizzato sul conto di un bambino perché ha meno di 18 anni e non è idoneo per un conto bancario completo.
Per creare una classe per bambini, possiamo utilizzare il seguente codice:
Il ChildBankAccount diventa un figlio della classe BankAccount perché BankAccount è racchiuso tra parentesi. Se vogliamo che la nostra classe figlia abbia esattamente gli stessi valori della nostra classe genitore‚ÄîBankAccount‚Äîpossiamo usare la parola chiave pass in questo modo:
Ma come abbiamo discusso in precedenza, il nostro account figlio avrà bisogno per memorizzare un valore speciale: una variabile che dice che l’account dell’utente è limitato.
Per raggiungere questo obiettivo, aggiungeremo un nuovo valore chiamato restricted al nostro classe bambino. Possiamo farlo usando il seguente codice:
Ora scomponiamo il nostro codice.
Nel codice sopra, affermiamo che vogliamo che i nostri ChildBankAccounts contengano quattro valori: nome, cognome, equilibrio e restrizioni.
"Il Karma di carriera è entrato nella mia vita quando ne avevo più bisogno e mi ha aiutato rapidamente ad abbinarmi a un bootcamp. Due mesi dopo la laurea, ho trovato il lavoro dei miei sogni in linea con i miei valori e obiettivi in life!"
Venus, Software Engineer presso Rockbot
I primi tre (nome, cognome e saldo) sono gli stessi del nostro valori della classe genitore ma limitato è nuovo ed è esclusivo della nostra classe per bambini. Per impostazione predefinita, restricted è impostato su True.
Quindi se creiamo un BankAccount standard (non un ChildBankAccount), non potremo accedere al valore limitato. Allo stesso modo, non saremo in grado di accedere al metodo isRestricted a meno che non creiamo un ChildBankAccount.
Ecco un esempio di come creiamo un ChildBankAccount e utilizzando i metodi getBalance() e isResticted() per saperne di più sulla nostra classe:
Il nostro codice restituisce quanto segue:
Come puoi vedere, il nostro programma definisce prima un nuovo ChildBankAccount per Bill Appleseed, il cui account detiene $ 100. Quindi, il nostro programma esegue il metodo getBalance() nella nostra classe, che restituisce il saldo dell’utente. getBalance() è dichiarato nella nostra classe genitore, BankAccount, ma è accessibile a ChildBankAccount tramite ereditarietà.
Il nostro programma esegue anche il metodo isRestricted(), che afferma che l’account del bambino è limitato perché ha meno di 18 anni. Questa classe è dichiarata in ChildBankAccount , tuttavia, il che significa che non è accessibile alla nostra classe genitore BankAccount. Se volessimo creare un BankAccount ristretto, dovremmo cambiare la classe genitore.
Ridefinizione dei metodi genitori
Nel nostro esempio sopra, abbiamo dichiarato un classe genitore chiamata BankAccount che memorizza le informazioni per i conti bancari. Abbiamo anche creato una classe figlio chiamata ChildBankAccount che memorizza le informazioni per i titolari di account di età inferiore ai 18 anni. Questa classe ha ereditato i metodi dalla classe BankAccount e ha anche creato il isRestricted() metodo.
Ma cosa succede se volessimo modificare un metodo di classe genitore esistente? Supponiamo che desideriamo che il nostro saldo BankAccount restituisca un messaggio con il saldo e un messaggio che dichiari Sei idoneo per uno scoperto, ma non vogliamo che questo venga visualizzato per ChildBankAccount.
Per fare ciò, dobbiamo sovrascrivere il nostro metodo genitore.
Ecco il codice per il nostro metodo genitore rivisto, BankAccount, che ora stampa un messaggio ai titolari del conto per dire che hanno diritto a uno scoperto quando controllano il loro saldo:
Ora, se creiamo un nuovo BankAccount per John Appleseed e stampare il suo saldo, vedremo un messaggio che indica Hai diritto a uno scoperto. Ecco un esempio in cui dichiariamo un nuovo conto e ne controlliamo il saldo:
Il nostro codice restituisce quanto segue:
Ma questo cambiamento significa anche che il nostro ChildBankAccount, che eredita i suoi valori da BankAccount, vedrà anche il messaggio. Ecco un esempio in cui creiamo un ChildBankAccount e ne controlliamo il saldo ora che la nostra classe genitore BankAccount è cambiata:
Il nostro codice restituisce:
Poiché i bambini non sono generalmente ammessi scoperti, dovremo apportare una modifica al nostro codice. Ora, per farlo, dobbiamo modificare la nostra classe ChildBankAccount e dichiarare una nuova funzione getBalance().
L’override dei metodi padre può essere utile quando si hanno più metodi figlio che possono utilizzare metodi simili ai loro genitori, ma richiedono l’esecuzione di modifiche specifiche. Come nel caso precedente, vogliamo che i nostri conti bancari principali visualizzino un messaggio di scoperto, ma non i nostri conti bancari figli, quindi sovrascriviamo il nostro metodo principale in ChildBankAccount.
L’ereditarietà viene utilizzata nella programmazione orientata agli oggetti per aiutarti a creare sottoclassi in grado di memorizzare valori già dichiarati in una classe padre. Questo è utile quando crei classi simili che memorizzeranno valori simili perché puoi usare l’ereditarietà per creare quelle classi senza ripetere il codice più volte.
In questo tutorial, abbiamo esplorato il ruolo dell’ereditarietà in Python . Abbiamo anche discusso di come funzionano l’ereditarietà e le classi padre e figlio, quindi abbiamo esplorato come sovrascrivere i metodi padre. Ora sei pronto per lavorare con le classi e l’ereditarietà come un esperto di Python!
