0Pricing
Python Academy · Lezione

Come vengono create le classi Python

Comprenda type, la metaclasse predefinita e gli hook per la creazione delle classi.

Come vengono create le classi Python è 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.

type() è una metaclasse

Ogni classe in Python è un'istanza di type. type è a sua volta una classe: è la metaclasse di tutte le metaclassi.

# These are equivalent:
class Dog:
    sound = "woof"

Dog2 = type("Dog2", (), {"sound": "woof"})
print(type(Dog))    # <class 'type'>
print(type(Dog2))   # <class 'type'>

Forma a tre argomenti di type()

type(name, bases, namespace) crea dinamicamente una nuova classe. È esattamente ciò che le istruzioni class fanno internamente.

Animal = type("Animal", (), {"speak": lambda self: "..."})
Dog = type("Dog", (Animal,), {"speak": lambda self: "woof"})

d = Dog()
print(d.speak())   # woof

Passaggi della creazione di una classe

Quando Python incontra un'istruzione class: 1) risolve la metaclasse, 2) prepara lo spazio dei nomi, 3) esegue il corpo della classe, 4) chiama metaclass(name, bases, namespace).

# class Foo(Base, metaclass=Meta):
#   x = 1
#
# Equivalent to:
# namespace = Meta.__prepare__("Foo", (Base,))
# exec(class_body, namespace)
# Foo = Meta("Foo", (Base,), namespace)

__prepare__

__prepare__(name, bases, **kw) è un metodo di classe della metaclasse che restituisce il dizionario dello spazio dei nomi utilizzato durante l'esecuzione del corpo della classe. Lo sovrascriva per utilizzare un OrderedDict o una mappatura personalizzata.

class OrderedMeta(type):
    @classmethod
    def __prepare__(mcs, name, bases, **kw):
        print(f"Preparing namespace for {name}")
        return {}

class MyClass(metaclass=OrderedMeta):
    x = 1
    y = 2

__new__ vs __init__ in type

type.__new__ crea l'oggetto classe, mentre type.__init__ lo inizializza. Per le metaclassi, sovrascriva __new__ per personalizzare la creazione della classe.

class Singleton(type):
    _instances = {}

    def __call__(cls, *args, **kw):
        if cls not in cls._instances:
            cls._instances[cls] = super().__call__(*args, **kw)
        return cls._instances[cls]

class DB(metaclass=Singleton):
    pass

print(DB() is DB())  # True

Decorator di classe vs metaclassi

I decorator di classe vengono applicati dopo la creazione, mentre le metaclassi controllano la creazione stessa. Per semplici estensioni, preferisca i decorator. Utilizzi le metaclassi quando deve influire sul processo di creazione.

def add_repr(cls):
    cls.__repr__ = lambda self: f"{cls.__name__}()"
    return cls

@add_repr
class Widget:
    pass

print(Widget())  # Widget()

__init_subclass__

__init_subclass__ viene chiamato sulla classe base ogni volta che viene definita una sottoclasse. È un'alternativa leggera alle metaclassi per personalizzare il comportamento delle sottoclassi.

class Plugin:
    _registry = []

    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin._registry.append(cls)

class AudioPlugin(Plugin): pass
class VideoPlugin(Plugin): pass

print(Plugin._registry)  # [AudioPlugin, VideoPlugin]

ABCMeta

ABCMeta è una metaclasse integrata che abilita le classi base astratte tramite @abstractmethod.

from abc import ABCMeta, abstractmethod

class Shape(metaclass=ABCMeta):
    @abstractmethod
    def area(self): ...

class Circle(Shape):
    def __init__(self, r): self.r = r
    def area(self): return 3.14159 * self.r ** 2

# Shape()  # TypeError: Can't instantiate abstract class

Ispezione della metaclasse di una classe

Utilizzi type(cls) per trovare la metaclasse di una classe e cls.__mro__ per visualizzare l'ordine di risoluzione dei metodi.

class Meta(type): pass

class Foo(metaclass=Meta): pass

print(type(Foo))       # <class '__main__.Meta'>
print(Foo.__mro__)     # (Foo, object)

Ereditarietà delle metaclassi

La metaclasse di una classe viene ereditata dalle sue sottoclassi. Se due classi base hanno metaclassi diverse, è necessario utilizzare quella più derivata, altrimenti si verifica un conflitto.

class MyMeta(type): pass

class Base(metaclass=MyMeta): pass
class Child(Base): pass   # Child's metaclass is also MyMeta

print(type(Child))   # <class '__main__.MyMeta'>

Quando utilizzare le metaclassi

Utilizzi le metaclassi per registrare automaticamente le sottoclassi, imporre invarianti di classe, rilevare i campi ORM, come nel Model di Django, e gestire il routing dei framework API. Nella maggior parte dei casi, utilizzi invece __init_subclass__ o i decorator di classe.

# Real-world: Django ORM uses ModelBase metaclass
# to collect field definitions into _meta

# You rarely need a custom metaclass;
# __init_subclass__ covers most plugin/registration patterns

Verifica rapida

Che cosa fa type("Dog", (Animal,), {"speak": lambda self: "woof"})?

Riepilogo

Ogni classe è un'istanza di type. La pipeline di creazione della classe è: risoluzione della metaclasse → preparazione dello spazio dei nomi → esecuzione del corpo → chiamata della metaclasse. Preferisca __init_subclass__ per semplici hook delle sottoclassi; utilizzi una metaclasse completa solo quando deve controllare direttamente la creazione della classe.

Domande Frequenti

La lezione «Come vengono create le classi Python» è gratuita?

Sì — il testo completo di «Come vengono create le classi Python» è 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 «Come vengono create le classi Python»?

Comprenda type, la metaclasse predefinita e gli hook per la creazione delle classi. 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 «Come vengono create le classi Python»?

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

  1. Come vengono create le classi Python
  2. Scrittura di metaclassi personalizzate
  3. Descriptor: __get__, __set__, __delete__
  4. __slots__ e ottimizzazione della memoria
← Torna a Python Academy