Eigene Metaklassen erstellen
In Python können wir den Prozess der Klassenerzeugung anpassen, indem wir das Schlüsselwort metaclass in der Klassendefinition verwenden. Das funktioniert auch, indem wir von einer Klasse erben, die dieses Schlüsselwort bereits gesetzt hat.
class MyMeta(type):
pass
class MyClass(metaclass=MyMeta):
pass
class MySubclass(MyClass):
pass
Unten sehen wir, dass der Typ der Klasse MyMeta type ist und dass der Typ von MyClass und MySubClass MyMeta ist.
print(type(MyMeta))
print(type(MyClass))
print(type(MySubclass))
<class 'type'>
<class '__main__.MyMeta'>
<class '__main__.MyMeta'>
Wird eine Klasse ohne Metaklasse definiert, verwendet Python standardmäßig die Metaklasse type. Wenn eine Metaklasse angegeben ist und sie keine Instanz von type() ist, wird sie direkt als Metaklasse verwendet.
__new__ und __init__
Metaklassen können auf zwei Arten wie unten gezeigt definiert werden. Den Unterschied erklären wir im Anschluss.
class MetaOne(type):
def __new__(cls, name, bases, dict):
pass
class MetaTwo(type):
def __init__(self, name, bases, dict):
pass
__new__ wird genutzt, wenn man dict oder das bases-Tuple festlegen möchte, bevor die Klasse erzeugt wird. Der Rückgabewert von __new__ ist üblicherweise eine Instanz von cls. __new__ erlaubt Unterklassen unveränderlicher Typen, die Instanzerzeugung anzupassen. In benutzerdefinierten Metaklassen kann es überschrieben werden, um die Klassenerzeugung zu steuern. __init__ wird in der Regel aufgerufen, nachdem das Objekt erstellt wurde, um es zu initialisieren.
Metaklassen-Methode __call__
Laut der offiziellen Dokumentation können wir auch andere Klassenmethoden überschreiben, indem wir in der Metaklasse eine eigene __call__()-Methode definieren, die benutzerdefiniertes Verhalten beim Aufruf der Klasse ermöglicht.
Metaklassen-Methode __prepare__
Nach Pythons Data-Model-Dokumentation
Sobald die passende Metaklasse ermittelt wurde, wird der Klassen-Namespace vorbereitet. Wenn die Metaklasse ein Attribut __prepare__ hat, wird es wie folgt aufgerufen: namespace = metaclass.__prepare__(name, bases, **kwds) (weitere Schlüsselwortargumente stammen aus der Klassendefinition). Hat die Metaklasse kein __prepare__-Attribut, wird der Klassen-Namespace als leeres geordnetes Mapping initialisiert. - docs.python.org
Singleton-Pattern mit einer Metaklasse
Dieses Entwurfsmuster beschränkt die Instanziierung einer Klasse auf genau ein Objekt. Das ist zum Beispiel nützlich, wenn du eine Klasse für die Datenbankverbindung entwickelst und nur eine einzige Instanz dieser Verbindungsklasse haben möchtest.
class SingletonMeta(type):
_instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls._instances:
cls._instances[cls] = super(SingletonMeta,cls).__call__(*args, **kwargs)
return cls._instances[cls]
class SingletonClass(metaclass=SingletonMeta):
pass
Fazit
In diesem Artikel hast du gelernt, was Metaklassen sind und wie wir sie in Python einsetzen können. Metaklassen lassen sich unter anderem für Logging, die Registrierung von Klassen zur Erzeugungszeit oder für Profiling nutzen. Sie wirken recht abstrakt, und vielleicht fragst du dich, ob du sie überhaupt brauchst. Python-Veteran Tim Peters beantwortet das am treffendsten.
"Metaclasses are deeper magic than 99% of users should ever worry about. If you wonder whether you need them, you don’t (the people who actually need them know with certainty that they need them, and don’t need an explanation about why).” - realpython
Wenn du mehr über Python lernen möchtest, starte den Python Programming-Lernpfad von DataCamp und lies unser Python Classes Tutorial.

Eine Metaklasse in Python ist die Klasse einer Klasse und legt fest, wie sich eine Klasse verhält. Eine Klasse ist selbst eine Instanz einer Metaklasse. Eine Klasse in Python bestimmt, wie sich ihre Instanzen verhalten. Um Metaklassen wirklich zu verstehen, solltest du bereits mit Python-Klassen gearbeitet haben. Bevor wir tiefer einsteigen, räumen wir ein paar Grundbegriffe aus dem Weg.
Alles in Python ist ein Objekt
Python-Klassen lassen sich dynamisch erzeugen
typein Python erlaubt es uns, den Typ eines Objekts zu ermitteln. Schauen wir uns den Typ des oben erzeugten Objekts an.Moment, was ist da passiert? Wir würden erwarten, dass der Typ des oben erstellten Objekts „class“ ist – ist er aber nicht. Behalte den Gedanken kurz im Hinterkopf, wir kommen gleich darauf zurück. Außerdem sehen wir, dass der Typ von
typeselbsttypeist. Es ist also eine Instanz vontype. Ein weiterer „magischer“ Trick vontypeist, dass wir damit Klassen dynamisch erzeugen können. Unten zeigen wir, wie das geht. Die KlasseDataCampunten ließe sich mittypewie folgt erzeugen:Im obigen Beispiel ist
DataCampder Klassenname, währendDataCampClassdie Variablenreferenz auf die Klasse ist. Beim Einsatz vontypekönnen wir Attribute über ein Dictionary übergeben, wie hier gezeigt:Wenn unsere
PythonClassvon der KlasseDataCamperben soll, übergeben wir sie als zweites Argument bei der Definition mittype:Nachdem diese zwei Konzepte geklärt sind, erkennen wir: Python erstellt Klassen mithilfe einer Metaklasse. Wir haben gesehen, dass alles in Python ein Objekt ist – und diese Objekte werden von Metaklassen erzeugt. Immer wenn wir mit
classeine Klasse definieren, erzeugt im Hintergrund eine Metaklasse diese Klasse. Wir haben oben bereits gesehen, wietypedas praktisch übernimmt. Das ist vergleichbar mitstrfür Strings undintfür Ganzzahlen. In Python erlaubt uns das Attribut___class__, den Typ der aktuellen Instanz zu prüfen. Erstellen wir unten einen String und prüfen seinen Typ.Wir können den Typ auch mit
type(article)prüfen.Wenn wir den Typ von
strprüfen, stellen wir ebenfalls fest, dass ertypeist.Prüfen wir den Typ von
float,int,list,tupleunddict, erhalten wir ein ähnliches Ergebnis. Das liegt daran, dass all diese Objekte vom Typtypesind.Wir haben bereits gesehen, dass
typeKlassen erzeugt. Wenn wir also__class__von__class__prüfen, solltetypezurückgegeben werden.