Ereditarietà multipla in Python

In questo articolo, imparerai cosa è l'ereditarietà multipla in Python e come utilizzarla nei programmi. Inoltre, imparerai l'ereditarietà a più livelli e l'ordine di risoluzione dei metodi.

Ereditarietà multipla in Python

Come in C++, unClassePuò derivare da più classi base in Python. Questo si chiama ereditarietà multipla.

Nell'ereditarietà multipla, tutte le funzionalità delle classi base vengono ereditate nella classe derivata. La sintassi dell'ereditarietà multipla è simile a quella dell'ereditarietà singolaEreditarietà.

Esempio

class Base1:
　　　　pass
class Base2:
　　　　pass
class MultiDerived(Base1, Base2):
　　　　pass

In questo caso,MultiDerivedProviene dalla classeBase1eBase2.

La classe MultiDerived deriva da Base1 e Base2.

Ereditarietà a più livelli in Python

D'altra parte, possiamo anche ereditare la classe derivata. Questo si chiama ereditarietà a più livelli. In Python può essere di qualsiasi profondità.

Nell'ereditarietà a più livelli, le funzionalità delle classi base e derivate vengono ereditate nella nuova classe derivata.

Di seguito è riportato un esempio con l'effetto visivo corrispondente.

class Base:
　　　　pass
class Derived1(Base):
　　　　pass
class Derived2(Derived1):
　　　　pass

In questo caso,Derived1DaBaseDerivazione,Derived2DaDerived1Derivazione.

Ordine di risoluzione dei metodi in Python

Ogni classe in Python deriva da questa classe object. È il tipo più fondamentale di Python.

Dunque, tecnicamente, tutte le altre classi (primitivi o definite dall'utente) sono classi derivate, e tutti gli oggetti sono esempi della classe object.

# Output: True
print(issubclass(list, object))
# Output: True
print(isinstance(5.5, object))
# Output: True
print(isinstance("Hello", object))

Nel caso di ereditarietà multipla, qualsiasi proprietà specificata verrà cercata prima nella classe corrente. Se non viene trovata, la ricerca continuerà in modo profondo e da sinistra a destra entrando nei genitori della classe senza dover cercare la stessa classe due volte.

Quindi, nell'esempio sopra, l'ordine di ricerca della classe MultiDerived è [MultiDerived, Base1, Base2, object]. Questo ordine è anche noto come la linearizzazione della classe MultiDerived, e il set di regole per trovare questo ordine si chiama “ Ordine di risoluzione dei metodi (MRO)).

L'MRO deve prevenire l'ordinamento di priorità locale e deve fornire monotonia. Può garantire che una classe compaia sempre prima dei suoi superclasse, e se ci sono più superclasse, l'ordine è lo stesso del tuple delle superclassi di base.

Si può considerare l'MRO di una classe come l'attributo __mro__ o il metodo mro(). Il primo restituisce un tuple, mentre l'altro restituisce una lista.

>>> MultiDerived.__mro__
(<class '__main__.MultiDerived'>,
　# <class '__main__.Base1'>,
　# <class '__main__.Base2'>,
　# <class 'object'>)
>>> MultiDerived.mro()
[<class '__main__.MultiDerived'>,
　# <class '__main__.Base1'>,
　# <class '__main__.Base2'>,
　# <class 'object'>]

Questo è un esempio di ereditarietà multipla leggermente più complessa, la sua visualizzazione e MRO.

class X: pass
class Y: pass
class Z: pass
class A(X, Y): pass
class B(Y, Z): pass
class M(B, A, Z): pass
# Output:
# [<class '__main__.M'>, <class '__main__.B'>,
# <class '__main__.A'>, <class '__main__.X'>,
# <class '__main__.Y'>, <class '__main__.Z'>,
# <class 'object'>]
print(M.mro())

Riferiti a questo contenuto per ulterioriDiscussione MROe comprendere il modo di calcolo effettivo degli algoritmi.