Python Academy · Lektion

Multipelt arv och MRO

Förstå multipelt arv och Pythons MRO (C3-linjärisering).

Lektion 3 av 414 steg

Multipelt arv och MRO är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Introduktion

Python stöder multipelt arv. Metodupplösningsordningen (MRO) avgör vilken metod som anropas när namn krockar.

Syntax för multipelt arv

class C(A, B): ärver från både A och B. C får alla metoder från båda.

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())

Metodupplösningsordning (MRO)

MRO definierar ordningen för uppslagning. C.__mro__ visar ordningen: C, A, B, object. Den första klassen med en matchande metod 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-linjärisering

Python använder C3-linjärisering för att beräkna MRO. Den garanterar underklass före basklass och ordning från vänster till höger för flera basklasser.

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

Diamantarv

D(B,C) där B och C båda ärver A utgör diamantproblemet. C3 säkerställer att A:s __init__ anropas endast en gång.

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 är en klass som är utformad för multipelt arv. Den lägger till metoder utan att fungera som en fullständig klass på egen hand.

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 för mixindesign

Mixins bör inte ha __init__, inte ärva från klasser som inte är mixins och endast göra en sak. Namnge dem med suffixet 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() vid multipelt arv

super() anropar nästa klass i MRO, inte nödvändigtvis den direkta basklassen. Varje klass måste anropa super() för samverkande beteende.

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() för dynamiskt skapande av klasser

type('NewClass', (Base,), {'method': fn}) skapar en klass dynamiskt. Det är användbart för metaprogrammering.

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

Kontrollera MRO

ClassName.__mro__ eller inspect.getmro(ClassName) visar upplösningsordningen som en tupel av 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 ni bör undvika multipelt arv

Komplexa hierarkier med multipelt arv är svåra att förstå. Föredra komposition eller enkla mixins framför djupa hierarkier.

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

Snabb kontroll

Vilken algoritm använder Python för att beräkna metodupplösningsordningen?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Multipelt arv: class C(A, B). MRO via C3-linjärisering avgör metodsökningen. Använd mixins för ett tydligt multipelt arv. super() följer MRO.

Fortsätt

Utmärkt framsteg! Fortsätt för att behärska nästa koncept.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Multipelt arv och MRO” gratis?

Ja – hela texten till ”Multipelt arv och MRO” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Multipelt arv och MRO”?

Förstå multipelt arv och Pythons MRO (C3-linjärisering). Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.

Hur lång tid tar lektionen ”Multipelt arv och MRO”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Python Academy