PricingLoginStart free
Python Academy · leksjon

Hvordan Python-klasser opprettes

Forstå type, standardmetaklassen og hooks for klasseoppretting.

Leksjon 1 av 413 trinn

Hvordan Python-klasser opprettes er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Python Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Python Academy inneholder totalt 4 leksjoner.

type() er en metaklasse

Alle klasser i Python er instanser av 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) oppretter en ny klasse dynamisk. Dette er nøyaktig det class-setninger gjør under panseret.

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

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

Trinnene ved opprettelse av en klasse

Når Python ser en class-setning, gjør det følgende: 1) løser metaklassen, 2) klargjør navnerommet, 3) kjører klassekroppen, 4) kaller 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 som returnerer ordboken for navnerommet som brukes under kjøringen av klassekroppen. Overstyr den for å bruke en OrderedDict eller en egendefinert 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__ kontra __init__ i type

type.__new__ oppretter klasseobjektet, mens type.__init__ initialiserer det. For metaklasser bør du overstyre __new__ for å tilpasse opprettelsen av klassen.

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

Klassedekoratorer kontra metaklasser

Klassedekoratorer brukes etter opprettelsen, mens metaklasser styrer selve opprettelsen. For enkel utvidelse bør du foretrekke dekoratorer. Bruk metaklasser når du trenger å påvirke opprettelsesprosessen.

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__ kalles på basisklassen hver gang en underklasse defineres. Det er et lettvektsalternativ til metaklasser for å tilpasse oppførselen til underklasser.

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 innebygd metaklasse som gir støtte for 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 class

Inspeksjon av en klasses metaklasse

Bruk type(cls) for å finne metaklassen til en klasse, og cls.__mro__ for å se rekkefølgen for metodeoppslag.

class Meta(type): pass

class Foo(metaclass=Meta): pass

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

Arv av metaklasser

Metaklassen til en klasse arves av underklassene. Hvis to basisklasser har forskjellige metaklasser, må den mest avledede metaklassen brukes, ellers oppstår 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'>

Når bør du bruke metaklasser?

Bruk metaklasser til å automatisk registrere underklasser, håndheve klasseinvarianter, oppdage ORM-felt, slik som i Djangos Model, og rute API-rammeverk. I de fleste tilfeller bør du heller bruke __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 patterns

Hurtigsjekk

Hva gjør type("Dog", (Animal,), {"speak": lambda self: "woof"})?

Besvar den i den interaktive leksjonen

Oppsummering

Alle klasser er instanser av type. Prosessen for opprettelse av en klasse er: løs metaklassen → klargjør navnerommet → kjør kroppen → kall metaklassen. Foretrekk __init_subclass__ for enkle kroker for underklasser, og bruk en full metaklasse bare når du trenger å styre selve opprettelsen av klassen.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
76
Leksjoner
320
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Hvordan Python-klasser opprettes» gratis?

Ja – hele teksten i «Hvordan Python-klasser opprettes» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Python Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Python Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Hvordan Python-klasser opprettes»?

Forstå type, standardmetaklassen og hooks for klasseoppretting. Du øver på Python Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Python Academy?

Ingen tidligere erfaring er nødvendig. Python Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Hvordan Python-klasser opprettes»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Python Academy-leksjonen?

Ja. Alle Python Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. Hvordan Python-klasser opprettes
  2. Skrive egendefinerte metaklasser
  3. Deskriptorer: __get__, __set__, __delete__
  4. __slots__ og minneoptimalisering
← Tilbake til Python Academy