Python Academy · Lezione

Override dei metodi e super()

Sovrascriva i metodi della classe genitrice e li richiami con super().

Override dei metodi e super() è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 2 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

La sovrascrittura dei metodi consente alle classi figlie di personalizzare il comportamento ereditato. super() consente di chiamare l'implementazione originale.

Basi della sovrascrittura

Definisca nella classe figlia un metodo con lo stesso nome per sostituire la versione della classe padre per tutte le istanze della classe figlia.

class Greeter:
    def greet(self): return 'Hello'
class FormalGreeter(Greeter):
    def greet(self): return 'Good day'
print(FormalGreeter().greet())

super() nelle sovrascritture

super().greet() all'interno della classe figlia chiama la versione della classe padre. È utile per estendere il comportamento, non per sostituirlo completamente.

class Logger:
    def log(self, msg): print(f'[LOG] {msg}')
class TimedLogger(Logger):
    def log(self, msg):
        import time
        super().log(f'{time.time():.0f}: {msg}')
TimedLogger().log('test')

super() in init

Chiami sempre super().__init__() nel __init__ della classe figlia per assicurarsi che venga eseguita l'inizializzazione della classe padre.

class Animal:
    def __init__(self, name): self.name = name
class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor
cat = Cat('Whiskers', True)
print(cat.name, cat.indoor)

super() con argomenti

super(ChildClass, self) è la forma esplicita, nello stile di Python 2. In Python 3, nella maggior parte dei casi è possibile utilizzare super() senza argomenti.

class A:
    def greet(self): return 'A'
class B(A):
    def greet(self): return super().greet() + 'B'
class C(B):
    def greet(self): return super().greet() + 'C'
print(C().greet())

Ereditarietà cooperativa

Nell'ereditarietà multipla, super() segue l'MRO. Ogni classe che chiama super() garantisce l'inizializzazione di tutte le classi della catena.

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

Sovrascrittura di str

Sovrascriva __str__ nella classe figlia per personalizzare la modalità di stampa delle istanze.

class Animal:
    def __init__(self, name): self.name = name
    def __str__(self): return f'Animal: {self.name}'
class Dog(Animal):
    def __str__(self): return f'Dog: {self.name}'
print(Dog('Rex'))

Pattern Template Method

La classe padre definisce lo scheletro dell'algoritmo; la classe figlia completa i passaggi sovrascrivendo metodi specifici.

class DataProcessor:
    def process(self):
        data = self.load()
        return self.transform(data)
    def load(self): return [1,2,3]
    def transform(self, d): return d
class Doubler(DataProcessor):
    def transform(self, d): return [x*2 for x in d]
print(Doubler().process())

Chiamata di un metodo di una classe affine

Con super() e un MRO corretto, nell'ereditarietà multipla può chiamare il metodo di una classe affine: si tratta dell'uso cooperativo di super().

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

__init_subclass__

__init_subclass__ viene chiamato ogni volta che la classe viene utilizzata come classe base. È utile per i pattern di registrazione dei plugin.

class Plugin:
    registry = []
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry.append(cls)
class A(Plugin): pass
class B(Plugin): pass
print([c.__name__ for c in Plugin.registry])

Quando NON sovrascrivere

Non sovrascriva un metodo se non deve modificare il comportamento. Le sovrascritture non necessarie aumentano il lavoro di manutenzione. Preferisca la composizione per comportamenti non correlati.

# Good: only override what's needed
class Dog(Animal):
    def speak(self): return 'Woof'
    # No need to override __init__ if parent's is fine
print('override guidance')

Controllo rapido

In Python 3, a che cosa fa riferimento super() (senza argomenti) all'interno di un metodo?

Ripasso

Sovrascriva ridefinendo il metodo nella classe figlia. super().method() chiama la versione della classe padre. super().__init__() inizializza la classe padre. super() cooperativo segue l'ordine MRO.

Continui

Ottimi progressi! Continui per padroneggiare il prossimo concetto.

Domande Frequenti

La lezione «Override dei metodi e super()» è gratuita?

Sì — il testo completo di «Override dei metodi e super()» è 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 «Override dei metodi e super()»?

Sovrascriva i metodi della classe genitrice e li richiami con super(). 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 2 di 4.

Quanto tempo richiede la lezione «Override dei metodi e super()»?

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