Python Academy · Lezione

Ereditarietà singola

Crei classi figlie che ereditano attributi e metodi da una classe genitrice.

Ereditarietà singola è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 1 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

L'ereditarietà consente a una classe figlia di riutilizzare ed estendere il comportamento di una classe padre senza duplicare il codice.

Definizione di una classe figlia

class Dog(Animal): eredita tutto da Animal. La classe figlia può aggiungere nuovi metodi o sovrascrivere quelli esistenti.

class Animal:
    def __init__(self, name): self.name = name
    def speak(self): return '...'
class Dog(Animal):
    def speak(self): return 'Woof'
d = Dog('Rex')
print(d.name, d.speak())

Chiamata di super().init

super().__init__(args) chiama __init__ della classe padre. Lo chiami sempre nella classe figlia quando la classe padre contiene una logica di configurazione.

class Animal:
    def __init__(self, name): self.name = name
class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name)
        self.breed = breed
d = Dog('Rex', 'Labrador')
print(d.name, d.breed)

Ereditarietà dei metodi

La classe figlia eredita tutti i metodi della classe padre. Se non li sovrascrive, funzionano senza modifiche.

class Vehicle:
    def start(self): return 'starting'
class Car(Vehicle):
    pass
print(Car().start())

Sovrascrittura dei metodi

Definisca nella classe figlia un metodo con lo stesso nome per sostituire la versione della classe padre. Viene chiamata la versione della classe figlia.

class Shape:
    def area(self): return 0
class Square(Shape):
    def __init__(self, s): self.s = s
    def area(self): return self.s**2
print(Square(4).area())

Estensione del comportamento della classe padre

Chiami super().method() all'interno della sovrascrittura per eseguire prima la versione della classe padre e poi aggiungere altro comportamento.

class Animal:
    def describe(self): return 'I am an animal'
class Dog(Animal):
    def describe(self): return super().describe() + ' and a dog'
print(Dog().describe())

isinstance() e issubclass()

isinstance(obj, Parent) restituisce True anche per le istanze delle classi figlie. issubclass(Child, Parent) verifica la gerarchia delle classi.

class Animal: pass
class Dog(Animal): pass
d = Dog()
print(isinstance(d, Animal))
print(issubclass(Dog, Animal))

Nuovi metodi nella classe figlia

La classe figlia può definire metodi completamente nuovi, che la classe padre non possiede.

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

Attributi protetti

La convenzione _name segnala «non accedere dall'esterno della classe». Le sottoclassi POSSONO utilizzarli.

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

Classi base astratte

from abc import ABC, abstractmethod obbliga le sottoclassi a implementare i metodi.

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self): pass
class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self):
        import math
        return math.pi * self.r**2
print(Circle(3).area())

bases e mro

Dog.__bases__ mostra le classi padre dirette. Dog.__mro__ mostra l'ordine completo di risoluzione dei metodi.

class A: pass
class B(A): pass
class C(B): pass
print(C.__mro__)

Controllo rapido

Che cosa fa super().__init__() in una classe figlia?

Ripasso

Ereditarietà: class Child(Parent). super() consente di accedere alla classe padre. Sovrascriva i metodi per modificare il comportamento. isinstance() verifica la gerarchia. ABC impone contratti astratti.

Continui

Ottimi progressi! Continui per padroneggiare il prossimo concetto.

Domande Frequenti

La lezione «Ereditarietà singola» è gratuita?

Sì — il testo completo di «Ereditarietà singola» è 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à singola»?

Crei classi figlie che ereditano attributi e metodi da una classe genitrice. 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 1 di 4.

Quanto tempo richiede la lezione «Ereditarietà singola»?

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