Skip to main content

7  Arv og polymorfi

En sparekonto og en brukskonto er ikke like, men de har mye til felles: begge har en eier og en saldo, og du kan sette inn og ta ut penger på begge. Skal vi skrive all den felles koden to ganger? Det ville vært bortkastet, og enda verre: rettet vi en feil i den ene, måtte vi huske å rette den i den andre. Arv løser dette. Du skriver det som er felles én gang i en klasse, og lar andre klasser bygge videre på den og legge til eller endre det som er forskjellig.

I dette kapittelet lærer du å lage subklasser som arver fra en annen klasse, å endre arvede metoder med overstyring og super(), å bruke objekter av ulike klasser på samme måte (polymorfi), å lage abstrakte klasser som bare er en mal, og å vurdere når du ikke bør bruke arv. Dette er det siste av kompetansemålet om å utvikle objektorienterte programmer med klasser, objekter, metoder og arv. Du bruker også det du lærte i kapittel 5 om å modellere, for arv er en relasjon i klassediagrammet (<|--).

Du kan gjøre oppgavene i boka og i notatboka i nettleseren. Prosjektene gjør du i VS Code.

Notatboka har flere oppgaver, som rettes med sjekk(). Den kan brukes i nettleseren eller i VS Code.

Læringsmål

Etter å ha arbeidet med kapittelet skal du kunne

  • lage en subklasse som arver attributter og metoder fra en superklasse,
  • overstyre en arvet metode og bruke super() til å bygge videre på den,
  • bruke objekter av ulike klasser på samme måte (polymorfi),
  • lage en abstrakt klasse med abc som tvinger subklassene til å skrive bestemte metoder,
  • vurdere om arv eller komposisjon passer best.

7.1 Arv og subklasser

Her lærer du å lage en klasse som arver alt fra en annen klasse, og legger til noe eget.

7.1.1 Subklasser

I kapittel 5 lærte du å se forskjell på «har en» (relasjoner) og «er en». En sparekonto er en konto. En hund er et dyr. Når noe «er en» noe annet, kan det arve alt fra den: alle egenskapene og handlingene til kontoen gjelder også for sparekontoen. Vi trenger bare å skrive det som er forskjellig.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva en superklasse og en subklasse er,
  • skrive en subklasse med class Sub(Super):,
  • bruke «er en»-testen for å avgjøre om arv passer,
  • legge til nye metoder og attributter i en subklasse,
  • bruke isinstance og issubclass.

Arv: en klasse som bygger videre på en annen

Vi starter med en vanlig konto, slik du lærte å skrive den i kapittel 6:

class Konto:
    def __init__(self, eier):
        self.eier = eier
        self._saldo = 0

    @property
    def saldo(self):
        return self._saldo

    def sett_inn(self, belop):
        if belop <= 0:
            raise ValueError("Beløpet må være positivt")
        self._saldo += belop

    def ta_ut(self, belop):
        if belop <= 0:
            raise ValueError("Beløpet må være positivt")
        if belop > self._saldo:
            raise ValueError("Ikke nok penger")
        self._saldo -= belop

    def __str__(self):
        return f"{self.eier}: {self.saldo} kr"

En sparekonto er en konto som i tillegg kan få rente. Vi lager den som en subklasse av Konto ved å skrive superklassen i parentes etter navnet:

class Sparekonto(Konto):
    RENTE = 0.03

    def legg_til_rente(self):
        self._saldo += self._saldo * self.RENTE

s = Sparekonto("Mia")
s.sett_inn(1000)
s.legg_til_rente()
print(s.saldo)
print(s)
1030.0
Mia: 1030.0 kr

Sparekonto har ingen konstruktør, ingen sett_inn og ingen __str__, og likevel virker alt det. De er arvet fra Konto. Subklassen har bare det den selv legger til: renten og metoden som legger den til saldoen.

classDiagram
    Konto <|-- Sparekonto
    Konto <|-- Brukskonto
    class Konto {
        -eier
        -saldo
        +sett_inn(belop)
        +ta_ut(belop)
    }
    class Sparekonto {
        +RENTE
        +legg_til_rente()
    }
    class Brukskonto {
        +KREDITT
    }

I klassediagrammet tegnes arv med en pil med hul trekant (<|--) som peker mot superklassen. Subklassen viser bare det den har i tillegg, for resten er arvet.

DefinisjonArv, superklasse og subklasse

Arv betyr at en klasse overtar alle attributtene og metodene til en annen klasse. Klassen som arves fra, kalles superklassen (eller baseklassen). Klassen som arver, kalles subklassen. Du skriver class Sub(Super):.

Her er en brukskonto som også er en konto, men som lar deg trekke saldoen litt under null (kreditt):

class Brukskonto(Konto):
    KREDITT = 5000

b = Brukskonto("Jon")
b.sett_inn(200)
print(b)
Jon: 200 kr

Foreløpig har den ikke noe nytt, så den oppfører seg helt som en vanlig konto. I 7.2.1 lærer du å endre ta_ut slik at kreditten brukes.

RegelEr-en-testen

Før du lager en subklasse, spør: er subklassen en slags superklasse?

  • Sparekonto er en Konto. ✔ Arv passer.
  • Hund er et Dyr. ✔ Arv passer.
  • Bil er en Motor. ✘ En bil har en motor. Bruk komposisjon (se 7.5.1).
  • Elev er en Klasse. ✘ En klasse har elever.

Arv betyr at subklassen kan brukes overalt der superklassen kan brukes.

Hva arves, og hva legges til?

Subklassen får alt fra superklassen: konstruktøren, attributtene, metodene, egenskapene og klasseattributtene. Du kan bruke dem som om de stod i subklassen selv. I tillegg kan subklassen legge til sine egne metoder og klasseattributter, som legg_til_rente. Det motsatte gjelder ikke: superklassen vet ikke om det subklassene legger til.

k = Konto("Kari")
print(hasattr(k, "legg_til_rente"))
print(hasattr(s, "legg_til_rente"))
print(hasattr(s, "sett_inn"))
False
True
True

En vanlig Konto har ikke legg_til_rente, mens Sparekonto har både den og alt som Konto har.

Lag klassen Dyr med navn og metoden hils() som skriver ut Jeg heter <navn>. Lag subklassen Hund som legger til metoden apport() som skriver ut <navn> henter pinnen.

class Hund(Dyr): og bruk self.navn i den nye metoden. Konstruktøren er arvet.

class Dyr:
    def __init__(self, navn):
        self.navn = navn

    def hils(self):
        print(f"Jeg heter {self.navn}")

class Hund(Dyr):
    def apport(self):
        print(f"{self.navn} henter pinnen")

fido = Hund("Fido")
fido.hils()
fido.apport()
Jeg heter Fido
Fido henter pinnen

Hund har ingen konstruktør, så den arvede fra Dyr brukes. hils er også arvet.

Å teste typen

Med isinstance(objekt, Klasse) kan du sjekke om et objekt er av en klasse, også hvis det er av en subklasse. Med issubclass(Sub, Super) sjekker du forholdet mellom klasser:

print(isinstance(s, Sparekonto))
print(isinstance(s, Konto))
print(isinstance(k, Sparekonto))
print(issubclass(Sparekonto, Konto))
print(issubclass(Konto, Sparekonto))
True
True
False
True
False

En sparekonto er en konto, så isinstance(s, Konto) er sann. En vanlig konto er ikke en sparekonto, så isinstance(k, Sparekonto) er usann.

Alle klasser i Python arver til slutt fra klassen object. Det er derfor alle objekter har noen felles metoder, som __str__ og __eq__ fra kapittel 6. Du har brukt arv hele tiden uten å vite det.

Arv fra innebygde klasser og unntak

Du kan også arve fra klasser som Python har. I kapittel 4 så du at alle feil er klasser. Du kan lage dine egne feiltyper ved å arve fra ValueError eller Exception:

class UgyldigBelop(ValueError):
    pass

try:
    raise UgyldigBelop("Beløpet må være positivt")
except ValueError as feil:
    print("Fanget:", feil)
Fanget: Beløpet må være positivt

UgyldigBelop er en ValueError, så except ValueError fanger den også. Samtidig kan du fange akkurat denne typen hvis du vil: except UgyldigBelop. Det gjør feilhåndteringen mer presis.

NoteHvor mange nivåer?

En subklasse kan selv ha subklasser, så du kan få et hierarki med flere nivåer (Konto → Sparekonto → BSUkonto). Arv fungerer likt på alle nivåer, og subklassen arver alt fra alle klassene over seg. Hold hierarkiet grunt, helst ikke mer enn to eller tre nivåer, ellers blir det vanskelig å følge med på hva som kommer fra hvor.

AdvarselVanlige feil
  • Å bruke arv når forholdet ikke er «er en» (en bil har en motor).
  • Å skrive superklassen uten parentes: class Sparekonto: lager en helt ny klasse uten arv.
  • Å skrive superklassen i feil rekkefølge (class Konto(Sparekonto)).
  • Å kopiere koden fra superklassen inn i subklassen i stedet for å arve den.
  • Å tro at superklassen får metodene til subklassen. Arven går bare nedover.
  • Å lage lange hierarkier med mange nivåer.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Passer arv (er en) eller komposisjon (har en) i hvert tilfelle?

Bil og Kjoretoy

Si setningen høyt: «Et … er et/en …» eller «Et … har …».

Arv: en bil er et kjøretøy. b) Komposisjon: en bil har hjul. c) Arv: en elev er en person. d) Komposisjon: et hus har rom. e) Arv: en sirkel er en form.
Bil og Hjul

Si setningen høyt: «Et … er et/en …» eller «Et … har …».

Elev og Person

Si setningen høyt: «Et … er et/en …» eller «Et … har …».

Hus og Rom

Si setningen høyt: «Et … er et/en …» eller «Et … har …».

Sirkel og Form

Si setningen høyt: «Et … er et/en …» eller «Et … har …».

class Dyr:
    def __init__(self, navn):
        self.navn = navn

    def hils(self):
        print("Hei, jeg er", self.navn)

class Katt(Dyr):
    def mjau(self):
        print("Mjau!")

k = Katt("Pus")
k.hils()
k.mjau()
print(isinstance(k, Dyr))

Hei, jeg er Pus, Mjau! og True. Katt arver konstruktøren og hils fra Dyr, og legger til mjau. En katt er et dyr, så isinstance(k, Dyr) er sann.

classDiagram
    Person <|-- Elev
    Person <|-- Laerer
    class Person {
        +navn
        +hils()
    }
    class Elev {
        +klasse
    }
    class Laerer {
        +fag
    }

Hva er superklassen, og hva er subklassene?

Person er superklassen, og Elev og Laerer er subklasser.

Hvilke attributter og metoder har Laerer til sammen?

Laerer har fag (egen) og navn og hils() (arvet fra Person).

Nivå 2
class Person:
    def __init__(self, navn):
        self.navn = navn

class Elev:
    def hils(self):
        print("Hei,", self.navn)

e = Elev("Kari")

Hva skjer, og hvordan rettes det?

Står Person i parentesen?

Det gir TypeError: Elev() takes no arguments. Elev arver ikke fra Person, så den har ingen konstruktør som tar navn. Rett til class Elev(Person):.

Sparekonto arver fra Konto. Hvilke av disse kan et Sparekonto-objekt bruke, og hvilke kan et vanlig Konto-objekt bruke? Metodene er sett_inn, ta_ut og legg_til_rente.

Sparekonto kan bruke alle tre. Konto kan bare bruke sett_inn og ta_ut, siden legg_til_rente bare finnes i subklassen. Arv går fra super- til subklasse, ikke omvendt.

Tegn et klassediagram med arv for disse: Dyr, Hund, Katt, Fugl. Alle har navn. Fugl har i tillegg kan_fly. Skriv attributtene der de hører hjemme.

classDiagram
    Dyr <|-- Hund
    Dyr <|-- Katt
    Dyr <|-- Fugl
    class Dyr {
        -navn: str
    }
    class Fugl {
        -kan_fly: bool
    }

navn står bare i Dyr, siden alle arver det. kan_fly er bare for fugler. Hund og Katt har ingenting nytt ennå.

Kodeoppgaver

Dyr er gitt. Skriv subklassen Hund som arver fra Dyr og legger til metoden apport() som gir teksten <navn> henter pinnen.

class Hund(Dyr): og så metoden apport som gir f"{self.navn} henter pinnen".

Konto er gitt. Skriv subklassen Sparekonto med klasseattributtet RENTE = 0.05 og metoden legg_til_rente() som øker saldoen med renten.

self._saldo += self._saldo * self.RENTE.

Person er gitt. Skriv Elev (med metoden presenter() som gir <navn> går i <klasse>) og Laerer (med presenter() som gir <navn> underviser i <fag>). Siden de ikke har egne konstruktører ennå, settes klasse og fag etter at objektet er laget.

class Elev(Person): med def presenter(self): return f"{self.navn} går i {self.klasse}".

Elev skal arve fra Person, men Elev("Kari").hils() krasjer. Rett koden.

Hva mangler i linja class Elev:?

Lag feiltypen UgyldigAlder som arver fra ValueError. Skriv funksjonen sett_alder(alder) som gir alderen hvis den er mellom \(0\) og \(130\), og ellers utløser UgyldigAlder("Ugyldig alder").

class UgyldigAlder(ValueError): pass, og raise UgyldigAlder("Ugyldig alder").

Skriv Kjoretoy (med hjul, antall hjul, og beskriv() som gir <hjul> hjul), Bil som arver fra Kjoretoy og har hjul = 4, og Sportsbil som arver fra Bil. Bruk et klasseattributt hjul i hver klasse, så ingen trenger konstruktør.

class Kjoretoy: hjul = 2, og beskriv gir f"{self.hjul} hjul". Bil setter hjul = 4. Sportsbil trenger bare pass.

Utfordringer

Skriv Ansatt med navn og timelonn (sendes inn), og metoden ukelonn(timer) som gir timer * timelonn. Skriv Deltidsansatt som arver, og legger til metoden er_fulltid(timer) som gir True hvis timene er minst \(37.5\). Skriv Sjef som arver og legger til klasseattributtet BONUS = 1000 og metoden ukelonn_med_bonus(timer).

Ansatt har konstruktøren. De andre arver den og legger bare til metoder.

Hvorfor er det bedre å la Sparekonto arve fra Konto enn å kopiere all koden fra Konto inn i Sparekonto?

Med kopiering finnes den samme koden to steder. Finner du en feil i sett_inn, må du rette den begge steder, og glemmer du ett, har du en feil som bare viser seg i den ene klassen. Med arv finnes koden ett sted, og alle subklasser får rettelsen automatisk. Koden blir også kortere og lettere å lese, siden subklassen bare viser det som er forskjellig.

Oppsummering

Subklasse

class Sparekonto(Konto):
    RENTE = 0.03

    def legg_til_rente(self):
        ...

Er-en-testen

  • Sparekonto er en Konto → arv
  • Bil har en Motor → komposisjon

Teste typen

isinstance(s, Konto)
issubclass(Sparekonto, Konto)

UML

Konto <|-- Sparekonto

  • Subklassen arver alt, og legger til sitt eget.
  • Arven går nedover: superklassen kjenner ikke subklassen.
  • Skriv class Sub(Super):. Uten parentes er det ingen arv.

7.1.2 Overstyre metoder

Av og til passer ikke den arvede metoden helt for subklassen. En vanlig konto nekter å la saldoen bli negativ, men en brukskonto har kreditt og skal tillate det til en grense. Da skriver vi en ny ta_ut i Brukskonto. Når subklassen har en metode med samme navn som superklassen, brukes subklassens versjon. Vi sier at den overstyrer metoden.

Læringsmål

Etter dette delkapittelet skal du kunne

  • overstyre en arvet metode i en subklasse,
  • forklare hvilken metode Python velger når begge klasser har den,
  • overstyre __str__ og andre spesialmetoder,
  • avgjøre når overstyring er riktig.

Overstyring

Du overstyrer en metode ved å skrive en metode med samme navn i subklassen. Her tillater Brukskonto uttak så lenge saldoen ikke går under minus kreditten:

class Brukskonto(Konto):
    KREDITT = 5000

    def ta_ut(self, belop):
        if belop <= 0:
            raise ValueError("Beløpet må være positivt")
        if belop > self._saldo + self.KREDITT:
            raise ValueError("Over kredittgrensen")
        self._saldo -= belop

b = Brukskonto("Jon")
b.sett_inn(200)
b.ta_ut(1000)
print(b.saldo)
-800

Jon har satt inn \(200\) kroner og tatt ut \(1000\), så saldoen er \(-800\). Det er lov på en brukskonto med \(5000\) i kreditt, men ikke på en vanlig konto:

k = Konto("Kari")
k.sett_inn(200)
try:
    k.ta_ut(1000)
except ValueError as feil:
    print("Konto:", feil)

try:
    b.ta_ut(10000)
except ValueError as feil:
    print("Brukskonto:", feil)
Konto: Ikke nok penger
Brukskonto: Over kredittgrensen

sett_inn er ikke overstyrt, så Brukskonto bruker den arvede fra Konto.

RegelHvilken metode brukes?

Når du kaller objekt.metode(), leter Python først etter metoden i klassen til objektet. Finnes den ikke der, leter den i superklassen, og så oppover i hierarkiet til den finner den.

  • Finnes metoden i subklassen, brukes den (overstyring).
  • Finnes den bare i superklassen, brukes den arvede.

Rekkefølgen Python leter i, kan du se med Klasse.__mro__ (method resolution order):

print([k.__name__ for k in Brukskonto.__mro__])
['Brukskonto', 'Konto', 'object']

Først Brukskonto, så Konto, og til slutt object, som alle klasser arver fra.

class A:
    def hils(self):
        return "A"
    def hei(self):
        return "hei fra A"

class B(A):
    def hils(self):
        return "B"

b = B()
print(b.hils())
print(b.hei())

Hvilke metoder finnes i B?

B og hei fra A. hils er overstyrt i B, så den brukes. hei finnes bare i A, så Python bruker den arvede.

Overstyre spesialmetoder

Spesialmetodene fra kapittel 6 arves også, og kan overstyres på samme måte. Her gir Konto en felles tekst, og Sparekonto endrer den:

class Sparekonto(Konto):
    RENTE = 0.03

    def __str__(self):
        return f"Sparekonto for {self.eier}: {self.saldo} kr"

print(Konto("Kari"))
print(Sparekonto("Mia"))
Kari: 0 kr
Sparekonto for Mia: 0 kr

Både Konto og Sparekonto har en __str__, men print bruker alltid den som hører til objektets egen klasse. Slik får hver klasse sin egen tekst uten at koden som skriver ut, må vite hvilken klasse det er. Dette er polymorfi, som du ser mer på i 7.3.1.

Overstyr __str__ i Brukskonto slik at den viser Brukskonto for <eier>: <saldo> kr (kreditt <KREDITT>).

Skriv en ny __str__ i Brukskonto, med self.KREDITT.

class Brukskonto(Konto):
    KREDITT = 5000

    def __str__(self):
        return (f"Brukskonto for {self.eier}: {self.saldo} kr "
                f"(kreditt {self.KREDITT})")

print(Brukskonto("Jon"))
Brukskonto for Jon: 0 kr (kreditt 5000)

Når bør du overstyre?

Overstyring passer når subklassen skal gjøre det samme som superklassen, men på sin egen måte, for eksempel å ta ut penger med andre regler. Ett viktig prinsipp: subklassen skal fortsatt kunne brukes overalt der superklassen brukes. Hvis en funksjon tar imot en Konto og kaller ta_ut(100), skal den fortsatt gi mening når den får en Brukskonto. Lager du en ta_ut i subklassen som for eksempel returnerer en tekst i stedet for å ta ut penger, bryter du forventningen.

AdvarselVanlige feil
  • Å stave metodenavnet litt annerledes (taut, ta_ut_penger). Da er det en ny metode, ikke en overstyring, og den gamle brukes fortsatt.
  • Å endre antall parametere, så koden som kaller metoden på superklassen, krasjer.
  • Å overstyre og glemme at du da mister alt superklassens versjon gjorde (se super() i 7.2.2).
  • Å la den overstyrte metoden gi en annen type svar enn den opprinnelige.
  • Å overstyre for å gjøre noe helt annet. Da passer kanskje ikke arven.
  • Å skrive metoden i feil klasse, så den arvede versjonen fortsatt brukes.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1
class Dyr:
    def lyd(self):
        return "..."

    def snakk(self):
        return "Dyret sier " + self.lyd()

class Hund(Dyr):
    def lyd(self):
        return "Voff"

class Fisk(Dyr):
    pass

print(Hund().snakk())
print(Fisk().snakk())

snakk kaller self.lyd(). Hvilken lyd finner Python for hvert objekt?

Dyret sier Voff og Dyret sier .... snakk er arvet av begge, men self.lyd() bruker klassen til objektet: Hund har en overstyrt lyd, mens Fisk bruker den arvede.

class Konto:
    def ta_ut(self, belop):
        ...

class Brukskonto(Konto):
    def taut(self, belop):
        ...

Hva skjer med Brukskonto("Jon").ta_ut(100)?

Metoden i Brukskonto heter taut, ikke ta_ut, så den overstyrer ikke noe. Det er en ny metode ved siden av. ta_ut(100) bruker den arvede versjonen fra Konto, så brukskontoen får ikke kredittregelen.

Nivå 2
class A:
    def hils(self):
        return "A"

class B(A):
    pass

class C(B):
    def hils(self):
        return "C"

print(A().hils(), B().hils(), C().hils())

A A C. B har ikke egen hils, så den arver fra A. C overstyrer den.

En funksjon uttak(konto) kaller konto.ta_ut(100) og regner med at saldoen blir \(100\) lavere. Du lager en subklasse Pengeskap(Konto) der ta_ut bare skriver ut «Ikke tilgjengelig» uten å trekke fra noe. Hva er galt?

Subklassen kan ikke lenger brukes der superklassen brukes: funksjonen uttak forventer at ta_ut trekker fra saldoen, og får det ikke. Overstyringen endret hva metoden betyr, ikke bare hvordan den gjør det. Er oppførselen helt annerledes, passer arv dårlig, og du bør vurdere en annen løsning.

Kodeoppgaver

Konto er gitt. Skriv Brukskonto med klasseattributtet KREDITT = 5000, og en overstyrt ta_ut(belop) som lar saldoen gå ned til minus kreditten. Beløpet må være positivt, og går uttaket over kredittgrensen, utløses ValueError("Over kredittgrensen") uten å endre noe.

Sjekk belop > self._saldo + self.KREDITT for kredittgrensen.

Dyr er gitt. Skriv Hund (lyd() gir "Voff") og Katt (lyd() gir "Mjau") som overstyrer lyd. Fisk lager ingen lyd, så den bruker Dyr.lyd.

Du trenger bare å skrive lyd i Hund og Katt. snakk er allerede arvet.

Konto er gitt med en __str__. Skriv Sparekonto som overstyrer __str__ slik at str(Sparekonto("Mia")) gir Sparekonto for Mia: 0 kr.

def __str__(self): return f"Sparekonto for {self.eier}: {self.saldo} kr".

Billett er gitt og har pris() som gir \(130\). Skriv Barnebillett (pris \(90\)) og Honnorbillett (pris \(100\)) som overstyrer pris. Skriv også funksjonen sum_pris(billetter) som gir summen av prisene.

sum_pris kaller b.pris() på hver billett. Du trenger ikke vite hvilken type det er.

Brukskontoen skal tillate negativ saldo, men ta_ut bruker fortsatt superklassens regler. Rett koden.

Hva heter metoden i Konto, og hva heter den i Brukskonto?

Utfordringer

Kunde har rabatt() som gir \(0\) (ingen rabatt, som prosent), og pris(grunnpris) som gir grunnpris minus rabatten i prosent. Skriv Student (rabatt \(20\)) og Pensjonist (rabatt \(30\)) som overstyrer bare rabatt. pris skal arves uendret.

Overstyr bare rabatt. pris kaller self.rabatt(), som finner den riktige versjonen.

Gi et eksempel på en overstyring som bryter forventningen til superklassen, og forklar hvorfor det er et problem.

Et eksempel er en subklasse LesKonto(Konto) som overstyrer sett_inn og ta_ut til å utløse en feil fordi kontoen er skrivebeskyttet. Alle funksjoner som får en Konto og setter inn penger, vil nå krasje når de får en LesKonto. Subklassen kan ikke brukes overalt der superklassen brukes, og da er det feil å bruke arv. Her bør LesKonto heller være en egen klasse, eller en Konto som har en egenskap for å være skrivebeskyttet.

Oppsummering

Overstyre

class Brukskonto(Konto):
    def ta_ut(self, belop):
        ...   # ny versjon

Hvilken metode?

  1. Klassen til objektet
  2. Superklassen
  3. Videre oppover til object

Se rekkefølgen

Brukskonto.__mro__
  • Samme metodenavn i subklassen overstyrer den arvede.
  • Subklassen skal kunne brukes overalt superklassen brukes.
  • Stavefeil i metodenavnet gir en ny metode, ikke en overstyring.

7.1.3 super()

Når du overstyrer en metode, mister du det superklassen gjorde. Ofte vil du heller bygge videre på det: gjøre det superklassen gjør, og så legge til noe. Det gjør du med super(), som gir deg superklassens versjon. Den er særlig viktig i konstruktøren, så subklassen kan ha egne attributter og samtidig la superklassen sette opp sine.

Læringsmål

Etter dette delkapittelet skal du kunne

  • skrive en subklasse-konstruktør som kaller super().__init__(...),
  • bruke super() til å bygge videre på en overstyrt metode,
  • forklare hva som skjer hvis du glemmer super().__init__,
  • skrive en subklasse med flere egne attributter.

super().__init__: konstruktøren i subklassen

Hva om Sparekonto skal ha en rente som er ulik for hver konto? Da trenger konstruktøren en ekstra parameter, og vi må skrive en egen __init__. Men Konto.__init__ setter eier og _saldo, og det vil vi fortsatt ha. Vi kaller derfor superklassens konstruktør med super().__init__(...):

class Sparekonto(Konto):
    def __init__(self, eier, rente):
        super().__init__(eier)       # Konto setter eier og saldo
        self.rente = rente           # Sparekonto legger til rente

    def legg_til_rente(self):
        self._saldo += self._saldo * self.rente

s = Sparekonto("Mia", 0.05)
s.sett_inn(1000)
s.legg_til_rente()
print(s.eier, s.saldo, s.rente)
Mia 1050.0 0.05

super() gir deg «superklassen sin del» av objektet, og super().__init__(eier) kjører Konto.__init__ for det samme objektet. Resultatet er at s har både eier og _saldo (fra Konto) og rente (fra Sparekonto). Du skriver ikke self inn i super().__init__(...).

Regelsuper().__init__

I en subklasse med egen konstruktør:

  1. Kall super().__init__(...) først, med det superklassen trenger.
  2. Sett deretter subklassens egne attributter.

Glemmer du kallet, blir attributtene fra superklassen aldri laget.

Her er hva som skjer hvis du glemmer det:

class Feil(Konto):
    def __init__(self, eier, rente):
        self.rente = rente        # Glemte super().__init__

f = Feil("Mia", 0.05)
try:
    f.sett_inn(100)
except AttributeError as feil:
    print("AttributeError:", feil)
AttributeError: 'Feil' object has no attribute '_saldo'

Konto.__init__ ble aldri kjørt, så objektet har verken _saldo eller eier. Feilen dukker først opp når noe prøver å bruke dem, og det kan være langt fra stedet der du glemte kallet.

Person har navn. Lag Elev med navn og klasse. Bruk super().

super().__init__(navn) først, så self.klasse = klasse.

class Person:
    def __init__(self, navn):
        self.navn = navn

class Elev(Person):
    def __init__(self, navn, klasse):
        super().__init__(navn)
        self.klasse = klasse

e = Elev("Kari", "2IT")
print(e.navn, e.klasse)
Kari 2IT

super() i andre metoder

super() virker i alle metoder, ikke bare konstruktøren. Det er nyttig når subklassen skal gjøre det samme som superklassen, pluss litt til. Her logger en sparekonto hvert uttak, men bruker Konto.ta_ut til selve uttaket (og beholder alle kontrollene):

class LoggetKonto(Konto):
    def __init__(self, eier):
        super().__init__(eier)
        self.logg = []

    def ta_ut(self, belop):
        super().ta_ut(belop)             # Konto tar ut (og kontrollerer)
        self.logg.append(f"Uttak: {belop}")

k = LoggetKonto("Jon")
k.sett_inn(500)
k.ta_ut(200)
try:
    k.ta_ut(1000)
except ValueError as feil:
    print(feil)
print(k.logg)
Ikke nok penger
['Uttak: 200']

Det mislykkede uttaket (1000) ble ikke logget, fordi super().ta_ut(belop) utløste en feil før logglinja kjørte. Vi slapp å kopiere alle kontrollene fra Konto.

Samme teknikk gir en __str__ som bygger på superklassens tekst:

class Sparekonto(Konto):
    def __init__(self, eier, rente):
        super().__init__(eier)
        self.rente = rente

    def __str__(self):
        return super().__str__() + f" (rente {self.rente * 100:.0f} %)"

print(Sparekonto("Mia", 0.03))
Mia: 0 kr (rente 3 %)

Teksten fra Konto (Mia: 0 kr) brukes som den er, og subklassen legger bare til renten.

class A:
    def hils(self):
        return "A"

class B(A):
    def hils(self):
        return super().hils() + "B"

class C(B):
    def hils(self):
        return super().hils() + "C"

print(C().hils())

super() i C er B, og super() i B er A.

ABC. C.hils kaller B.hils, som kaller A.hils (gir "A"). Så legger B til "B", og C legger til "C".

Konstruktør med flere nivåer

Har hierarkiet flere nivåer, kaller hver konstruktør sin nærmeste superklasse, som kaller sin, og så videre oppover. Du trenger bare å bry deg om det neste nivået:

class Dyr:
    def __init__(self, navn):
        self.navn = navn

class Pattedyr(Dyr):
    def __init__(self, navn, antall_ben):
        super().__init__(navn)
        self.antall_ben = antall_ben

class Hund(Pattedyr):
    def __init__(self, navn):
        super().__init__(navn, 4)

fido = Hund("Fido")
print(fido.navn, fido.antall_ben)
Fido 4

Hund trenger bare å oppgi navnet, siden alle hunder har fire ben. Den sender 4 videre til Pattedyr, som sender navnet videre til Dyr.

AdvarselVanlige feil
  • Å glemme super().__init__(...) i subklassens konstruktør. Du får AttributeError senere.
  • Å sende self til super().__init__(self, ...). Skal ikke med.
  • Å kalle super().__init__ med feil antall parametere.
  • Å sette attributtene som superklassen trenger etter at du har brukt dem. Kall super().__init__ først.
  • Å skrive super.__init__(...) uten parentes etter super.
  • Å bruke super() utenfor en metode i en klasse.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1
class Dyr:
    def __init__(self, navn):
        self.navn = navn

class Hund(Dyr):
    def __init__(self, navn, rase):
        super().__init__(navn)
        self.rase = rase

h = Hund("Fido", "labrador")
print(h.navn, h.rase)

Fido labrador. super().__init__(navn) setter navn (i Dyr), og Hund setter rase selv.

class Person:
    def __init__(self, navn):
        self.navn = navn

class Elev(Person):
    def __init__(self, navn, klasse):
        self.klasse = klasse

e = Elev("Kari", "2IT")
print(e.navn)

Hva skjer, og hvordan rettes det?

Det gir AttributeError: 'Elev' object has no attribute 'navn'. Elev.__init__ kaller ikke Person.__init__, så navn blir aldri satt. Rett med super().__init__(navn) som første linje i konstruktøren.

Nivå 2
class Konto:
    def __init__(self):
        self.saldo = 0
    def sett_inn(self, belop):
        self.saldo += belop

class Bonuskonto(Konto):
    def sett_inn(self, belop):
        super().sett_inn(belop)
        self.saldo += 10

b = Bonuskonto()
b.sett_inn(100)
b.sett_inn(50)
print(b.saldo)

Hver innsetting gir beløpet pluss \(10\).

170. Første innsetting gir \(100 + 10\), andre gir \(50 + 10\), og \(110 + 60 = 170\). super().sett_inn(belop) gjør den vanlige innsettingen, og subklassen legger til bonusen.

I en subklasse-konstruktør skriver du self.rente = rente før super().__init__(eier). Hva er risikoen, og hva er beste praksis?

Superklassens konstruktør kan overskrive attributter du har satt, eller bruke noe som ikke er satt ennå. Selv om det av og til går bra, er beste praksis å kalle super().__init__(...) først, så superklassens del av objektet er ferdig satt opp før subklassen legger til sitt.

Kodeoppgaver

Konto er gitt. Skriv Sparekonto med konstruktør som tar eier og rente (bruk super()), og metoden legg_til_rente() som øker saldoen med renten.

super().__init__(eier) og så self.rente = rente.

Person er gitt med navn. Skriv Elev med navn og klasse, og Laerer med navn og fag. Begge bruker super().

super().__init__(navn) først i begge konstruktørene.

Konto er gitt. Skriv LoggetKonto med en tom liste logg. ta_ut(belop) bruker Konto.ta_ut via super(), og legger bare teksten Uttak: <belop> til i logg hvis uttaket gikk bra.

Kall super().ta_ut(belop) først. Skjer det en feil der, kjører ikke linja under.

Person har __str__ som gir navnet. Skriv Elev (med navn og klasse) der __str__ gir Kari (2IT), ved å bruke super().__str__().

return super().__str__() + f" ({self.klasse})".

Elev("Kari", "2IT").navn krasjer. Rett koden.

Hvilken konstruktør settes navn i, og blir den kjørt?

Utfordringer

Skriv Dyr (navn), Pattedyr(Dyr) (navn, antall_ben) og Hund(Pattedyr) (bare navn; fire ben og rase = "ukjent" som attributt). Alle bruker super(). Hund har også metoden beskriv() som gir <navn> har <antall_ben> ben.

Hund.__init__(self, navn) kaller super().__init__(navn, 4), som kaller Dyr.__init__(navn).

Forklar forskjellen på å overstyre en metode helt og å overstyre den og bruke super(). Når velger du hva?

Overstyrer du helt (uten super()), erstatter subklassens versjon superklassens, som ikke kjøres. Bruker du super(), kjører superklassens versjon først (eller sist), og subklassen bygger videre på den. Du overstyrer helt når subklassen gjør noe grunnleggende annerledes (brukskontoens kredittregel). Du bruker super() når du vil beholde det superklassen gjør og bare legge til noe (logging, ekstra attributter, en lenger tekst), så du slipper å kopiere koden.

Oppsummering

Konstruktør

class Elev(Person):
    def __init__(self, navn, klasse):
        super().__init__(navn)
        self.klasse = klasse

Bygge videre

def ta_ut(self, belop):
    super().ta_ut(belop)
    self.logg.append(belop)

Tekst

def __str__(self):
    return super().__str__() + "!"
  • Kall super().__init__(...) først, uten self i parentesen.
  • Glemmer du det, mangler attributtene fra superklassen.
  • super() gir deg superklassens versjon av metoden.

7.2 Polymorfi

Arv gjør noe mer enn å spare kode: den lar deg bruke objekter av ulike klasser på samme måte.

7.2.1 Samme metode, ulike klasser

Du trykker på en av-knapp. På en TV slår den av bildet, på en radio slår den av lyden, og på en lampe slukker den lyset. Du bryr deg ikke om hva som skjer inni, bare at knappen gjør det riktige for akkurat denne tingen. Polymorfi (gresk: «mange former») betyr akkurat det: samme kall, men hvert objekt gjør det på sin måte. Koden som bruker objektene, trenger ikke vite hvilken type de er.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva polymorfi er, og vise det i en liste med ulike objekter,
  • skrive kode som bruker objekter uten å sjekke typen,
  • legge til en ny klasse uten å endre koden som bruker dem,
  • forklare duck typing.

Én løkke, mange klasser

Vi lager noen former, som alle har en metode areal(), men som regner det ut på sin egen måte:

import math

class Rektangel:
    def __init__(self, bredde, hoyde):
        self.bredde = bredde
        self.hoyde = hoyde

    def areal(self):
        return self.bredde * self.hoyde

class Sirkel:
    def __init__(self, radius):
        self.radius = radius

    def areal(self):
        return math.pi * self.radius ** 2

class Trekant:
    def __init__(self, grunnlinje, hoyde):
        self.grunnlinje = grunnlinje
        self.hoyde = hoyde

    def areal(self):
        return self.grunnlinje * self.hoyde / 2

former = [Rektangel(3, 4), Sirkel(1), Trekant(6, 5)]

total = 0
for form in former:
    total += form.areal()
print(round(total, 2))
30.14

Løkka kaller form.areal() uten å vite om objektet er et rektangel, en sirkel eller en trekant. Hver klasse svarer på sin måte, og løkka bare summerer. Det er polymorfi: samme metodenavn, ulik oppførsel avhengig av objektet.

Se hva alternativet ville vært uten polymorfi:

for form in former:
    if type(form) == Rektangel:
        total += form.bredde * form.hoyde
    elif type(form) == Sirkel:
        total += math.pi * form.radius ** 2
    elif type(form) == Trekant:
        total += form.grunnlinje * form.hoyde / 2

Her må koden som bruker formene, kjenne til alle typene og detaljene i dem. Legger vi til Femkant, må vi huske å endre denne kjeden, og alle andre steder der vi har en tilsvarende. Med polymorfi lager vi bare en ny klasse med areal(), og all eksisterende kode virker uten endringer.

RegelPolymorfi
  • Gi alle klassene samme metodenavn for det de har til felles (areal()).
  • Koden som bruker objektene, kaller metoden uten å sjekke typen.
  • Hver klasse bestemmer selv hvordan metoden virker.
  • Å legge til en ny klasse krever ikke at du endrer koden som bruker dem.

Billett, Barnebillett og Honnorbillett har alle pris(), med verdiene \(130\), \(90\) og \(100\). Hva er summen av pris() for lista [Billett(), Barnebillett(), Barnebillett(), Honnorbillett()], og hvordan skriver du koden uten if?

Kall pris() på hvert objekt.

Summen er \(130 + 90 + 90 + 100 = 410\). Koden:

total = 0
for b in billetter:
    total += b.pris()

Løkka vet ikke hvilken type billett det er. Hvert objekt svarer med sin egen pris.

Polymorfi med arv

Ofte lager vi formene som subklasser av en felles klasse. Da har de garantert de samme metodene, og vi kan skrive den delen som er lik ett sted. Her har Form en felles beskriv() som bruker areal(), mens hver subklasse regner ut sitt eget areal:

class Form:
    def areal(self):
        return 0

    def beskriv(self):
        return f"{type(self).__name__} med areal {self.areal():.1f}"

class Rektangel(Form):
    def __init__(self, bredde, hoyde):
        self.bredde = bredde
        self.hoyde = hoyde

    def areal(self):
        return self.bredde * self.hoyde

class Sirkel(Form):
    def __init__(self, radius):
        self.radius = radius

    def areal(self):
        return math.pi * self.radius ** 2

for form in [Rektangel(3, 4), Sirkel(2)]:
    print(form.beskriv())
Rektangel med areal 12.0
Sirkel med areal 12.6

beskriv() finnes bare i Form, men kaller self.areal(). Det som skjer, er at Python leter etter areal i klassen til objektet, og finner subklassens versjon. Samme beskriv() gir derfor ulike svar for ulike former. type(self).__name__ gir navnet på klassen som tekst.

Duck typing: det holder at objektet kan det du ber om

I Python trenger ikke objektene dele en superklasse for å brukes polymorfisk. Det holder at de har metoden. Dette kalles duck typing: «hvis det går som en and og kvekker som en and, er det en and». Koden spør ikke hva objektet er, bare om det kan det vi ber om.

class Hund:
    def lyd(self):
        return "Voff"

class Robot:
    def lyd(self):
        return "Biip"

for ting in [Hund(), Robot()]:
    print(ting.lyd())
Voff
Biip

Hund og Robot har ikke noe med hverandre å gjøre, men begge har lyd(), så løkka virker. Du har brukt duck typing hele tiden: len(x) virker for lister, tekster og ordbøker, og print(x) virker for alle objekter som har __str__. Det er polymorfi på innebygde klasser.

NoteArv eller duck typing?

Arv gir deg delt kode og en garanti for at metodene finnes (spesielt med abstrakte klasser, se 7.4.1). Duck typing er mer fleksibelt, men ingen sjekker at metoden finnes før programmet kjører og krasjer med AttributeError. Bruk arv når klassene virkelig er varianter av det samme, og duck typing når ulike klasser tilfeldigvis kan det samme.

En ny klasse uten å endre noe

Her ser du kraften i polymorfi. Vi legger til en ny form, og funksjonen som summerer arealene, endres ikke:

def sum_areal(former):
    return sum(f.areal() for f in former)

class Kvadrat(Rektangel):
    def __init__(self, side):
        super().__init__(side, side)

print(sum_areal([Rektangel(3, 4), Kvadrat(5)]))
37

sum_areal er skrevet før Kvadrat fantes, men virker likevel for den. Koden er åpen for utvidelse uten at du må endre den.

AdvarselVanlige feil
  • Å bruke en kjede av if type(x) == ... i stedet for polymorfi.
  • Å gi metodene ulike navn i ulike klasser (areal(), finn_areal(), beregn()), så løkka ikke kan kalle dem likt.
  • Å la metodene ha ulike parametere, så de ikke kan kalles likt.
  • Å la en klasse mangle metoden, så du får AttributeError midt i løkka.
  • Å la metoder med samme navn gjøre helt ulike ting.
  • Å tro at objektene må ha en felles superklasse. I Python holder det at de har metoden.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1
class Hund:
    def lyd(self):
        return "Voff"

class Katt:
    def lyd(self):
        return "Mjau"

class And:
    def lyd(self):
        return "Kvakk"

for dyr in [Hund(), Katt(), And(), Hund()]:
    print(dyr.lyd())

Voff, Mjau, Kvakk og Voff, hver på sin linje. Løkka kaller lyd() på hvert objekt, og hver klasse svarer på sin måte.

Forklar med egne ord hva polymorfi er, og hva som er fordelen.

Polymorfi betyr at objekter av ulike klasser kan brukes på samme måte, ved at de har samme metodenavn, men hver gjør det på sin måte. Fordelen er at koden som bruker objektene, ikke trenger å vite hvilken type de er (ingen lange if-kjeder), og at du kan legge til nye klasser uten å endre den.

Nivå 2
class Hund:
    def lyd(self):
        return "Voff"

class Fisk:
    pass

for dyr in [Hund(), Fisk()]:
    print(dyr.lyd())

Hva skjer, og hvordan kan det løses?

Hunden skriver Voff, men så krasjer det med AttributeError: 'Fisk' object has no attribute 'lyd', fordi fisken ikke har metoden. Løsningen er å gi Fisk en lyd() (for eksempel som returnerer en tom tekst), eller å lage en felles superklasse Dyr med en standard lyd() som alle arver.

Skriv om denne koden til polymorfi. Hvilke endringer trengs?

def pris(billett):
    if type(billett) == Voksenbillett:
        return 130
    elif type(billett) == Barnebillett:
        return 90
    elif type(billett) == Honnorbillett:
        return 100

Gi hver klasse en metode pris():

class Voksenbillett:
    def pris(self):
        return 130

class Barnebillett:
    def pris(self):
        return 90

class Honnorbillett:
    def pris(self):
        return 100

Så kaller du bare billett.pris() der du før kalte funksjonen. Legger du til en ny billettype, lager du bare en ny klasse, og ingen eksisterende kode må endres.

Kodeoppgaver

Rektangel, Sirkel og Trekant er gitt, og alle har areal(). Skriv funksjonen sum_areal(former) som summerer arealene, uten å sjekke typene.

sum(f.areal() for f in former).

Skriv Hund (lyd() gir "Voff"), Katt ("Mjau") og Ku ("Muu"), uten arv. Skriv så funksjonen kor(dyr) som gir én tekst med alle lydene adskilt med mellomrom, i rekkefølge.

" ".join(d.lyd() for d in dyr).

Skriv Fast (konstruktør med manedslonn, lonn() gir den), Timebasert (konstruktør med timelonn og timer, lonn() gir produktet) og Provisjon (konstruktør med grunnlonn og salg, lonn() gir grunnlønnen pluss \(10\) % av salget). Skriv total_lonn(ansatte).

Alle tre har lonn() uten parametere. total_lonn summerer a.lonn().

Form er gitt med beskriv() som bruker areal(). Skriv Rektangel og Kvadrat (som arver fra Rektangel) med riktig areal(). beskriv() skal arves uendret.

Kvadrat.__init__(self, side) kaller super().__init__(side, side).

Funksjonen under bruker en if-kjede. Skriv om koden slik at hver klasse har pris(), og total(billetter) summerer uten å sjekke typen.

Gi hver klasse metoden pris(), og la total summere b.pris().

Utfordringer

Konto har manedsavslutning() som ikke gjør noe. Sparekonto (konstruktør med eier og rente) legger renten til saldoen. Brukskonto trekker en fast månedsavgift på \(50\) kroner. Skriv funksjonen avslutt_maned(kontoer) som kaller manedsavslutning() på alle kontoene.

Sparekonto.__init__(self, eier, rente, saldo=0) kaller super().__init__(eier, saldo). avslutt_maned kaller k.manedsavslutning() for hver konto.

I sum_areal over kaller vi f.areal() uten å vite typen. Hva skjer hvis vi legger til en klasse som mangler areal(), og hvordan kan en abstrakt klasse (7.4.1) hindre problemet?

Programmet krasjer med AttributeError den dagen noen kaller areal() på objektet, og det kan være langt fra der klassen ble laget. En abstrakt superklasse med en abstrakt metode areal() hindrer at du i det hele tatt kan lage et objekt av en subklasse som mangler den, så feilen kommer med en gang, ikke først midt i en løkke.

Oppsummering

Polymorfi

for form in former:
    total += form.areal()

Samme kall, ulik oppførsel.

Med arv

class Form:
    def beskriv(self):
        return self.areal()

Metoden i superklassen kaller subklassens versjon.

Duck typing

Det holder at objektet har metoden.

  • Ingen if type(x) == .... La objektet svare selv.
  • Nye klasser kan legges til uten å endre koden som bruker dem.
  • Samme metodenavn og parametere i alle klassene.

7.3 Abstrakte klasser

Noen klasser er bare en mal for andre. Her lærer du å si det tydelig i koden.

7.3.1 Abstrakte klasser med abc

Kan du bygge et «dyr»? Du kan bygge en hund, en katt eller en fisk, men ikke bare et dyr uten å si hva slags. Klassen Dyr er en idé, en mal som sier hva alle dyr har til felles, men den beskriver ikke noe konkret. I kode kaller vi en slik klasse abstrakt. Den kan ikke brukes til å lage objekter, men tvinger alle subklassene til å fylle ut det som mangler.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva en abstrakt klasse og en abstrakt metode er,
  • lage dem med ABC og @abstractmethod,
  • forklare hva som skjer hvis du lager et objekt av en abstrakt klasse eller en ufullstendig subklasse,
  • blande abstrakte og vanlige metoder i samme klasse.

Abstrakt klasse og abstrakt metode

I Form fra forrige delkapittel returnerte areal() bare \(0\), og ingenting hindret oss i å lage et Form()-objekt som ikke er noe som helst. Med modulen abc (abstract base classes) kan vi gjøre Form abstrakt:

from abc import ABC, abstractmethod

class Form(ABC):
    @abstractmethod
    def areal(self):
        """Gir arealet. Må skrives i hver subklasse."""

    @abstractmethod
    def omkrets(self):
        """Gir omkretsen. Må skrives i hver subklasse."""

    def beskriv(self):
        return (f"{type(self).__name__}: areal {self.areal():.1f}, "
                f"omkrets {self.omkrets():.1f}")
  • Form(ABC): klassen arver fra ABC, som gjør den abstrakt.
  • @abstractmethod over en metode betyr at metoden må skrives i hver subklasse. Selve metoden har ingen kode (bare en docstring).
  • beskriv() er en vanlig metode med kode, som alle subklasser arver. Den bruker de abstrakte metodene, og de er garantert å finnes.

Du kan ikke lage et objekt av en abstrakt klasse:

try:
    f = Form()
except TypeError as feil:
    print("TypeError:", feil)
TypeError: Can't instantiate abstract class Form without an implementation for abstract methods 'areal', 'omkrets'

Python nekter, og sier hvilke abstrakte metoder som mangler. En subklasse må skrive alle de abstrakte metodene for at den skal kunne brukes:

class Rektangel(Form):
    def __init__(self, bredde, hoyde):
        self.bredde = bredde
        self.hoyde = hoyde

    def areal(self):
        return self.bredde * self.hoyde

    def omkrets(self):
        return 2 * (self.bredde + self.hoyde)

class Halvferdig(Form):
    def areal(self):
        return 1

r = Rektangel(3, 4)
print(r.beskriv())

try:
    h = Halvferdig()
except TypeError as feil:
    print("TypeError:", feil)
Rektangel: areal 12.0, omkrets 14.0
TypeError: Can't instantiate abstract class Halvferdig without an implementation for abstract method 'omkrets'

Rektangel skriver begge de abstrakte metodene, så den virker, og får beskriv() gratis. Halvferdig glemte omkrets, så Python nekter å lage et objekt av den. Feilen kommer med en gang objektet lages, ikke først når omkrets() blir kalt langt ut i programmet.

RegelAbstrakte klasser
from abc import ABC, abstractmethod

class Form(ABC):
    @abstractmethod
    def areal(self):
        ...
  • Klassen arver fra ABC.
  • Abstrakte metoder har @abstractmethod og ingen egentlig kode.
  • Du kan ikke lage objekter av en klasse med abstrakte metoder.
  • En subklasse må skrive alle de abstrakte metodene for å bli konkret.
  • Vanlige metoder og konstruktører i en abstrakt klasse arves som vanlig.

I UML skrives en abstrakt klasse ofte med merkelappen <<abstract>> over navnet, eller med kursivt klassenavn. Abstrakte metoder skrives kursivt eller med {abstract}.

classDiagram
    class Form {
        <<abstract>>
        +areal()* float
        +omkrets()* float
        +beskriv() str
    }
    Form <|-- Rektangel
    Form <|-- Sirkel

Hvilke av disse bør være abstrakte: Dyr, Hund, Kjoretoy, Bil?

Kan du lage et helt konkret objekt av klassen, eller er den bare en idé?

Dyr og Kjoretoy bør være abstrakte: du treffer aldri «et dyr» uten at det er en bestemt art, og aldri «et kjøretøy» uten at det er en bil, en sykkel eller noe annet. Hund og Bil er konkrete og kan lages som objekter.

Ferdig kode og krav i samme klasse

Den abstrakte klassen kan ha en konstruktør og vanlige metoder som subklassene arver, og i tillegg abstrakte metoder som subklassene må skrive. Slik får du en mal der det felles er ferdig, og det forskjellige må fylles ut. Det kalles malmetoden (template method): superklassen bestemmer rekkefølgen, og subklassene fyller inn detaljene.

class Ansatt(ABC):
    def __init__(self, navn):
        self.navn = navn

    @abstractmethod
    def lonn(self):
        """Månedslønn i kroner."""

    def lonnsslipp(self):
        return f"{self.navn}: {self.lonn()} kr"

class Fast(Ansatt):
    def __init__(self, navn, manedslonn):
        super().__init__(navn)
        self.manedslonn = manedslonn

    def lonn(self):
        return self.manedslonn

print(Fast("Per", 30000).lonnsslipp())
Per: 30000 kr

lonnsslipp() er skrevet én gang, i den abstrakte klassen, og bruker lonn(), som hver subklasse må skrive. Merk at den abstrakte klassen har en vanlig konstruktør, som subklassen kaller med super().

NoteUten abc

Du kan lage lignende krav uten abc, ved å la metoden i superklassen utløse NotImplementedError: raise NotImplementedError("Skal skrives i subklassen"). Da kommer feilen først når metoden kalles, og du kan fortsatt lage objekter av superklassen. abc er bedre, for da kommer feilen allerede når objektet lages.

AdvarselVanlige feil
  • Å glemme ABC som superklasse. Da virker @abstractmethod ikke, og du kan lage objekter.
  • Å glemme @abstractmethod, så metoden ikke er abstrakt.
  • Å glemme å skrive alle de abstrakte metodene i subklassen.
  • Å prøve å lage et objekt av den abstrakte klassen.
  • Å stave metoden annerledes i subklassen (areal og Areal), så den abstrakte fortsatt mangler.
  • Å gjøre en klasse abstrakt når den burde være konkret og brukes direkte.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Forklar med egne ord hva en abstrakt klasse er, og hva en abstrakt metode er.

En abstrakt klasse er en klasse du ikke kan lage objekter av, og som brukes som mal for subklasser. En abstrakt metode er en metode som er erklært i den abstrakte klassen, men uten kode, og som hver subklasse må skrive for å bli konkret.

from abc import ABC, abstractmethod

class Dyr(ABC):
    @abstractmethod
    def lyd(self):
        ...

d = Dyr()

Det gir TypeError: Can't instantiate abstract class Dyr ..., fordi Dyr har en abstrakt metode og dermed ikke kan brukes til å lage objekter.

Nivå 2
from abc import ABC, abstractmethod

class Form(ABC):
    @abstractmethod
    def areal(self):
        ...

    @abstractmethod
    def omkrets(self):
        ...

class Kvadrat(Form):
    def __init__(self, side):
        self.side = side

    def areal(self):
        return self.side ** 2

k = Kvadrat(3)

Hva skjer, og hvordan rettes det?

Det gir TypeError, fordi Kvadrat ikke har skrevet omkrets, som er abstrakt. Rett ved å legge til def omkrets(self): return 4 * self.side.

For hver metode: hører den hjemme som abstrakt metode eller som vanlig metode i Ansatt?

lonn(), som regnes ut på ulikt vis for fast, timebasert og provisjon.
Abstrakt: hver subklasse må skrive sin egen. b) Vanlig: den er lik for alle og bruker lonn(). c) Vanlig: lik for alle, så den skrives én gang i superklassen.
lonnsslipp(), som setter sammen navnet og lønnen på samme måte for alle.
endre_navn(nytt), som er lik for alle.
Kodeoppgaver

Skriv den abstrakte klassen Form (med ABC) med de abstrakte metodene areal() og omkrets(), og skriv Kvadrat (med side) som arver fra den.

from abc import ABC, abstractmethod. class Form(ABC): med @abstractmethod over begge metodene.

Form er gitt som abstrakt med areal(), og beskriv() som gir <klassenavn>: <areal>. Skriv Rektangel og Sirkel som arver fra den.

Skriv konstruktør og areal() i begge. beskriv er arvet.

Skriv den abstrakte klassen Ansatt med konstruktør (navn), abstrakt lonn() og vanlig lonnsslipp() som gir <navn>: <lonn> kr. Skriv Fast (med manedslonn) og Timebasert (med timelonn og timer).

Fast.__init__(self, navn, manedslonn) kaller super().__init__(navn).

Dyr skal være abstrakt, men Dyr() virker. Rett koden.

Importer ABC og abstractmethod, og bruk dem i Dyr.

Skriv den abstrakte klassen Figur med abstrakt areal(), og vanlig er_storre_enn(annen) som gir True hvis denne figuren har større areal enn annen. Skriv Rektangel og Sirkel.

er_storre_enn gir self.areal() > annen.areal(). Den virker for alle figurer, fordi alle har areal().

Utfordringer

Skriv den abstrakte klassen Karakter med navn og liv (starter på \(100\)), abstrakt angrip() (gir skaden), og vanlig ta_skade(n) (trekker fra liv, aldri under \(0\)) og er_levende(). Skriv Kriger (angrip() gir \(20\)) og Magiker (angrip() gir \(35\)). Skriv kamp(a, b) som lar a angripe b én gang, og gir True hvis b fortsatt lever.

I kamp(a, b) kaller du b.ta_skade(a.angrip()) og gir b.er_levende().

Hva er fordelen med en abstrakt klasse sammenlignet med en vanlig superklasse der metodene bare er pass?

Med en abstrakt klasse kan du ikke lage objekter av superklassen eller av en subklasse som glemmer en metode, så feilen kommer med en gang objektet lages, ikke først når metoden kalles. Klassen dokumenterer også tydelig hva subklassene må skrive. Med en vanlig klasse og pass får du bare None tilbake når du glemmer metoden, og feilen kan vise seg langt senere og være vanskelig å finne.

Oppsummering

Abstrakt klasse

from abc import ABC, abstractmethod

class Form(ABC):
    @abstractmethod
    def areal(self):
        ...

    def beskriv(self):
        return f"{self.areal()}"

Subklassen

class Kvadrat(Form):
    def areal(self):
        return self.side ** 2

UML

<<abstract>> over klassenavnet

  • Du kan ikke lage objekter av en abstrakt klasse.
  • Subklassen må skrive alle abstrakte metoder.
  • Vanlige metoder i den abstrakte klassen arves som vanlig.

7.4 Når bør man ikke bruke arv?

Arv er kraftig, men ikke alltid riktig. Her lærer du å velge.

7.4.1 Arv eller komposisjon

Arv er fristende fordi det sparer kode. Men det binder subklassen tett til superklassen: alt som endres i superklassen, påvirker alle subklasser. Å bruke arv bare for å slippe å skrive kode flere ganger, uten at subklassen virkelig er en superklasse, gir ofte rot. Det finnes et alternativ: la klassen ha et objekt av den andre klassen. Det kalles komposisjon, og du kjenner det fra kapittel 5 og 6.

Læringsmål

Etter dette delkapittelet skal du kunne

  • avgjøre om en relasjon er «er en» (arv) eller «har en» (komposisjon),
  • forklare hvorfor arv kan gi problemer, med eksempler,
  • skrive om en løsning med arv til komposisjon,
  • velge mellom arv og komposisjon og begrunne valget.

«Er en» eller «har en»

Husk testen fra 7.1.1:

  • Er en → arv: en sparekonto er en konto.
  • Har en → komposisjon: en bil har en motor.

Det er lett å gjøre feil. Tenk deg at du vil lage en stabel (stack), der du legger noe øverst og tar bort det øverste. Python har allerede list, så hvorfor ikke arve fra den?

class Stabel(list):
    def legg_oppa(self, x):
        self.append(x)

    def ta_av(self):
        return self.pop()

s = Stabel()
s.legg_oppa(1)
s.legg_oppa(2)
s.insert(0, 99)        # Hmm, dette skulle ikke gå an
print(s)
[99, 1, 2]

Stabelen er ikke en liste: en stabel skal bare tillate å legge til og ta bort øverst. Siden Stabel arver alt fra list, kan hvem som helst bruke insert, sort, reverse og alt annet, og bryte reglene for en stabel. Løsningen er komposisjon: stabelen har en liste, og viser bare de metodene den skal ha.

class Stabel:
    def __init__(self):
        self._elementer = []

    def legg_oppa(self, x):
        self._elementer.append(x)

    def ta_av(self):
        return self._elementer.pop()

    def er_tom(self):
        return len(self._elementer) == 0

s = Stabel()
s.legg_oppa(1)
s.legg_oppa(2)
print(s.ta_av())
print(s.er_tom())
print(hasattr(s, "insert"))
2
False
False

Nå har stabelen bare de tre metodene vi har lagd. Listen er skjult inni som et privat attributt, så ingen kan bryte reglene. Dette er innkapsling kombinert med komposisjon.

RegelArv eller komposisjon?
  • Arv når subklassen virkelig er en superklasse og kan brukes overalt der superklassen brukes.
  • Komposisjon når klassen har en annen, eller bare trenger å bruke litt av den.
  • Bruk ikke arv bare for å gjenbruke kode.
  • Er du i tvil, velg komposisjon: den er mer fleksibel.

Når arv går galt

Et klassisk eksempel: er et kvadrat et rektangel? I matematikken ja, men i kode kan det gå galt.

class Rektangel:
    def __init__(self, bredde, hoyde):
        self.bredde = bredde
        self.hoyde = hoyde

    def areal(self):
        return self.bredde * self.hoyde

class Kvadrat(Rektangel):
    def __init__(self, side):
        super().__init__(side, side)

def gjor_bredere(rektangel):
    rektangel.bredde += 1
    return rektangel.areal()

print(gjor_bredere(Rektangel(3, 3)))
k = Kvadrat(3)
print(gjor_bredere(k))
print(k.bredde, k.hoyde)
12
12
4 3

Etter at funksjonen har gjort kvadratet «bredere», er bredden \(4\) og høyden fortsatt \(3\). Det er ikke lenger et kvadrat! Funksjonen gjor_bredere forutsetter at et rektangel kan endre bredden alene, og det gjelder ikke for kvadratet. Subklassen kan ikke brukes overalt der superklassen brukes, og da er arven feil, selv om «et kvadrat er et rektangel» høres riktig ut.

Dette er prinsippet vi så i 7.2.1: en subklasse må kunne erstatte superklassen uten at noe går galt. Her kan kvadratet ikke det, så det er bedre å gjøre dem til to separate klasser, kanskje med en felles abstrakt superklasse Form.

Komposisjon gir fleksibilitet

Komposisjon lar deg også bytte ut deler mens programmet kjører, noe arv ikke kan:

class Bensinmotor:
    def effekt(self):
        return 150

class Elmotor:
    def effekt(self):
        return 300

class Bil:
    def __init__(self, motor):
        self.motor = motor

    def effekt(self):
        return self.motor.effekt()

bil = Bil(Bensinmotor())
print(bil.effekt())
bil.motor = Elmotor()
print(bil.effekt())
150
300

Bilen har en motor og spør den om effekten. Vi bytter motoren, og bilen oppfører seg annerledes uten at klassen Bil endres. Med arv (BilMedBensinmotor, BilMedElmotor) måtte vi hatt en ny klasse for hver kombinasjon, og kunne ikke byttet underveis. Dette bruker polymorfi: motorene har samme metode effekt().

Velg arv eller komposisjon for hvert tilfelle, og begrunn.

  1. Elev og Person
  2. Bil og Motor
  3. Kontaktliste som trenger å lagre kontakter i en liste
  4. Sparekonto og Konto

Er-en eller har-en? Kan subklassen brukes overalt der superklassen brukes?

  1. Arv: en elev er en person. b) Komposisjon: en bil har en motor. c) Komposisjon: en kontaktliste har en liste, men er ikke en liste, og skal ikke få alle listemetodene. d) Arv: en sparekonto er en konto, og kan brukes der en konto brukes.
NoteHold hierarkiet grunt

Dype hierarkier med mange nivåer er vanskelige å forstå og endre, siden en endring øverst påvirker alt nedenfor. Hold arven til ett eller to nivåer. Trenger du å kombinere egenskaper fra flere kilder (en bil som både er et kjøretøy og har en motor og et radiosystem), er komposisjon ofte bedre enn flere nivåer med arv.

AdvarselVanlige feil
  • Å bruke arv bare for å gjenbruke kode, uten at det er «er en».
  • Å arve fra list eller dict og dermed gi fra seg kontrollen over metodene.
  • Å lage en subklasse som ikke kan brukes der superklassen brukes.
  • Å lage dype hierarkier.
  • Å bruke komposisjon, men glemme å skjule objektet (gjøre attributtet privat).
  • Å tro at arv alltid er mer «objektorientert» enn komposisjon.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Velg arv eller komposisjon.

Hund og Dyr

Er-en eller har-en?

Arv (en hund er et dyr). b) Komposisjon (et hus har rom). c) Komposisjon (et lag har spillere). d) Arv (en lærer er en person). e) Komposisjon (en kino har saler).
Hus og Rom

Er-en eller har-en?

Lag og Spiller

Er-en eller har-en?

Lærer og Person

Er-en eller har-en?

Kino og Sal

Er-en eller har-en?

En kamerat lager class Kontaktliste(list). Hva er problemet?

En kontaktliste har en liste av kontakter, men er ikke en liste. Med arv får den alle listemetodene (insert, sort, reverse, extend …), som kan brukes på måter kontaktlisten ikke er laget for, og som kan bryte reglene (for eksempel at hver kontakt skal ha et navn). Bedre er en klasse med en privat liste og bare de metodene du vil ha (legg_til, finn, fjern).

Nivå 2
class Rektangel:
    def __init__(self, b, h):
        self.bredde = b
        self.hoyde = h

class Kvadrat(Rektangel):
    def __init__(self, s):
        super().__init__(s, s)

k = Kvadrat(4)
k.hoyde = 10
print(k.bredde, k.hoyde)

Hva er galt?

4 10. Objektet er et Kvadrat, men har ulik bredde og høyde, så det er ikke lenger et kvadrat. Subklassen arver attributter som kan endres hver for seg, og klassen kan ikke sikre at sidene er like. Å la Kvadrat arve fra Rektangel bryter kvadratets regler.

Hva er fordelen med at Bil har en motor (komposisjon) framfor at det finnes BensinBil og ElBil som subklasser av Bil?

Med komposisjon kan du bytte motor underveis (bil.motor = Elmotor()), og du slipper en ny klasse for hver kombinasjon av bil og motor. Med arv er motortypen bundet til klassen for objektets hele levetid, og antallet klasser vokser raskt hvis du også har flere gir, farger og så videre.

Kodeoppgaver

Skriv klassen Stabel som har en privat liste. legg_oppa(x) legger øverst, ta_av() fjerner og gir det øverste (utløser IndexError("Stabelen er tom") hvis den er tom), se_overst() gir det øverste uten å fjerne det, og storrelse() gir antallet. Stabelen skal ikke ha listemetoder som insert og sort.

Lagre elementene i self._elementer = [] og bruk append og pop.

Skriv Bensinmotor (effekt() gir \(150\)), Elmotor (effekt() gir \(300\)) og Bil som har en motor sendt inn i konstruktøren. Bil.effekt() spør motoren. Motoren kan byttes.

Bil.__init__(self, motor): self.motor = motor.

Skriv klassen Kontaktliste med en privat liste. legg_til(navn) legger til et navn (ingen duplikater, gir True hvis det ble lagt til og ellers False). finn(deltekst) gir lista med navn som inneholder deltekst (ikke skille på store og små bokstaver), og antall() gir antallet.

deltekst.lower() in navn.lower() for hvert navn.

Kvadrat arver fra Rektangel, men sidene kan bli ulike. Skriv om koden uten arv: Kvadrat har en side, og areal() og omkrets(). Sidene kan ikke bli ulike.

Gjør Kvadrat til en egen klasse med bare side.

Utfordringer

Handlekurv har en liste priser, og en rabattregel som er et eget objekt. IngenRabatt.rabatt(sum) gir \(0\), ProsentRabatt(p).rabatt(sum) gir sum * p / 100, og FastRabatt(belop).rabatt(sum) gir belop, men aldri mer enn summen. Handlekurv(regel) tar regelen inn, og totalt() gir summen minus rabatten. Regelen kan byttes mens programmet kjører.

Handlekurv.__init__(self, regel) setter self.regel = regel og self.priser = []. totalt() bruker self.regel.rabatt(sum(self.priser)).

Du skal lage et system for en skole med elever, lærere, rektor og klasser. Tegn et klassediagram og avgjør hvor du bruker arv og hvor du bruker komposisjon. Begrunn minst to valg med «er en» og «har en», og nevn ett sted der du valgte bort arv.

Et mulig svar: Person som superklasse for Elev, Laerer og Rektor (arv: alle er personer med navn og kontaktinformasjon). Klasse har elever (komposisjon eller aggregering, siden en klasse har elever, men er ikke en elev). Skole har klasser (komposisjon). Man kan velge bort arv for Rektor: er en rektor en lærer, eller har en rektor rollen rektor? Gir man Person en liste med roller (komposisjon), kan en person være både lærer og rektor uten at man trenger en ny klasse for hver kombinasjon. Begrunnelsen teller mer enn det endelige valget.

Oppsummering

Testen

  • Er en → arv
  • Har en → komposisjon

Komposisjon

class Bil:
    def __init__(self, motor):
        self.motor = motor

    def effekt(self):
        return self.motor.effekt()

Unngå arv når

  • subklassen ikke kan brukes overalt superklassen brukes
  • du bare vil gjenbruke kode
  • du arver fra list eller dict
  • Er du i tvil, velg komposisjon.
  • Hold arvehierarkier grunne.
  • Komposisjon lar deg bytte deler underveis.

7.5 Bruk det i prosjektene

7.6 Oppgaver

Disse oppgavene blander temaene fra hele kapittelet. Flere oppgaver finner du i notatboka (lenkene øverst i kapittelet).

Hvilket begrep fra kapittelet passer i hvert tilfelle?

Sparekonto har alle metodene til Konto uten at du skrev dem på nytt.
Arv. b) Overstyring. c) super().__init__(...). d) Polymorfi. e) Abstrakt klasse. f) Komposisjon.
Brukskonto har en egen versjon av ta_ut.
Konstruktøren i Elev bruker Persons konstruktør.
En løkke kaller form.areal() på ulike former.
Du kan ikke lage et objekt av Form.
En Bil har en Motor som kan byttes.

Skriv den abstrakte klassen Figur med navn og x, y (starter på \(0\)), abstrakt symbol() og vanlig flytt(dx, dy). Skriv Spiller (symbol @) og Fiende (symbol X, og flytt som overstyrer slik at fienden alltid beveger seg dobbelt så langt, men bruker super()).

Fiende.flytt(self, dx, dy) kaller super().flytt(2 * dx, 2 * dy).

Koden skal vise polymorfi med en abstrakt klasse, men har flere feil. Finn minst tre.

from abc import ABC, abstractmethod

class Dyr:
    def __init__(self, navn):
        self.navn = navn

    @abstractmethod
    def lyd(self):
        pass

class Hund(Dyr):
    def __init__(self, navn, rase):
        self.rase = rase

    def lyd(self):
        return "Voff"

for d in [Hund("Fido", "lab")]:
    if type(d) == Hund:
        print(d.lyd())

Se på superklassen, konstruktøren og løkka.

  1. Dyr arver ikke fra ABC, så @abstractmethod har ingen virkning, og klassen er ikke abstrakt. Skriv class Dyr(ABC):.
  2. Hund.__init__ kaller ikke super().__init__(navn), så navn blir aldri satt.
  3. Løkka sjekker typen med if type(d) == Hund. Polymorfi gjør dette unødvendig: kall bare d.lyd().

Velg arv eller komposisjon, og skriv koden, for hvert av tilfellene: a) Sjef og Ansatt, b) Kunde og Bestilling, c) Ordbok som bare skal ha legg_til(ord, betydning) og slå_opp(ord).

  1. Arv: class Sjef(Ansatt), siden en sjef er en ansatt og kan brukes overalt der en ansatt brukes. b) Komposisjon: en kunde har bestillinger (self.bestillinger = []), men er ikke en bestilling. c) Komposisjon: klassen har en privat dict og viser bare de to metodene, i stedet for å arve fra dict og gi alle dens metoder:
class Ordbok:
    def __init__(self):
        self._ord = {}

    def legg_til(self, ord_, betydning):
        self._ord[ord_] = betydning

    def slaa_opp(self, ord_):
        return self._ord.get(ord_)

Velg et system (et dyr i en dyrehage, et spill, en butikk). Tegn et klassediagram med minst én abstrakt klasse, to subklasser med arv og én komposisjon. Skriv klassene i Python med super(), overstyring og en polymorfisk løkke. Test med pytest.

Sjekk at hver arv består «er en»-testen, at abstrakte metoder er skrevet i alle subklasser, at subklassens konstruktør bruker super().__init__, at en løkke kaller en metode på objekter av ulike klasser uten å sjekke typen, og at komposisjonen er et privat attributt som peker på et annet objekt.

7.7 Oppsummering

Arv

Subklasse og overstyring

class Brukskonto(Konto):
    KREDITT = 5000

    def ta_ut(self, belop):
        ...

super()

def __init__(self, eier, rente):
    super().__init__(eier)
    self.rente = rente

Teste typen

isinstance(obj, Konto)
issubclass(Sparekonto, Konto)

Polymorfi og abstrakte klasser

Polymorfi

for form in former:
    print(form.areal())

Abstrakt klasse

from abc import ABC, abstractmethod

class Form(ABC):
    @abstractmethod
    def areal(self):
        ...

Arv eller komposisjon

Valg

  • Er en → arv
  • Har en → komposisjon
  • Tvil → komposisjon

Komposisjon

class Bil:
    def __init__(self, motor):
        self.motor = motor
  • Arv går nedover: subklassen arver alt, men superklassen kjenner ikke subklassen.
  • Kall super().__init__(...) først i subklassens konstruktør.
  • Ikke sjekk typen med if. La objektene svare selv.
  • Bruk ikke arv bare for å gjenbruke kode.