Introductie tot Python-metaklassen

Aangepaste metaklassen maken

In Python kunnen we het aanmaakproces van een klasse aanpassen door het trefwoord metaclass in de klassedefinitie mee te geven. Dit kan ook door te erven van een klasse waarin dit trefwoord al is meegegeven.

class MyMeta(type):
    pass

class MyClass(metaclass=MyMeta):
    pass

class MySubclass(MyClass):
    pass
Mogelijk gemaakt door

Hieronder zie je dat het type van de klasse MyMeta type is en dat het type van MyClass en MySubClass MyMeta is.

print(type(MyMeta))
print(type(MyClass))
print(type(MySubclass))
Mogelijk gemaakt door

<class 'type'>
<class '__main__.MyMeta'>
<class '__main__.MyMeta'>
Mogelijk gemaakt door

Als je een klasse definieert en er is geen metaklas gedefinieerd, wordt standaard de metaklas type gebruikt. Als een metaklas is opgegeven en deze is geen instantie van type(), dan wordt die direct als metaklas gebruikt.

__new__ en __init__

Metaklassen kunnen ook op een van de twee onderstaande manieren worden gedefinieerd. We leggen hieronder het verschil tussen beide uit.

class MetaOne(type):
    def __new__(cls, name, bases, dict):
        pass

class MetaTwo(type):
    def __init__(self, name, bases, dict):
        pass
Mogelijk gemaakt door

__new__ wordt gebruikt wanneer je de dict of bases-tuple wilt definiëren voordat de klasse wordt aangemaakt. De retourwaarde van __new__ is meestal een instantie van cls. __new__ stelt subklassen van onveranderlijke typen in staat om het aanmaken van instanties aan te passen. Het kan in aangepaste metaklassen worden overschreven om de klassecreatie te beïnvloeden. __init__ wordt meestal aangeroepen nadat het object is aangemaakt om het te initialiseren.

Metaklasmethode __call__

Volgens de officiële documentatie kunnen we ook andere klassemethode overschrijven door een aangepaste __call__()-methode in de metaklas te definiëren, die aangepast gedrag mogelijk maakt wanneer de klasse wordt aangeroepen.

Metaklasmethode __prepare__

Volgens Python's data model-docs

Zodra de juiste metaklas is bepaald, wordt de klassenamespace voorbereid. Als de metaklas een attribuut __prepare__ heeft, wordt dit aangeroepen als namespace = metaclass.__prepare__(name, bases, **kwds) (waarbij de extra keyword-argumenten, indien aanwezig, uit de klassedefinitie komen). Als de metaklas geen attribuut __prepare__ heeft, dan wordt de klassenamespace geïnitialiseerd als een lege geordende mapping. - docs.python.org

Singleton-ontwerp met een metaklas

Dit is een ontwerppatroon dat het instantiëren van een klasse beperkt tot slechts één object. Dit kan bijvoorbeeld handig zijn bij het ontwerpen van een klasse die verbinding maakt met de database. Je wilt misschien slechts één instantie van de verbindingsklasse hebben.

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
Mogelijk gemaakt door

Conclusie

In dit artikel hebben we geleerd wat metaklassen zijn en hoe we ze kunnen toepassen in onze Python-programmering. Metaklassen kun je onder andere gebruiken voor logging, het registreren van klassen tijdens het aanmaken en voor profiling. Het lijken vrij abstracte concepten, en je vraagt je misschien af of je ze überhaupt nodig hebt. Doorgewinterde Pythonista Tim Peters beantwoordt die vraag het best.

"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

Wil je meer leren over Python? Start dan met DataCamp's Python Programming skill track en bekijk onze Python Classes Tutorial.

Referenties

Link één

Link twee