Python Academy · leksjon

Multippel arv og MRO

Forstå multippel arv og Pythons MRO (C3-linearisering).

Leksjon 3 av 414 trinn

Multippel arv og MRO er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 3 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.

Introduksjon

Python støtter multippel nedarving. Metodeoppløsningsrekkefølgen (MRO) bestemmer hvilken metode som kalles når navn kolliderer.

Syntaks for multippel nedarving

class C(A, B): arver fra både A og B. C får alle metodene 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())

Metodeoppløsningsrekkefølge (MRO)

MRO definerer rekkefølgen for oppslag. C.__mro__ viser rekkefølgen: C, A, B, object. Den første klassen med en samsvarende metode vinner.

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 bruker C3-linearisering til å beregne MRO. Den garanterer underklasse før overklasse og basisklasser fra venstre mot høyre.

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

Diamantnedarving

D(B,C), der både B og C arver A, er diamantproblemet. C3 sikrer at A sin __init__ bare kalles é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 som er utformet for multippel nedarving. Den legger til metoder uten å fungere som en fullstendig, selvstendig 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 utforming av mixins

Mixins bør ikke ha __init__, ikke arve fra klasser som ikke er mixins og gjøre én ting. Gi dem navn med endelsen 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 multippel nedarving

super() kaller den neste klassen i MRO, ikke nødvendigvis den direkte overklassen. Hver klasse må kalle super() for samarbeidende oppførsel.

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() for dynamisk klasseopprettelse

type('NewClass', (Base,), {'method': fn}) oppretter en klasse dynamisk. Dette er nyttig for metaprogrammering.

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

Kontrollere MRO

ClassName.__mro__ eller inspect.getmro(ClassName) viser oppløsningsrekkefølgen som en tuppel med klasser.

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

Når du bør unngå multippel nedarving

Komplekse hierarkier med multippel nedarving er vanskelige å forstå. Foretrekk komposisjon eller enkle mixins fremfor dype hierarkier.

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

Hurtigsjekk

Hvilken algoritme bruker Python til å beregne metodeoppløsningsrekkefølgen?

Besvar den i den interaktive leksjonen

Oppsummering

Flere arv: class C(A, B). MRO via C3-linearisering bestemmer metodesøk. Bruk mixins for ryddig flerarv. super() følger MRO.

Fortsett

Utmerket fremgang! Fortsett for å mestre neste konsept.

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 gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Multippel arv og MRO» gratis?

Ja – hele teksten i «Multippel arv og MRO» 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 «Multippel arv og MRO»?

Forstå multippel arv og Pythons MRO (C3-linearisering). 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 3 av 4.

Hvor lang tid tar leksjonen «Multippel arv og MRO»?

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

← Tilbake til Python Academy