Tipi di ereditarietà in Python | Ereditarietà Python [con esempio]

Pubblicato: 2021-02-09

Sommario

introduzione

La lotta per un codice pulito è una battaglia a cui si uniscono tutti i programmatori. E quella battaglia può essere vinta con un'adeguata armatura di concetti di programmazione orientata agli oggetti. E il corretto utilizzo dei concetti OOP ci aiuta a migliorare la riusabilità del codice, la leggibilità, la complessità ottimale del tempo e dello spazio.

La codifica in Python è super divertente. Ha un numero enorme di supporto per librerie, orientato agli oggetti, la programmabilità della GUI lo rende una torta calda tra tutti i linguaggi di programmazione.

L'ereditarietà è una delle funzionalità orientate agli oggetti più utilizzate e implementarla in Python è un compito entusiasmante. Quindi, iniziamo ora!

Per prima cosa capiamo la definizione di eredità.

Eredità

L'ereditarietà è un processo per ottenere proprietà e caratteristiche (variabili e metodi) di un'altra classe. In questo ordine gerarchico, la classe che eredita un'altra classe è chiamata sottoclasse o classe figlia e l'altra classe è la classe genitore.

L'ereditarietà è classificata in base alla gerarchia seguita e al numero di classi e sottoclassi principali coinvolte.

Esistono cinque tipi di eredità:

  1. Unica eredità
  2. Ereditarietà multipla
  3. Ereditarietà multilivello
  4. Eredità gerarchica
  5. Eredità ibrida

Unica eredità

Questo tipo di ereditarietà consente a una sottoclasse oa una classe derivata di ereditare proprietà e caratteristiche della classe padre, questo evita la duplicazione del codice e migliora la riutilizzabilità del codice.

#classe genitore
 classe Sopra :
 io = 5
 def fun1 (auto):
 print( "Ehi, sei nella classe genitore" )

 #sottoclasse
 classe Sotto (sopra):
 io= 10
 def fun2 (auto):
 print( "Ehi, sei nella sottoclasse" )

 temp1=Sotto()
 temp2=Sopra()
 temp1.fun1()
 temp1.fun2()
 temp2.fun1()
 stampa(temp1.i)
 stampa(temp2.i)
 #temp2.fun2()

Bene, esaminiamo il codice sopra.

Nel codice sopra "Above" è la classe genitore e "Below" è la classe figlia che eredita la classe genitore. L'implementazione dell'ereditarietà in Python è un compito semplice, dobbiamo solo menzionare il nome della classe genitore tra parentesi della classe figlia. Stiamo creando oggetti sia della classe genitore che della classe figlia, e qui arriva un punto interessante sull'ereditarietà. Una classe figlia può accedere ai metodi e alle variabili della classe genitore, mentre il viceversa non è vero.

Quindi nel codice sopra l'oggetto temp1 può accedere a entrambi i metodi fun1 e fun2 mentre l'oggetto temp2 può accedere solo al metodo fun1. Allo stesso modo, la stessa regola si applica alle variabili nel codice. E l'accesso a un metodo di classe figlio o a una variabile da un oggetto di classe padre genererà un errore. Se l'ultima riga del codice non è commentata, viene generato un errore.

Ereditarietà multipla

Questa eredità consente a una classe figlia di ereditare da più di una classe padre. Questo tipo di eredità non è supportato dalle classi java, ma python supporta questo tipo di eredità. Ha un enorme vantaggio se abbiamo la necessità di raccogliere più caratteristiche da classi diverse.

#classe genitore 1
 classe A :
 demo1= 0
 def fun1 (auto):
 stampa(auto.demo1)

 #classe genitore 2
 classe B :
 demo2= 0
 def fun2 (auto):
 stampa(self.demo2)

 #classe bambino
 classe C (A, B):
 def fun3 (auto):
 print( "Ehi, sei nella classe figlio" )

 # Codice principale
 c = C()
 c.demo1 = 10
 c.demo2 = 5
 c.fun3()
 print( “il primo numero è : “ ,c.demo1)
 print( “il secondo numero è : “ ,c.demo2)

Nel codice sopra, abbiamo creato due classi padre "A", "B". Seguendo la sintassi dell'ereditarietà in Python, abbiamo creato una classe figlia, che eredita entrambe le classi "A" e "B". Come discusso in precedenza sul fatto che una classe figlia può accedere ai metodi e alle variabili della classe genitore, la classe figlia "C" può accedere ai metodi della sua classe genitore.

Ereditarietà multilivello

Nell'ereditarietà multilivello, il trasferimento delle proprietà delle caratteristiche viene effettuato a più di una classe in modo gerarchico. Per ottenere una migliore visualizzazione possiamo considerarlo come un antenato della relazione dei nipoti o una radice da foglia in un albero con più di un livello.

#classe genitore 1
 veicolo di classe :
 def funzionante (auto):
 print( “i veicoli sono usati per il trasporto” )

 #bambino classe 1
 auto di classe (veicolo):
 def ruote (auto):
 print( "un'auto ha 4 ruote" )
#bambino classe 2
 classe electric_car (auto):
 def specialità (auto):
 print( "l'auto elettrica funziona con l'elettricità" )

 elettrico=auto_elettrica()
 specialità.elettriche()
 ruote.elettriche()
 elettrico.funzionante()

Dopo aver esaminato il codice sopra, abbiamo creato una classe "veicolo", quindi abbiamo creato un'auto di classe che eredita il veicolo di classe. Ora il "veicolo" è una classe genitore e la "macchina" è una classe figlia. Successivamente abbiamo creato una classe "auto_elettrica", ora la classe auto è una classe genitore e la classe auto_elettrica è una classe figlia e la relazione tra classe veicolo e classe auto elettrica è l'eredità multilivello.

Qui la classe electric_car può accedere ai metodi, alle variabili sia del veicolo che della classe dell'auto, mentre la classe auto può accedere solo ai metodi, variabili della classe del veicolo. E come discusso, il veicolo della classe genitore non può accedere a nessun metodo della classe figlia.

Eredità gerarchica

Questa eredità consente a una classe di ospitare come classe padre per più di una classe figlia o sottoclasse. Ciò offre il vantaggio di condividere il funzionamento dei metodi con più classi figlio, evitando così la duplicazione del codice.

#classe genitore
 Genitore di classe :
 def fun1 (auto):
 print( "Ehi, sei nella classe genitore" )
#bambino classe 1
 classe bambino1 (Genitore):
 def fun2 (auto):
 print( "Ehi, sei nella classe bambino 1" )

 #bambino classe 2
 classe bambino2 (Genitore):
 def fun3 (auto):
 print( "Ehi, sei nella classe bambino 2" )
#bambino classe 3
 classe bambino3 (Genitore):
 def fun4 (auto):
 print( "Ehi, sei nella classe bambino 3" )
# programma principale
 child_obj1 = child3()
 child_obj2 = child2()
 child_obj3 = child1()
 child_obj1.fun1()
 child_obj1.fun4()
 child_obj2.fun1()
 child_obj2.fun3()
 child_obj3.fun1()
 child_obj3.fun2()

Nel codice sopra, abbiamo una singola classe genitore e più classi figlie che ereditano la stessa classe genitore. Ora tutte le classi figlie possono accedere ai metodi e alle variabili della classe genitore. Abbiamo creato una classe "Parent" e 3 classi figlio "child1", "child2", "child3", che ereditano la stessa classe padre "Parent".

Checkout: idee per progetti open source Python

Eredità ibrida

Un'eredità è detta eredità ibrida se più di un tipo di eredità è implementato nello stesso codice. Questa funzione consente all'utente di utilizzare al meglio la caratteristica dell'ereditarietà. Ciò soddisfa il requisito dell'implementazione di un codice che necessita di ereditarietà multiple nell'implementazione.

classe A:
def fun1(self):
print("Ehi, sei in classe A")class B(A):
def fun2(self):
print("Ehi, sei in classe B")class C(A):
def fun3(self):
print("Ehi, sei in classe C")class D(C,A): #riga 13
def fun4(self):
print("Ehi, sei nella classe D")#programma principale
rif = D()
rif.fun4()
rif.fun3()
rif.fun1()

Nel codice sopra, possiamo vedere che abbiamo implementato più di un tipo di ereditarietà. Le classi A, B, C implementano l'ereditarietà gerarchica e le classi A, C, D implementano l'ereditarietà multilivello. Noe quelle eredità individuali hanno le loro proprietà individuali di accesso ai metodi e alle variabili della classe genitore. Inoltre, c'è un punto da notare.

Quando implementiamo l'ereditarietà multilivello, seguiamo una sintassi come "classe_bambino(classe_genitore1, classe_genitore2)". Ma questa sintassi genererà un errore se "parent_class1" è gerarchicamente sopra "parent_class2". Se vogliamo implementare questa sintassi, allora "parent_class1" deve trovarsi in un livello gerarchicamente inferiore a "parent_class2". Ad esempio, nel codice precedente, se la riga 13 ha una classe di sintassi D(A, C), il codice non funzionerebbe poiché la classe C è gerarchicamente inferiore alla classe A.

Impara i corsi di scienza dei dati dalle migliori università del mondo. Guadagna programmi Executive PG, programmi di certificazione avanzati o programmi di master per accelerare la tua carriera.

Leggi: Idee e argomenti del progetto Python

Conclusione

Abbiamo esaminato gli usi e le esigenze dell'eredità e abbiamo compreso la definizione di eredità. Inoltre, abbiamo esaminato i tipi di eredità e abbiamo esaminato i codici di implementazione e le spiegazioni di ciascun tipo di eredità. Comprensione delle regole delle variabili e dell'accesso ai metodi nei diversi tipi di ereditarietà.

Ora che sei a conoscenza di diversi tipi di eredità in Python, prova a implementarli e prova a utilizzarli nel tuo codice. Prova a ottimizzare il tuo codice con il corretto utilizzo dell'ereditarietà.

Se sei curioso di conoscere la scienza dei dati, dai un'occhiata al Diploma PG in Data Science di IIIT-B e upGrad, creato per i professionisti che lavorano e offre oltre 10 casi di studio e progetti, workshop pratici pratici, tutoraggio con esperti del settore, 1- on-1 con mentori del settore, oltre 400 ore di apprendimento e assistenza al lavoro con le migliori aziende.

Qual è la differenza tra eredità multipla e eredità multilivello?

Molti programmatori principianti spesso si confondono tra l'ereditarietà multipla e l'ereditarietà multilivello. Di seguito vengono illustrate alcune delle differenze significative tra questi due tipi di eredità.
Ereditarietà multipla -
1. Quando una classe figlia eredita le sue proprietà e caratteristiche da più di una classe base, questo tipo di eredità è noto come Ereditarietà Multipla.
2. Non è ampiamente utilizzato poiché l'ereditarietà multipla può essere piuttosto complessa da comprendere.
3. Ha solo due livelli di classe: classe base e classe derivata.
Ereditarietà multilivello
1. L'ereditarietà in cui una classe figlia eredita le proprietà dalla sua classe base che sta ulteriormente ereditando le proprietà da un'altra classe base, rendendo la prima una classe figlia è nota come Ereditarietà multilivello.
2. Questa eredità serve a grandi scopi e quindi è ampiamente utilizzata.
3. Ha almeno tre livelli di classe: classe base, classe intermedia e classe derivata.

Cosa capisci dell'ereditarietà ibrida?

L'ereditarietà ibrida è un tipo unico di eredità. Piuttosto che avere un nuovo concetto, come suggerisce il nome, è una combinazione di due o più tipi di eredità. Ad esempio, una classe che mostra ereditarietà multiple e multilivello è un esempio di ereditarietà ibrida.

Cosa sai sui modificatori di accesso in Python?

In Python, ci sono 3 tipi di modificatori di accesso menzionati di seguito:
1. Modificatore di accesso pubblico - I membri Public di una classe sono accessibili da qualsiasi parte del programma. In Python, se l'identificatore di accesso dei membri dati o delle funzioni membro non è specificato, allora è pubblico per impostazione predefinita.
2. Modificatore di accesso protetto - Se un membro dati o una funzione membro è definito come protetto, è accessibile solo dalle classi derivate di quella classe.
3. Modificatore di accesso privato - Il modificatore di accesso privato è lo specificatore di accesso più sicuro. I membri privati ​​sono accessibili solo all'interno della classe in cui sono definiti.