Python Academy · Lezione

Ereditarietà multipla e MRO

Comprenda l'ereditarietà multipla e la MRO di Python (linearizzazione C3).

Lezione 3 di 414 passaggi

Ereditarietà multipla e MRO è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Introduzione

Python supporta l'ereditarietà multipla. L'ordine di risoluzione dei metodi (MRO) stabilisce quale metodo viene chiamato quando i nomi coincidono.

Sintassi dell'ereditarietà multipla

class C(A, B): eredita sia da A sia da B. C riceve tutti i metodi di entrambe.

class A:
    def hello(self): return 'A'
class B:
    def world(self): return 'B'
class C(A, B): pass
c = C()
print(c.hello(), c.world())

Ordine di risoluzione dei metodi (MRO)

L'MRO definisce l'ordine di ricerca. C.__mro__ mostra l'ordine: C, A, B, object. Vince la prima classe che contiene un metodo corrispondente.

class A:
    def greet(self): return 'A'
class B:
    def greet(self): return 'B'
class C(A, B): pass
print(C().greet())  # A wins
print(C.__mro__)

Linearizzazione C3

Python utilizza la linearizzazione C3 per calcolare l'MRO. Garantisce che la classe figlia preceda la classe padre e che le classi base multiple vengano considerate da sinistra a destra.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print([c.__name__ for c in D.__mro__])

Ereditarietà a diamante

D(B,C), dove B e C ereditano entrambe da A, rappresenta il problema del diamante. C3 garantisce che __init__ di A venga chiamato una sola volta.

class A:
    def __init__(self): print('A')
class B(A):
    def __init__(self): super().__init__(); print('B')
class C(A):
    def __init__(self): super().__init__(); print('C')
class D(B, C):
    def __init__(self): super().__init__(); print('D')
D()

Mixin

Un mixin è una classe progettata per l'ereditarietà multipla. Aggiunge metodi senza costituire da sola una classe completa.

class JSONMixin:
    def to_json(self):
        import json
        return json.dumps(vars(self))
class User(JSONMixin):
    def __init__(self, name, age): self.name,self.age=name,age
print(User('Alice', 30).to_json())

Regole di progettazione dei mixin

I mixin dovrebbero: non avere __init__, non ereditare da classi non-mixin e svolgere una sola funzione. Li denomini con il suffisso Mixin.

class LoggingMixin:
    def log(self, msg): print(f'[{self.__class__.__name__}] {msg}')
class Service(LoggingMixin):
    def run(self): self.log('running')
Service().run()

super() nell'ereditarietà multipla

super() chiama la classe successiva nell'MRO, non necessariamente la classe padre diretta. Ogni classe deve chiamare super() per garantire un comportamento cooperativo.

class Base:
    def action(self): return 'Base'
class A(Base):
    def action(self): return 'A->' + super().action()
class B(Base):
    def action(self): return 'B->' + super().action()
class C(A, B):
    def action(self): return 'C->' + super().action()
print(C().action())

type() per la creazione dinamica di classi

type('NewClass', (Base,), {'method': fn}) crea dinamicamente una classe. È utile per la metaprogrammazione.

def hello(self): return 'hello'
MyClass = type('MyClass', (object,), {'hello': hello})
print(MyClass().hello())

Verifica dell'MRO

ClassName.__mro__ o inspect.getmro(ClassName) mostra l'ordine di risoluzione come tupla di classi.

class A: pass
class B(A): pass
class C(B): pass
import inspect
print([c.__name__ for c in inspect.getmro(C)])

Quando evitare l'ereditarietà multipla

Le gerarchie complesse con ereditarietà multipla sono difficili da comprendere. Preferisca la composizione o semplici mixin alle gerarchie profonde.

# Prefer:
class User:
    def __init__(self, name, logger):
        self.name = name
        self.logger = logger  # composition
print('composition preferred')

Controllo rapido

Quale algoritmo utilizza Python per calcolare il Method Resolution Order?

Rispondi nella lezione interattiva

Riepilogo

Ereditarietà multipla: class C(A, B). L'MRO, determinato dalla linearizzazione C3, stabilisce la ricerca dei metodi. Utilizzi i mixin per ottenere un'ereditarietà multipla chiara. super() segue l'MRO.

Continui

Ottimi progressi! Continui per padroneggiare il prossimo concetto.

Gratis per iniziare

Impara Python con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 76
Lezioni: 320

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Ereditarietà multipla e MRO» è gratuita?

Sì — il testo completo di «Ereditarietà multipla e MRO» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Ereditarietà multipla e MRO»?

Comprenda l'ereditarietà multipla e la MRO di Python (linearizzazione C3). Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Ereditarietà multipla e MRO»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Python Academy