In Python, la funzione super() viene utilizzata per fare riferimento alla classe genitore o alla superclasse. Ti consente di chiamare i metodi definiti nella superclasse dalla sottoclasse, consentendoti di estendere e personalizzare la funzionalità ereditata dalla classe genitore.
Sintassi di super() in Python
Sintassi: super()
Ritorno : Restituisce un oggetto proxy che rappresenta la classe del genitore.
Funzione super() nell'esempio di Python
Nell'esempio fornito, The Imp la classe ha un __caldo__ metodo che inizializza il file id , E nome E Aggiunge attributi. IL Libero professionista la classe eredita da Imp class e aggiunge un attributo aggiuntivo chiamato E-mail. Chiama il metodo __init__ super() della classe genitore per inizializzare l'attributo ereditato.
Python3
class> Emp():> >def> __init__(>self>,>id>, name, Add):> >self>.>id> => id> >self>.name>=> name> >self>.Add>=> Add> # Class freelancer inherits EMP> class> Freelance(Emp):> >def> __init__(>self>,>id>, name, Add, Emails):> >super>().__init__(>id>, name, Add)> >self>.Emails>=> Emails> Emp_1>=> Freelance(>103>,>'Suraj kr gupta'>,>'Noida'> ,>'KKK@gmails'>)> print>(>'The ID is:'>, Emp_1.>id>)> print>(>'The Name is:'>, Emp_1.name)> print>(>'The Address is:'>, Emp_1.Add)> print>(>'The Emails is:'>, Emp_1.Emails)> |
>
>
Produzione :
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails>
A cosa serve il metodo super()?
Un metodo da una classe genitore può essere chiamato in Python usando la funzione super(). È una pratica tipica in programmazione orientata agli oggetti per chiamare i metodi della superclasse e abilitare l'override e l'ereditarietà del metodo. Anche se la classe corrente ha sostituito questi metodi con la propria implementazione, chiamare super() ti consente di accedere e utilizzare i metodi della classe genitore. In questo modo, puoi migliorare e modificare il comportamento della classe genitore pur continuando a trarne vantaggio.
Vantaggi della Super Funzione
- Non è necessario ricordare o specificare il nome della classe genitore per accedere ai suoi metodi. Questa funzione può essere utilizzata sia nelle eredità singole che multiple.
- Ciò implementa la modularità (isolamento delle modifiche) e la riusabilità del codice poiché non è necessario riscrivere l'intera funzione.
- La super funzione in Python viene chiamata dinamicamente perché Python è un linguaggio dinamico, a differenza di altri linguaggi.
Come funziona l'ereditarietà senza Python Super?
Nell'esempio fornito, c'è un problema con il metodo __init__ della classe Emp. La classe Emp è ereditata dalla classe Person, ma nel suo metodo __init__ non chiama il metodo __init__ della classe genitore per inizializzare gli attributi name e id.
Python3
# code> class> Person:> ># Constructor> >def> __init__(>self>, name,>id>):> >self>.name>=> name> >self>.>id> => id> ># To check if this person is an employee> >def> Display(>self>):> >print>(>self>.name,>self>.>id>)> > class> Emp(Person):> > >def> __init__(>self>, name,>id>):> >self>.name_>=> name> >def> Print>(>self>):> >print>(>'Emp class called'>)> Emp_details>=> Emp(>'Mayank'>,>103>)> # calling parent class function> Emp_details.name_, Emp_details.name> |
>
>
sottostringa della stringa Java
Produzione :
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) in 24 25 # calling parent class function --->26 Emp_details.name_, Emp_details.name AttributeError: l'oggetto 'Emp' non ha attributo 'name'>
Risolvere il problema precedente con Super in Python
Nel codice fornito, la classe Emp eredita correttamente dalla classe Person e il metodo __init__ della classe Emp ora chiama correttamente il metodo __init__ della classe genitore utilizzando super() in Python.
Python3
# code> # A Python program to demonstrate inheritance> class> Person:> ># Constructor> >def> __init__(>self>, name,>id>):> >self>.name>=> name> >self>.>id> => id> ># To check if this person is an employee> >def> Display(>self>):> >print>(>self>.name,>self>.>id>)> > class> Emp(Person):> > >def> __init__(>self>, name,>id>):> >self>.name_>=> name> >super>().__init__(name,>id>)> >def> Print>(>self>):> >print>(>'Emp class called'>)> Emp_details>=> Emp(>'Mayank'>,>103>)> # calling parent class function> print>(Emp_details.name_, Emp_details.name)> |
>
>
Produzione :
Mayank Mayank>
Comprendere Python super() con i metodi __init__()
Python ha un metodo riservato chiamato __init__. Nella programmazione orientata agli oggetti viene chiamato costruttore. Quando viene chiamato questo metodo, consente alla classe di inizializzare gli attributi della classe. In una sottoclasse ereditata, è possibile fare riferimento a una classe genitore utilizzando la funzione super(). La super funzione restituisce un oggetto temporaneo della superclasse che consente l'accesso a tutti i suoi metodi alla sua classe figlia.
Nota: Per ulteriori informazioni, fare riferimento a Ereditarietà in Python .
Super funzione con ereditarietà singola
Prendiamo l’esempio degli animali. Cani, gatti e mucche fanno parte degli animali. Condividono anche caratteristiche comuni come:
- Sono mammiferi.
- Hanno una coda e quattro zampe.
- Sono animali domestici.
Quindi, le classi cani, gatti e cavalli sono una sottoclasse della classe animale. Questo è un esempio di ereditarietà singola perché molte sottoclassi vengono ereditate da una classe con un solo genitore.
Python3
# Python program to demonstrate> # super function> class> Animals:> ># Initializing constructor> >def> __init__(>self>):> >self>.legs>=> 4> >self>.domestic>=> True> >self>.tail>=> True> >self>.mammals>=> True> >def> isMammal(>self>):> >if> self>.mammals:> >print>(>'It is a mammal.'>)> >def> isDomestic(>self>):> >if> self>.domestic:> >print>(>'It is a domestic animal.'>)> class> Dogs(Animals):> >def> __init__(>self>):> >super>().__init__()> >def> isMammal(>self>):> >super>().isMammal()> class> Horses(Animals):> >def> __init__(>self>):> >super>().__init__()> >def> hasTailandLegs(>self>):> >if> self>.tail>and> self>.legs>=>=> 4>:> >print>(>'Has legs and tail'>)> # Driver code> Tom>=> Dogs()> Tom.isMammal()> Bruno>=> Horses()> Bruno.hasTailandLegs()> |
>
>
Produzione :
It is a mammal. Has legs and tail>
Super con eredità multiple
Prendiamone un altro esempio di superfunzione , Supponiamo che una classe può volare E puo nuotare ereditano da una classe di mammiferi e queste classi sono ereditate dalla classe di animali. Quindi la classe animale eredita dalle molteplici classi base. Vediamo l'utilizzo di Pitone super con argomenti in questo caso.
Python3
copertina rigida o tascabile
class> Mammal():> >def> __init__(>self>, name):> >print>(name,>'Is a mammal'>)> class> canFly(Mammal):> >def> __init__(>self>, canFly_name):> >print>(canFly_name,>'cannot fly'>)> ># Calling Parent class> ># Constructor> >super>().__init__(canFly_name)> class> canSwim(Mammal):> >def> __init__(>self>, canSwim_name):> >print>(canSwim_name,>'cannot swim'>)> >super>().__init__(canSwim_name)> class> Animal(canFly, canSwim):> >def> __init__(>self>, name):> >super>().__init__(name)> # Driver Code> Carol>=> Animal(>'Dog'>)> |
>
>
Produzione :
La classe Animal eredita da classi a due genitori: canFly e canSwim. Pertanto, l'istanza della sottoclasse Carol può accedere a entrambi i costruttori della classe genitore.
Dog cannot fly Dog cannot swim Dog Is a mammal>
Super con ereditarietà multilivello
Prendiamone un altro esempio di superfunzione , supponiamo che una classe sappia nuotare sia ereditata da canFly, canFly dalla classe mammifero. Quindi la classe dei mammiferi eredita dall'eredità multilivello. Vediamo l'utilizzo di Pitone super con argomenti in questo caso.
Python3
class> Mammal():> >def> __init__(>self>, name):> >print>(name,>'Is a mammal'>)> class> canFly(Mammal):> >def> __init__(>self>, canFly_name):> >print>(canFly_name,>'cannot fly'>)> ># Calling Parent class> ># Constructor> >super>().__init__(canFly_name)> class> canSwim(canFly):> >def> __init__(>self>, canSwim_name):> >print>(canSwim_name,>'cannot swim'>)> >super>().__init__(canSwim_name)> class> Animal(canSwim):> >def> __init__(>self>, name):> ># Calling the constructor> ># of both the parent> ># class in the order of> ># their inheritance> >super>().__init__(name)> # Driver Code> Carol>=> Animal(>'Dog'>)> |
>
>
Produzione :
Dog cannot swim Dog cannot fly Dog Is a mammal>
Eredità multipla di Python e MRO
Nell'esempio fornito, la classe C eredita dalle classi A e B e sovrascrive il metodo age(). Tuttavia, nel metodo age() della classe C, la riga super(C, self).age() richiama il metodo age() dalla classe successiva in MRO. In questo caso, invocherà il metodo age() dalla classe A poiché appare prima della classe B nell'MRO.
Python3
dimensioni del testo in lattice
class> A:> >def> age(>self>):> >print>(>'Age is 21'>)> class> B:> >def> age(>self>):> >print>(>'Age is 23'>)> class> C(A, B):> >def> age(>self>):> >super>(C,>self>).age()> > c>=> C()> print>(C.__mro__)> print>(C.mro())> |
>
>
Produzione :
(, , , ) [, , , ]>