Python Academy · Lektion

Multipel nedarvning og MRO

Forstå multipel nedarvning og Pythons MRO (C3-linearisering).

Lektion 3 af 414 trin

Multipel nedarvning og MRO er en gratis Python Academy-lektion på CoddyKit. Dette er lektion 3 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.

Introduktion

Python understøtter multipel nedarvning. Rækkefølgen for metodeopslag (MRO) bestemmer, hvilken metode der kaldes, når navne kolliderer.

Syntaks for multipel nedarvning

class C(A, B): nedarver fra både A og B. C får alle metoder fra begge.

class A:
    def hello(self): return 'A'
class B:
    def world(self): return 'B'
class C(A, B): pass
c = C()
print(c.hello(), c.world())

Rækkefølge for metodeopslag (MRO)

MRO definerer rækkefølgen for opslag. C.__mro__ viser rækkefølgen: C, A, B, object. Den første klasse med en matchende metode vinder.

class A:
    def greet(self): return 'A'
class B:
    def greet(self): return 'B'
class C(A, B): pass
print(C().greet())  # A wins
print(C.__mro__)

C3-linearisering

Python bruger C3-linearisering til at beregne MRO. Den garanterer underklasse før superklasse og fra venstre mod højre for flere basisklasser.

class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
print([c.__name__ for c in D.__mro__])

Diamantnedarvning

D(B,C), hvor både B og C nedarver fra A, er diamantproblemet. C3 sikrer, at A's __init__ kun kaldes én gang.

class A:
    def __init__(self): print('A')
class B(A):
    def __init__(self): super().__init__(); print('B')
class C(A):
    def __init__(self): super().__init__(); print('C')
class D(B, C):
    def __init__(self): super().__init__(); print('D')
D()

Mixins

En mixin er en klasse, der er designet til multipel nedarvning. Den tilføjer metoder uden selv at fungere som en komplet klasse.

class JSONMixin:
    def to_json(self):
        import json
        return json.dumps(vars(self))
class User(JSONMixin):
    def __init__(self, name, age): self.name,self.age=name,age
print(User('Alice', 30).to_json())

Regler for mixin-design

Mixins bør ikke have __init__, ikke nedarve fra klasser, der ikke er mixins, og kun gøre én ting. Navngiv dem med suffikset Mixin.

class LoggingMixin:
    def log(self, msg): print(f'[{self.__class__.__name__}] {msg}')
class Service(LoggingMixin):
    def run(self): self.log('running')
Service().run()

super() ved multipel nedarvning

super() kalder den næste klasse i MRO'en, ikke nødvendigvis den direkte superklasse. Hver klasse skal kalde super() for at opnå samarbejdende funktionalitet.

class Base:
    def action(self): return 'Base'
class A(Base):
    def action(self): return 'A->' + super().action()
class B(Base):
    def action(self): return 'B->' + super().action()
class C(A, B):
    def action(self): return 'C->' + super().action()
print(C().action())

type() til dynamisk oprettelse af klasser

type('NewClass', (Base,), {'method': fn}) opretter en klasse dynamisk. Det er nyttigt til metaprogrammering.

def hello(self): return 'hello'
MyClass = type('MyClass', (object,), {'hello': hello})
print(MyClass().hello())

Kontrol af MRO

ClassName.__mro__ eller inspect.getmro(ClassName) viser rækkefølgen for metodeopslag som en tupel af klasser.

class A: pass
class B(A): pass
class C(B): pass
import inspect
print([c.__name__ for c in inspect.getmro(C)])

Hvornår bør du undgå multipel nedarvning?

Komplekse hierarkier med multipel nedarvning er svære at gennemskue. Foretræk komposition eller simple mixins frem for dybe hierarkier.

# Prefer:
class User:
    def __init__(self, name, logger):
        self.name = name
        self.logger = logger  # composition
print('composition preferred')

Hurtigt tjek

Hvilken algoritme bruger Python til at beregne rækkefølgen for metodeopslag?

Besvar den i den interaktive lektion

Opsummering

Flere nedarvninger: class C(A, B). MRO via C3-linearisering bestemmer opslag af metoder. Brug mixins til renere flere nedarvninger. super() følger MRO.

Fortsæt

Fremragende fremskridt! Fortsæt for at få styr på det næste koncept.

Gratis at komme i gang

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Multipel nedarvning og MRO” gratis?

Ja — hele teksten til “Multipel nedarvning og MRO” 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 “Multipel nedarvning og MRO”?

Forstå multipel nedarvning og Pythons MRO (C3-linearisering). 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 3 af 4.

Hvor lang tid tager lektionen “Multipel nedarvning og MRO”?

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

← Tilbage til Python Academy