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"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
abcsom 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
isinstanceogissubclass.
Arv: en klasse som bygger videre på en annen
Vi starter med en vanlig konto, slik du lærte å skrive den i kapittel 6:
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.
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.
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.
Å 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.
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.
- Å 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
Nivå 2
Kodeoppgaver
Utfordringer
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.
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.
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.
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.
- Å 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
Nivå 2
Kodeoppgaver
Utfordringer
Oppsummering
Overstyre
class Brukskonto(Konto):
def ta_ut(self, belop):
... # ny versjonHvilken metode?
- Klassen til objektet
- Superklassen
- 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__(...).
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.
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.
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.
- Å glemme
super().__init__(...)i subklassens konstruktør. Du fårAttributeErrorsenere. - Å sende
selftilsuper().__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 ettersuper. - Å 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
Nivå 2
Kodeoppgaver
Utfordringer
Oppsummering
Konstruktør
class Elev(Person):
def __init__(self, navn, klasse):
super().__init__(navn)
self.klasse = klasseBygge 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, utenselfi 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 / 2Her 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.
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.
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.
- Å 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
AttributeErrormidt 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
Nivå 2
Kodeoppgaver
Utfordringer
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
ABCog@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 fraABC, som gjør den abstrakt.@abstractmethodover 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.
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
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().
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.
- Å glemme
ABCsom superklasse. Da virker@abstractmethodikke, 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 (
arealogAreal), 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
Nivå 2
Kodeoppgaver
Utfordringer
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 ** 2UML
<<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.
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().
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.
- Å bruke arv bare for å gjenbruke kode, uten at det er «er en».
- Å arve fra
listellerdictog 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
Nivå 2
Kodeoppgaver
Utfordringer
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
listellerdict
- 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).
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 = renteTeste 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.