Python Academy · leksjon

Overstyring av metoder og super()

Overstyr metoder fra foreldreklassen, og kall dem med super().

Leksjon 2 av 414 trinn

Overstyring av metoder og super() er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 2 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

Metodeoverstyring gjør det mulig for underklasser å tilpasse arvet oppførsel. super() gjør det mulig å kalle den opprinnelige implementasjonen.

Grunnleggende om overstyring

Definer samme metodenavn i underklassen for å erstatte overklassens versjon for alle instanser av underklassen.

class Greeter:
    def greet(self): return 'Hello'
class FormalGreeter(Greeter):
    def greet(self): return 'Good day'
print(FormalGreeter().greet())

super() i overstyringer

super().greet() inne i underklassen kaller overklassens versjon. Dette er nyttig når du vil utvide oppførselen, ikke erstatte den fullstendig.

class Logger:
    def log(self, msg): print(f'[LOG] {msg}')
class TimedLogger(Logger):
    def log(self, msg):
        import time
        super().log(f'{time.time():.0f}: {msg}')
TimedLogger().log('test')

super() i init

Kall alltid super().__init__() i underklassens __init__ for å sikre at overklassens initialisering kjøres.

class Animal:
    def __init__(self, name): self.name = name
class Cat(Animal):
    def __init__(self, name, indoor):
        super().__init__(name)
        self.indoor = indoor
cat = Cat('Whiskers', True)
print(cat.name, cat.indoor)

super() med argumenter

super(ChildClass, self) er den eksplisitte formen (Python 2-stil). Python 3 tillater super() uten argumenter i de fleste tilfeller.

class A:
    def greet(self): return 'A'
class B(A):
    def greet(self): return super().greet() + 'B'
class C(B):
    def greet(self): return super().greet() + 'C'
print(C().greet())

Samarbeidende nedarving

Ved multippel nedarving følger super() MRO. Når hver klasse kaller super(), sikres det at alle klassene i kjeden initialiseres.

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

Overstyre str

Overstyr __str__ i underklassen for å tilpasse hvordan instanser skrives ut.

class Animal:
    def __init__(self, name): self.name = name
    def __str__(self): return f'Animal: {self.name}'
class Dog(Animal):
    def __str__(self): return f'Dog: {self.name}'
print(Dog('Rex'))

Mønsteret Template Method

Overklassen definerer algoritmens skjelett, mens underklassen fyller ut trinnene ved å overstyre bestemte metoder.

class DataProcessor:
    def process(self):
        data = self.load()
        return self.transform(data)
    def load(self): return [1,2,3]
    def transform(self, d): return d
class Doubler(DataProcessor):
    def transform(self, d): return [x*2 for x in d]
print(Doubler().process())

Kalle en søsterklasses metode

Med super() og riktig MRO kan du kalle en søsterklasses metode ved multippel nedarving – dette er samarbeidende super().

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

__init_subclass__

__init_subclass__ kalles hver gang klassen underklasses. Det er nyttig i mønstre for registrering av programtillegg.

class Plugin:
    registry = []
    def __init_subclass__(cls, **kw):
        super().__init_subclass__(**kw)
        Plugin.registry.append(cls)
class A(Plugin): pass
class B(Plugin): pass
print([c.__name__ for c in Plugin.registry])

Når du IKKE bør overstyre

Ikke overstyr hvis du ikke trenger å endre oppførselen. Unødvendige overstyringer øker vedlikeholdsarbeidet. Foretrekk komposisjon for urelatert oppførsel.

# Good: only override what's needed
class Dog(Animal):
    def speak(self): return 'Woof'
    # No need to override __init__ if parent's is fine
print('override guidance')

Hurtigsjekk

Hva viser super() (uten argumenter) til inne i en metode i Python 3?

Besvar den i den interaktive leksjonen

Oppsummering

Overstyr ved å redefinere i underklassen. super().method() kaller overklassens versjon. super().__init__() initialiserer overklassen. Samarbeidende super() følger MRO-rekkefølgen.

Fortsett

Utmerket fremgang! Fortsett for å mestre det neste konseptet.

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 «Overstyring av metoder og super()» gratis?

Ja – hele teksten i «Overstyring av metoder og super()» 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 «Overstyring av metoder og super()»?

Overstyr metoder fra foreldreklassen, og kall dem med super(). 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 2 av 4.

Hvor lang tid tar leksjonen «Overstyring av metoder og super()»?

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