0Pricing
Python Academy · Lektion

Wie Python-Klassen erstellt werden

Verstehen Sie type, die Standard-Metaklasse und Hooks zur Klassenerstellung.

Wie Python-Klassen erstellt werden ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

type() ist eine Metaklasse

Jede Klasse in Python ist eine Instanz von type. type ist selbst eine Klasse – und damit die Metaklasse aller Metaklassen.

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

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

Dreiargumentige Form von type()

type(name, bases, namespace) erstellt dynamisch eine neue Klasse. Genau das bewirken class-Anweisungen im Hintergrund.

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

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

Schritte der Klassenerstellung

Wenn Python eine class-Anweisung findet, führt es folgende Schritte aus: 1) Es löst die Metaklasse auf, 2) bereitet den Namespace vor, 3) führt den Klassenkörper aus und 4) ruft metaclass(name, bases, namespace) auf.

# 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) ist eine Klassenmethode der Metaklasse, die das Namespace-Dictionary zurückgibt, das während der Ausführung des Klassenkörpers verwendet wird. Überschreiben Sie die Methode, um ein OrderedDict oder ein benutzerdefiniertes Mapping zu verwenden.

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__ erstellt das Klassenobjekt, type.__init__ initialisiert es. Überschreiben Sie bei Metaklassen __new__, um die Klassenerstellung anzupassen.

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

Klassendekoratoren vs. Metaklassen

Klassendekoratoren werden nach der Erstellung angewendet, während Metaklassen die Erstellung selbst steuern. Für einfache Erweiterungen sollten Sie Dekoratoren bevorzugen. Verwenden Sie Metaklassen, wenn Sie den Erstellungsprozess beeinflussen müssen.

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__ wird auf der Basisklasse aufgerufen, sobald eine Unterklasse definiert wird. Das ist eine leichtgewichtige Alternative zu Metaklassen, um das Verhalten von Unterklassen anzupassen.

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 ist eine integrierte Metaklasse, über die abstrakte Basisklassen mithilfe von @abstractmethod umgesetzt werden.

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

Die Metaklasse einer Klasse untersuchen

Verwenden Sie type(cls), um die Metaklasse einer Klasse zu ermitteln, und cls.__mro__, um die Reihenfolge der Methodenauflösung anzuzeigen.

class Meta(type): pass

class Foo(metaclass=Meta): pass

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

Vererbung von Metaklassen

Die Metaklasse einer Klasse wird von ihren Unterklassen geerbt. Wenn zwei Basisklassen unterschiedliche Metaklassen haben, muss die am weitesten abgeleitete verwendet werden, andernfalls tritt ein Konflikt auf.

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'>

Wann Sie Metaklassen verwenden sollten

Verwenden Sie Metaklassen, um Unterklassen automatisch zu registrieren, Klasseninvarianten durchzusetzen, ORM-Felder zu erkennen (wie bei Djangos Model) und das Routing von API-Frameworks umzusetzen. In den meisten Fällen sollten Sie stattdessen __init_subclass__ oder Klassendekoratoren verwenden.

# 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

Wissenscheck

Was bewirkt type("Dog", (Animal,), {"speak": lambda self: "woof"})?

Zusammenfassung

Jede Klasse ist eine Instanz von type. Die Pipeline der Klassenerstellung: Metaklasse auflösen → Namespace vorbereiten → Klassenkörper ausführen → Metaklasse aufrufen. Bevorzugen Sie __init_subclass__ für einfache Hooks von Unterklassen und verwenden Sie eine vollständige Metaklasse nur dann, wenn Sie die Klassenerstellung selbst steuern müssen.

Häufig gestellte Fragen

Ist die Lektion „Wie Python-Klassen erstellt werden“ kostenlos?

Ja — der vollständige Text von „Wie Python-Klassen erstellt werden“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Wie Python-Klassen erstellt werden“?

Verstehen Sie type, die Standard-Metaklasse und Hooks zur Klassenerstellung. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Wie Python-Klassen erstellt werden“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Wie Python-Klassen erstellt werden
  2. Benutzerdefinierte Metaklassen schreiben
  3. Deskriptoren: __get__, __set__, __delete__
  4. __slots__ und Speicheroptimierung
← Zurück zu Python Academy