Hoe Python-klassen worden gemaakt
U leert type, de standaardmetaklasse en hooks voor het maken van klassen begrijpen.
Hoe Python-klassen worden gemaakt is een gratis Python Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Python Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Python Academy bevat in totaal 4 lessen.
type() is een metaklasse
Elke klasse in Python is een instantie van type. type is zelf een klasse — het is de metaklasse van alle metaklassen.
# These are equivalent:
class Dog:
sound = "woof"
Dog2 = type("Dog2", (), {"sound": "woof"})
print(type(Dog)) # <class 'type'>
print(type(Dog2)) # <class 'type'>De vorm met drie argumenten van type()
type(name, bases, namespace) maakt dynamisch een nieuwe klasse. Dit is precies wat class-instructies onder de motorkap doen.
Animal = type("Animal", (), {"speak": lambda self: "..."})
Dog = type("Dog", (Animal,), {"speak": lambda self: "woof"})
d = Dog()
print(d.speak()) # woofStappen voor het aanmaken van een klasse
Wanneer Python een class-instructie ziet: 1) wordt de metaklasse bepaald, 2) wordt de naamruimte voorbereid, 3) wordt de klassebody uitgevoerd, 4) wordt metaclass(name, bases, namespace) aangeroepen.
# 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) is een klassemethode op de metaklasse die de woordenboeknaamruimte retourneert die tijdens de uitvoering van de klassebody wordt gebruikt. Overschrijf deze om een OrderedDict of aangepaste toewijzing te gebruiken.
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__ versus __init__ in type
type.__new__ maakt het klasseobject; type.__init__ initialiseert het. Overschrijf voor metaklassen __new__ om het aanmaken van klassen aan te passen.
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()) # TrueKlasse-decorators versus metaklassen
Klasse-decorators worden na het aanmaken toegepast; metaklassen sturen het aanmaken zelf aan. Geef voor eenvoudige uitbreidingen de voorkeur aan decorators. Gebruik metaklassen wanneer je het aanmaakproces moet beïnvloeden.
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__ wordt op de basisklasse aangeroepen telkens wanneer een subklasse wordt gedefinieerd. Dit is een lichtgewicht alternatief voor metaklassen om het gedrag van subklassen aan te passen.
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 is een ingebouwde metaklasse die abstracte basisklassen mogelijk maakt via @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 classDe metaklasse van een klasse inspecteren
Gebruik type(cls) om de metaklasse van een klasse te vinden en cls.__mro__ om de volgorde van methodeoplossing te bekijken.
class Meta(type): pass
class Foo(metaclass=Meta): pass
print(type(Foo)) # <class '__main__.Meta'>
print(Foo.__mro__) # (Foo, object)Overerving van metaklassen
De metaklasse van een klasse wordt overgeërfd door de subklassen. Als twee basisklassen verschillende metaklassen hebben, moet de meest specifieke worden gebruikt (anders ontstaat er een conflict).
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'>Wanneer gebruik je metaklassen?
Gebruik metaklassen voor: het automatisch registreren van subklassen, het afdwingen van klasse-invarianten, het detecteren van ORM-velden (zoals bij Django's Model) en routering in API-frameworks. Gebruik in de meeste gevallen in plaats daarvan __init_subclass__ of klasse-decorators.
# 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 patternsKorte controle
Wat doet type("Dog", (Animal,), {"speak": lambda self: "woof"})?
Samenvatting
Elke klasse is een instantie van type. De verwerkingspijplijn voor het aanmaken van een klasse: metaklasse bepalen → naamruimte voorbereiden → body uitvoeren → metaklasse aanroepen. Geef voor eenvoudige haken voor subklassen de voorkeur aan __init_subclass__; gebruik alleen een volledige metaklasse wanneer je het aanmaken van klassen zelf moet beheersen.
Leer Python met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 76
- Lessen
- 320
Veelgestelde vragen
Is de les “Hoe Python-klassen worden gemaakt” gratis?
Ja — de volledige tekst van “Hoe Python-klassen worden gemaakt” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Python Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Python Academy bevat in totaal 4 lessen.
Wat leer ik in “Hoe Python-klassen worden gemaakt”?
U leert type, de standaardmetaklasse en hooks voor het maken van klassen begrijpen. Je oefent met Python Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met Python Academy te beginnen?
Ervaring vooraf is niet nodig. Python Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.
Hoe lang duurt de les “Hoe Python-klassen worden gemaakt”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over Python Academy?
Ja. Elke les over Python Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Hoe Python-klassen worden gemaakt
- Aangepaste metaklassen schrijven
- Descriptors: __get__, __set__, __delete__
- __slots__ en geheugenoptimalisatie