Python Academy · leksjon

Polymorfisme og duck typing

Skriv polymorf kode som fungerer med alle kompatible objekter.

Leksjon 4 av 414 trinn

Polymorfisme og duck typing er en gratis leksjon i Python Academy på CoddyKit. Dette er leksjon 4 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.

Innledning

Polymorfisme lar ulike objekter svare på det samme grensesnittet. Duck typing betyr: Hvis det oppfører seg som en and, er det en and.

Hva er polymorfisme?

Polymorfisme betyr «mange former». Det samme metodenavnet fungerer forskjellig på ulike objekter. Python legger stor vekt på dette.

class Cat:
    def speak(self): return 'Meow'
class Dog:
    def speak(self): return 'Woof'
for animal in [Cat(), Dog()]:
    print(animal.speak())

Duck typing

Python krever ikke et klassehierarki for polymorfisme. Hvis et objekt har riktig metode, fungerer det. Det er ikke nødvendig med grensesnitt.

class Duck:
    def quack(self): return 'Quack'
class Person:
    def quack(self): return 'I am quacking like a duck'
def make_it_quack(duck):
    print(duck.quack())
make_it_quack(Duck())
make_it_quack(Person())

Polymorfe funksjoner

len() fungerer på strenger, lister, dict-er og tupler – fordi de alle implementerer __len__. Dette er innebygd polymorfisme.

for obj in ['hello', [1,2,3], {'a':1}]:
    print(type(obj).__name__, len(obj))

Operatoroverlasting

+ fungerer på heltall, flyttall, strenger og lister fordi hver type implementerer __add__ på sin egen måte.

print(1 + 2)        # int addition
print('a' + 'b')    # string concat
print([1] + [2])    # list concat

Protokollbasert duck typing

Iterasjonsprotokollen: Alle objekter med __iter__ og __next__ fungerer i for-løkker – det kreves ingen basisklasse.

class Squares:
    def __init__(self, n): self.n,self.i=n,0
    def __iter__(self): return self
    def __next__(self):
        if self.i>=self.n: raise StopIteration
        x=self.i**2; self.i+=1; return x
print(list(Squares(5)))

EAFP kontra LBYL

EAFP (det er enklere å be om tilgivelse enn tillatelse) bruker try/except. LBYL (se før du hopper) bruker if/hasattr. Python foretrekker EAFP.

# LBYL:
if hasattr(obj, 'quack'):
    obj.quack()
# EAFP (Pythonic):
try:
    'hello'.quack()
except AttributeError:
    print('no quack')

isinstance() for trygg delegering

Når De trenger typespesifikk oppførsel, er isinstance() ryddigere enn å fange AttributeError.

def process(data):
    if isinstance(data, str):
        return data.upper()
    elif isinstance(data, list):
        return [x*2 for x in data]
print(process('hi'))
print(process([1,2,3]))

Abstrakte basisklasser som protokoller

from abc import ABC, abstractmethod definerer formelle protokoller. Underklasser må implementere abstrakte metoder.

from abc import ABC, abstractmethod
class Drawable(ABC):
    @abstractmethod
    def draw(self): pass
class Circle(Drawable):
    def draw(self): print('O')
Circle().draw()

typing.Protocol (3.8+)

class MyProtocol(Protocol): definerer strukturell subtyping uten ABC. Det fungerer med mypy for statiske kontroller.

from typing import Protocol
class Quackable(Protocol):
    def quack(self) -> str: ...
def make_quack(x: Quackable) -> str:
    return x.quack()
print('protocol demo')

Polymorfisme i praksis

Utform API-er som godtar alle objekter med riktig grensesnitt. Da blir koden utvidbar uten endringer.

class JSONSerializer:
    def serialize(self, obj): import json; return json.dumps(obj)
class XMLSerializer:
    def serialize(self, obj): return f'<data>{obj}</data>'
def export(data, serializer):
    return serializer.serialize(data)
print(export({'x': 1}, JSONSerializer()))

Hurtigsjekk

Hva betyr duck typing i Python?

Besvar den i den interaktive leksjonen

Oppsummering

Polymorfisme: samme grensesnitt, ulik oppførsel. Duck typing: oppførselen er viktig, ikke typen. Protokoller definerer grensesnitt uformelt. EAFP (try/except) er typisk Python.

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 «Polymorfisme og duck typing» gratis?

Ja – hele teksten i «Polymorfisme og duck typing» 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 «Polymorfisme og duck typing»?

Skriv polymorf kode som fungerer med alle kompatible objekter. 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 4 av 4.

Hvor lang tid tar leksjonen «Polymorfisme og duck typing»?

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