Sådan oprettes Python-klasser
Forstå type, standardmetaklassen og hooks til klasseoprettelse.
Sådan oprettes Python-klasser er en gratis Python Academy-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Python Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Python Academy-kurset indeholder 4 lektioner i alt.
type() er en metaklasse
Hver klasse i Python er en instans af type. type er selv en klasse — den er metaklassen for alle metaklasser.
# These are equivalent:
class Dog:
sound = "woof"
Dog2 = type("Dog2", (), {"sound": "woof"})
print(type(Dog)) # <class 'type'>
print(type(Dog2)) # <class 'type'>type() med tre argumenter
type(name, bases, namespace) opretter en ny klasse dynamisk. Det er præcis det, class-sætninger gør internt.
Animal = type("Animal", (), {"speak": lambda self: "..."})
Dog = type("Dog", (Animal,), {"speak": lambda self: "woof"})
d = Dog()
print(d.speak()) # woofTrin i klasseoprettelsen
Når Python ser en class-sætning, gør den følgende: 1) finder metaklassen, 2) klargør navnerummet, 3) udfører klassekroppen, 4) kalder 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) er en klassemetode på metaklassen, der returnerer det navnerumsordbog, som bruges under udførelsen af klassekroppen. Overskriv den for at bruge en OrderedDict eller en tilpasset mapping.
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__ og __init__ i type
type.__new__ opretter klasseobjektet, mens type.__init__ initialiserer det. I metaklasser skal du overskrive __new__ for at tilpasse klasseoprettelsen.
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()) # TrueKlassedekoratorer kontra metaklasser
Klassedekoratorer anvendes efter oprettelsen, mens metaklasser styrer selve oprettelsen. Til enkel udvidelse bør du foretrække dekoratorer. Brug metaklasser, når du har brug for at påvirke oprettelsesprocessen.
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__ kaldes på basisklassen, hver gang der defineres en underklasse. Det er et enkelt alternativ til metaklasser, når underklassers adfærd skal tilpasses.
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 er en indbygget metaklasse, der driver abstrakte basisklasser 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 classInspektion af en klasses metaklasse
Brug type(cls) til at finde en klasses metaklasse og cls.__mro__ til at se metodens opslagrækkefølge.
class Meta(type): pass
class Foo(metaclass=Meta): pass
print(type(Foo)) # <class '__main__.Meta'>
print(Foo.__mro__) # (Foo, object)Nedarvning af metaklasser
En klasses metaklasse nedarves af dens underklasser. Hvis to basisklasser har forskellige metaklasser, skal den mest afledte bruges, ellers opstår der en konflikt.
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'>Hvornår skal du bruge metaklasser
Brug metaklasser til automatisk at registrere underklasser, håndhæve klasseinvarianter, finde ORM-felter som i Djangos Model og håndtere routning i API-frameworks. I de fleste tilfælde bør du i stedet bruge __init_subclass__ eller klassedekoratorer.
# 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 patternsHurtig test
Hvad gør type("Dog", (Animal,), {"speak": lambda self: "woof"})?
Opsummering
Hver klasse er en instans af type. Forløbet for klasseoprettelse er: Find metaklassen → klargør navnerummet → udfør kroppen → kald metaklassen. Foretræk __init_subclass__ til enkle hooks for underklasser, og brug kun en fuld metaklasse, når du har brug for at styre selve klasseoprettelsen.
Lær Python med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 76
- Lektioner
- 320
Ofte stillede spørgsmål
Er lektionen “Sådan oprettes Python-klasser” gratis?
Ja — hele teksten til “Sådan oprettes Python-klasser” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Python Academy-kurset, skal du opgradere til CoddyKit PRO. Python Academy-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Sådan oprettes Python-klasser”?
Forstå type, standardmetaklassen og hooks til klasseoprettelse. Du øver dig i Python Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Python Academy?
Der kræves ingen tidligere erfaring. Python Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.
Hvor lang tid tager lektionen “Sådan oprettes Python-klasser”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Python Academy-lektion?
Ja. Alle Python Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Sådan oprettes Python-klasser
- Skrivning af brugerdefinerede metaklasser
- Deskriptorer: __get__, __set__, __delete__
- __slots__ og hukommelsesoptimering