Skip to main content

6  Klasser og objekter

I forrige kapittel tegnet du modeller av programmer. Nå skal du gjøre modellene til kode. Du har allerede brukt objekter hele tiden: en liste er et objekt med metoder som append og sort, og en tekst er et objekt med metoder som upper og split. Nå lærer du å lage dine egne typer objekter, med de attributtene og metodene du selv bestemmer.

Du lærer å skrive en klasse med class, __init__ og self, å legge til metoder, å skille mellom data som hører til hvert objekt og data som deles av alle, å beskytte dataene i en klasse (innkapsling og @property), å bestemme hvordan objekter skrives ut og sammenlignes, og å la objekter i lister og andre objekter samarbeide. Dette er kompetansemålet om å utvikle objektorienterte programmer med klasser, objekter og metoder. Arv, som er en del av samme kompetansemål, kommer i kapittel 7.

Du kan gjøre oppgavene i boka og i notatboka i nettleseren. De store oppgavene i 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

  • skrive en klasse med konstruktør, attributter og metoder, og lage objekter av den,
  • skille mellom objektattributter og klasseattributter,
  • beskytte dataene i en klasse med innkapsling og @property,
  • bestemme hvordan objekter skrives ut og sammenlignes med __str__, __repr__, __eq__ og __lt__,
  • bruke objekter i lister og ordbøker, og la objekter bruke hverandre.

6.1 Den første klassen

Her lager du din første klasse og dine første objekter.

6.1.1 class, init og self

I kapittel 5 lagde vi objekter som ordbøker: dune = {"tittel": "Dune", "varighet": 155}. Det virker, men det er skjørt. Skriver du "tittle" i stedet for "tittel", får du ingen advarsel før programmet krasjer. Ordboken kan heller ikke ha egne metoder, og ingenting sikrer at alle filmer har de samme feltene. En klasse løser alt dette: den er malen som sier at en film har tittel og varighet, og som lager objekter som alltid har de feltene.

Læringsmål

Etter dette delkapittelet skal du kunne

  • skrive en klasse med class og konstruktøren __init__,
  • forklare hva self er,
  • lage objekter av klassen og lese attributtene deres,
  • legge til en metode, og kalle den på et objekt.

Klassen og konstruktøren

Vi skriver klassen Film fra kinomodellen. Den har attributtene tittel og varighet:

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

dune = Film("Dune", 155)
mars = Film("Oppdrag Mars", 118)

print(dune.tittel)
print(mars.varighet)
Dune
118

Slik virker det:

  • class Film: starter klassen. Navnet skrives med stor forbokstav, i entall.
  • __init__ (to understreker på hver side) er konstruktøren. Python kjører den automatisk hver gang du lager et nytt objekt med Film(...). Her gir den attributtene sine startverdier.
  • self er objektet som lages. Når du skriver self.tittel = tittel, lagrer du verdien i dette objektet, under navnet tittel.
  • Film("Dune", 155) lager et nytt objekt. Verdiene "Dune" og 155 sendes til tittel og varighet. Du sender ikke noe til self, for Python gjør det selv.
RegelSlik lager du en klasse
class Navn:
    def __init__(self, parameter):
        self.attributt = parameter
  • Klassenavn har stor forbokstav.
  • Konstruktøren heter alltid __init__, og første parameter er alltid self.
  • Attributter lages ved å skrive self.navn = verdi.
  • Du lager et objekt med Navn(verdier), og leser attributtene med punktum: objekt.attributt.

Merk at self.tittel og tittel er to forskjellige ting. Den første er attributtet som hører til objektet og lever videre etter at konstruktøren er ferdig. Den andre er parameteren, som bare finnes mens __init__ kjører.

Lag klassen Hund med attributtene navn og rase. Lag to hunder, og skriv ut navnet til den ene.

Konstruktøren tar self, navn og rase, og lagrer dem i self.navn og self.rase.

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

fido = Hund("Fido", "labrador")
pluto = Hund("Pluto", "puddel")
print(fido.navn)
Fido

Metoder

En metode er en funksjon som hører til klassen. Den skrives inne i klassen, og første parameter er alltid self. Da kommer metoden til attributtene til objektet den kalles på.

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def vis_info(self):
        print(f"{self.tittel} ({self.varighet} min)")

    def er_lang(self):
        return self.varighet > 150

dune = Film("Dune", 155)
mars = Film("Oppdrag Mars", 118)

dune.vis_info()
mars.vis_info()
print(dune.er_lang())
print(mars.er_lang())
Dune (155 min)
Oppdrag Mars (118 min)
True
False

Du kaller en metode med punktum: dune.vis_info(). Da sender Python automatisk objektet dune inn som self. Det er derfor metoden har en parameter self, men du skriver ingenting i parentesen når du kaller den. Du kan se hva som skjer ved å kalle den på den lange måten, som gir samme resultat:

Film.vis_info(dune)
Dune (155 min)

Her gir vi self selv, og ser at dune.vis_info() bare er en kortere måte å skrive det på.

Legg til en metode er_kort i Film som gir True hvis filmen varer under \(100\) minutter.

Metoden tar bare self, og bruker self.varighet.

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def er_kort(self):
        return self.varighet < 100

print(Film("Pondus på tur", 94).er_kort())
print(Film("Dune", 155).er_kort())
True
False

Hvert objekt har sin egen tilstand

Alle objektene av en klasse har de samme attributtene og metodene, men hvert objekt har sine egne verdier. Endrer du ett, påvirkes ikke de andre:

a = Film("Dune", 155)
b = Film("Dune", 155)
c = a              # c er samme objekt som a

a.varighet = 160
print(a.varighet, b.varighet, c.varighet)
print(a is b, a is c)
160 155 160
False True

a og b ble laget hver for seg, så de er to ulike objekter selv om innholdet var likt. c = a lager ikke et nytt objekt, men gir objektet et nytt navn. Derfor endres c også når vi endrer a. Du ser mer på dette i 6.5.1.

Skriver du print(dune) uten å ha gjort noe mer, får du noe lite nyttig som

<__main__.Film object at 0x7f3a1c2b5d10>

Det er typen og adressen i minnet (adressen varierer). I 6.4.1 lærer du å bestemme selv hva som skrives ut.

Fra UML til kode

Klasseboksene fra kapittel 5 kan nesten oversettes ord for ord. Attributtene blir self.navn = ... i __init__, og metodene blir def-linjer inne i klassen:

UML Python
class Sal class Sal:
- nummer: int self.nummer = nummer i __init__
- antall_seter: int self.antall_seter = antall_seter
+ er_stor(): bool def er_stor(self):
class Sal:
    def __init__(self, nummer, antall_seter):
        self.nummer = nummer
        self.antall_seter = antall_seter

    def er_stor(self):
        return self.antall_seter >= 150

sal1 = Sal(1, 200)
print(sal1.er_stor())
True

Typene (int) og synligheten (-) skriver vi ikke i koden ennå. Synlighet kommer i 6.3.1, og typer kan du legge til som typehint (se 3.1.2).

NoteLes feilmeldingene

Du får snart feilmeldinger du ikke har sett før. Disse er vanlige:

  • TypeError: Film.vis_info() takes 0 positional arguments but 1 was given: du glemte self som første parameter i metoden.
  • AttributeError: 'Film' object has no attribute 'tittel': du glemte self. foran attributtet i konstruktøren, eller stavet navnet feil.
  • TypeError: Film.__init__() missing 1 required positional argument: 'varighet': du ga for få verdier da du lagde objektet.
  • TypeError: Film() takes no arguments: du har skrevet init i stedet for __init__ (mangler understrekene).
AdvarselVanlige feil
  • Å glemme self som første parameter i metoder og konstruktør.
  • Å skrive tittel = tittel i stedet for self.tittel = tittel. Da blir ikke verdien lagret i objektet.
  • Å skrive self.tittel når du mener parameteren, eller omvendt, inne i __init__.
  • Å glemme understrekene i __init__.
  • Å lese et attributt på klassen i stedet for på objektet (Film.tittel i stedet for dune.tittel).
  • Å glemme return i en metode som skal gi et svar, slik at du får None.
  • Å glemme parentesen når du kaller metoden (dune.vis_info).

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 Bil:
    def __init__(self, modell, dagspris):
        self.modell = modell
        self.dagspris = dagspris

    def beskriv(self):
        return f"{self.modell}: {self.dagspris} kr"

golf = Bil("Golf", 500)
tesla = Bil("Tesla", 900)
print(golf.beskriv())
print(tesla.dagspris)
Hva skrives ut?

golf.beskriv() sender golf inn som self.

Først Golf: 500 kr, så 900.

Hvor mange objekter lages, og hvor mange klasser finnes?

golf.beskriv() sender golf inn som self.

To objekter (golf og tesla) og én klasse (Bil).

Hva er self i kallet golf.beskriv()?

golf.beskriv() sender golf inn som self.

self er objektet golf. Derfor blir self.modell lik "Golf".

Koden under skal lage en klasse Sal, men har fire feil. Finn dem.

class Sal:
    def __init__(nummer, antall_seter):
        nummer = nummer
        self.antall_seter = antall_seter

    def er_stor():
        return self.antall_seter >= 150

Se på første parameter i begge metodene, og på linjen som lagrer nummeret.

  1. __init__ mangler self som første parameter.
  2. nummer = nummer lagrer ikke noe i objektet. Det skal stå self.nummer = nummer.
  3. er_stor mangler self som parameter.
  4. er_stor bruker self, som ikke finnes når parameteren mangler.

Riktig:

class Sal:
    def __init__(self, nummer, antall_seter):
        self.nummer = nummer
        self.antall_seter = antall_seter

    def er_stor(self):
        return self.antall_seter >= 150

I koden under: hvilke navn er klasser, og hvilke er objekter?

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

kari = Elev("Kari")
ola = Elev("Ola")

Elev er klassen. kari og ola er objekter av klassen Elev.

Nivå 2
class Teller:
    def __init__(self):
        self.verdi = 0

    def tell(self):
        self.verdi += 1

a = Teller()
b = Teller()
a.tell()
a.tell()
b.tell()
print(a.verdi, b.verdi)

Hvert objekt har sin egen verdi.

2 1. Objektene a og b har hver sin verdi. a ble telt opp to ganger og b én gang.

Skriv klassen Elev med attributtene navn og klasse, og metoden hils som skriver ut Hei, jeg er <navn> fra <klasse>. Lag en elev og kall metoden. Kjør koden i VS Code eller i cellen under.

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

    def hils(self):
        print(f"Hei, jeg er {self.navn} fra {self.klasse}")

kari = Elev("Kari", "2IT")
kari.hils()
Kodeoppgaver

Disse oppgavene rettes automatisk. Rettingen lager objekter av klassen din og sjekker attributtene og metodene.

Skriv klassen Hund med konstruktør som tar navn og rase og lagrer dem som attributter.

def __init__(self, navn, rase): og så self.navn = navn og self.rase = rase.

Skriv klassen Sal med nummer og antall_seter, og metoden er_stor() som gir True hvis salen har minst \(150\) seter.

Metoden tar self og gir self.antall_seter >= 150.

Skriv klassen Rektangel med bredde og hoyde, og metodene areal() og omkrets().

Begge metodene tar bare self og bruker self.bredde og self.hoyde.

Klassen skal gi riktig svar for Person("Per", 17).er_voksen(), men krasjer. Rett koden.

Hva skjer med alder etter at konstruktøren er ferdig? Hvor ble den lagret?

Skriv klassen Film med tittel og varighet, og metoden vis_info() som skriver ut Dune (155 min) for en film med tittel Dune og varighet \(155\) (bruk print).

print(f"{self.tittel} ({self.varighet} min)")

Utfordringer

Skriv klassen Punkt med x og y, og metoden avstand_til(annet) som gir avstanden til et annet Punkt (Pytagoras). Bruk math.sqrt eller ** 0.5.

Metoden får et annet objekt som parameter. Bruk annet.x og annet.y, og regn ut \(\sqrt{(x_1-x_2)^2 + (y_1-y_2)^2}\).

Gi tre fordeler med å bruke en klasse i stedet for en ordbok til å lagre en film.

Klassen sikrer at alle filmer har de samme attributtene (konstruktøren krever dem), og en skrivefeil i attributtnavnet gir en feilmelding med en gang. Metodene hører sammen med dataene, så koden som bruker en film, finner alt på ett sted. Du kan også kontrollere verdiene (for eksempel nekte negativ varighet), og senere endre hvordan dataene lagres uten at resten av programmet må endres.

Oppsummering

En klasse

class Film:
    def __init__(self, tittel):
        self.tittel = tittel

    def vis(self):
        print(self.tittel)

Lage og bruke objekter

dune = Film("Dune")
print(dune.tittel)
dune.vis()

Delene

  • __init__: kjører ved opprettelse
  • self: objektet selv
  • self.x: attributt i objektet
  • self er alltid første parameter, men du sender den ikke selv.
  • self.tittel = tittel lagrer. tittel = tittel gjør ikke det.
  • Hvert objekt har sine egne verdier.

6.2 Attributter og metoder

En klasse er mer enn en pakke med verdier. Her ser du hvordan metoder endrer og bruker tilstanden til et objekt, og hvordan du kan dele data mellom alle objektene i en klasse.

6.2.1 Objektattributter og metoder

En billettluke har en tilstand som endrer seg: først er alle setene ledige, så blir ett og ett solgt. Objekter er gode til akkurat dette. Dataene (hvilke seter som er solgt) og reglene for å endre dem (kan du selge et sete som er tatt?) hører sammen i samme klasse. Metodene er det som flytter objektet fra én tilstand til en annen.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage metoder som endrer attributtene til objektet og metoder som gir svar,
  • la en metode bruke en annen med self,
  • bruke standardverdier og lister i konstruktøren på en trygg måte,
  • forklare hvorfor en liste aldri skal være standardverdi for en parameter.

Metoder som endrer objektet

En metode kan endre attributtene til objektet ved å skrive til self. Endringen varer etter at metoden er ferdig, siden attributtet hører til objektet og ikke til metoden.

class Teller:
    def __init__(self):
        self.verdi = 0

    def tell(self):
        self.verdi += 1

    def nullstill(self):
        self.verdi = 0

t = Teller()
t.tell()
t.tell()
print(t.verdi)
t.nullstill()
print(t.verdi)
2
0

Nesten alle metoder gjør én av to ting: de endrer objektet (tell, nullstill), eller de gir et svar om det (er_stor, antall_ledige). Prøv å holde dem adskilt. En metode som både endrer og skriver ut, er vanskeligere å bruke på nytt og å teste. La heller metoden gi verdien tilbake med return, og la den som kaller metoden bestemme om den skal skrives ut.

Lag klassen Spiller med navn og poeng (starter på \(0\)), og metoden gi_poeng(antall) som øker poengene. Lag en spiller, gi \(10\) og \(5\) poeng, og skriv ut poengene.

self.poeng += antall.

class Spiller:
    def __init__(self, navn):
        self.navn = navn
        self.poeng = 0

    def gi_poeng(self, antall):
        self.poeng += antall

p = Spiller("Mia")
p.gi_poeng(10)
p.gi_poeng(5)
print(p.poeng)
15

poeng får startverdien \(0\) i konstruktøren, og trenger ikke være en parameter.

Lister i objekter

Et objekt kan huske en hel samling, som en liste. Her har forestillingen en liste med solgte seter. Listen lages tom i konstruktøren, og metodene legger til og leser fra den. Merk at selg bruker en annen metode, er_ledig, ved å skrive self.er_ledig(...).

class Forestilling:
    def __init__(self, tidspunkt, antall_seter):
        self.tidspunkt = tidspunkt
        self.antall_seter = antall_seter
        self.solgte = []

    def er_ledig(self, sete):
        return 1 <= sete <= self.antall_seter and sete not in self.solgte

    def selg(self, sete):
        if not self.er_ledig(sete):
            return False
        self.solgte.append(sete)
        return True

    def antall_ledige(self):
        return self.antall_seter - len(self.solgte)

f = Forestilling("19:00", 3)
print(f.selg(2))
print(f.selg(2))
print(f.selg(5))
print(f.antall_ledige())
True
False
False
2

Første salg går bra, men sete \(2\) er tatt allerede ved andre forsøk, og sete \(5\) finnes ikke i en sal med tre seter. antall_ledige regnes ut hver gang fra de andre attributtene, så det er ingen ekstra verdi som kan komme ut av takt (se 5.5.1).

RegelBruk self
  • Attributter og metoder i objektet nås alltid med self.: self.solgte, self.er_ledig(sete).
  • Uten self. er det en vanlig variabel eller funksjon, og Python finner den ikke i objektet.
  • Attributter lages i __init__, slik at alle objekter har dem fra første stund.

Standardverdier og trygge lister

Konstruktøren kan ha parametere med standardverdi, akkurat som vanlige funksjoner (se 3.1.1):

class Bil:
    def __init__(self, modell, dagspris=500):
        self.modell = modell
        self.dagspris = dagspris
        self.utleid = False

golf = Bil("Golf")
tesla = Bil("Tesla", 900)
print(golf.dagspris, tesla.dagspris)
500 900

Men vær forsiktig med lister. En liste som standardverdi lages én gang, når funksjonen defineres, og deles mellom alle objektene:

class Handlekurv:
    def __init__(self, varer=[]):     # Ikke gjør dette!
        self.varer = varer

    def legg_til(self, vare):
        self.varer.append(vare)

k1 = Handlekurv()
k2 = Handlekurv()
k1.legg_til("melk")
print(k2.varer)
['melk']

Kurven til k2 inneholder melk, selv om vi bare la til noe i k1. Begge objektene bruker den samme lista. Løsningen er å lage en ny liste for hvert objekt, inne i konstruktøren:

class Handlekurv:
    def __init__(self):
        self.varer = []               # Ny liste for hvert objekt

    def legg_til(self, vare):
        self.varer.append(vare)

k1 = Handlekurv()
k2 = Handlekurv()
k1.legg_til("melk")
print(k1.varer, k2.varer)
['melk'] []

Vil du la brukeren sende inn en liste, bruker du None som standardverdi og lager listen i konstruktøren: def __init__(self, varer=None): self.varer = varer if varer is not None else []. Det samme gjelder ordbøker og mengder.

class Lager:
    def __init__(self):
        self.varer = {}

    def legg_til(self, vare, antall):
        self.varer[vare] = self.varer.get(vare, 0) + antall

    def antall_av(self, vare):
        return self.varer.get(vare, 0)

lager = Lager()
lager.legg_til("kaffe", 5)
lager.legg_til("kaffe", 3)
lager.legg_til("te", 2)
print(lager.antall_av("kaffe"))
print(lager.antall_av("sukker"))

Hva gir get når nøkkelen ikke finnes?

Først 8 (5 pluss 3), så 0 (sukker finnes ikke, og get gir da \(0\)). Her er attributtet en ordbok som lages i konstruktøren, og metodene endrer og leser den.

AdvarselVanlige feil
  • Å kalle en annen metode uten self.: er_ledig(sete) i stedet for self.er_ledig(sete). Du får NameError.
  • Å bruke en liste (eller ordbok) som standardverdi i __init__. Alle objektene deler den.
  • Å glemme self. foran attributtet når du endrer det: verdi += 1 i stedet for self.verdi += 1.
  • Å glemme return i en metode som skal gi svar.
  • Å legge nye attributter til utenfor __init__. Da har ikke alle objekter dem, og du får AttributeError.
  • Å la én metode både endre, skrive ut og gi svar.

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 Konto:
    def __init__(self):
        self.saldo = 0

    def sett_inn(self, belop):
        self.saldo += belop

    def hent_saldo(self):
        return self.saldo

k = Konto()
k.sett_inn(100)
k.sett_inn(50)
print(k.hent_saldo())
print(k.saldo)

Hvor lagres saldo?

150 to ganger. sett_inn endrer saldo i objektet, så verdien er \(100 + 50 = 150\). hent_saldo() og k.saldo gir samme verdi.

For hver metode: endrer den objektet, eller gir den et svar?

selg(sete) i Forestilling (legger setet til solgte)
Endrer objektet (og gir gjerne True eller False om det gikk bra). b) Gir et svar. c) Endrer objektet. d) Gir et svar.
antall_ledige()
nullstill() i Teller
er_stor() i Sal
Nivå 2
class Elev:
    def __init__(self, navn, karakterer=[]):
        self.navn = navn
        self.karakterer = karakterer

kari = Elev("Kari")
ola = Elev("Ola")
kari.karakterer.append(5)
print(ola.karakterer)
Hva skrives ut, og hvorfor er det feil?

Hvor mange lister lages?

[5]. Standardverdien [] lages én gang, og både kari og ola bruker den samme lista. Olas karakterer skulle vært tomme.

Hvordan rettes det?

Hvor mange lister lages?

Lag lista inne i konstruktøren:

class Elev:
    def __init__(self, navn):
        self.navn = navn
        self.karakterer = []
class Elev:
    def __init__(self, navn):
        self.navn = navn
        self.karakterer = []
class Forestilling:
    def __init__(self, antall_seter):
        self.antall_seter = antall_seter
        self.solgte = []

    def er_ledig(self, sete):
        return sete not in self.solgte

    def selg(self, sete):
        if er_ledig(sete):
            solgte.append(sete)

Koden har to feil. Finn dem.

Se på hvordan metoden og attributtet brukes inne i selg.

er_ledig(sete) mangler self. foran (self.er_ledig(sete)), og solgte.append(sete) mangler self. (self.solgte.append(sete)). Uten self. leter Python etter en vanlig funksjon og variabel, og gir NameError.

Kodeoppgaver

Skriv klassen Teller med attributtet verdi (starter på \(0\)) og metodene tell() (øker med \(1\)) og nullstill() (setter til \(0\)).

tell gjør self.verdi += 1, og nullstill gjør self.verdi = 0.

Skriv klassen Forestilling med antall_seter og en tom liste solgte. Lag metodene er_ledig(sete) (sete må være fra \(1\) til antall_seter og ikke solgt), selg(sete) (selger hvis ledig, og gir True eller False) og antall_ledige().

Lag self.solgte = [] i konstruktøren. La selg bruke self.er_ledig(sete), og legg setet til med append.

Skriv klassen Handlekurv med en tom liste varer. Metoden legg_til(navn, pris) legger til en vare som tuppelen (navn, pris). totalpris() gir summen av prisene, og antall() gir antall varer.

self.varer.append((navn, pris)), og totalpris summerer pris for hver (navn, pris).

Hver Elev skal ha sin egen liste med karakterer, men Elev("Ola").karakterer er ikke tom etter at Kari har fått en karakter. Rett koden.

Bruk None som standardverdi, og lag en ny liste i konstruktøren hvis det ikke er sendt inn noen.

Skriv klassen Lager med en tom ordbok varer. legg_til(vare, antall) øker beholdningen. ta_ut(vare, antall) minker den og gir True, men hvis det ikke er nok på lager, endres ingenting og den gir False. antall_av(vare) gir beholdningen (\(0\) for ukjente varer).

self.varer.get(vare, 0) gir beholdningen, også for varer som ikke finnes.

Utfordringer

Skriv klassen Runder som husker rundetider. ny_runde(tid) legger til en tid (i sekunder). beste() gir den raskeste tiden (eller None hvis det ikke er noen), og snitt() gir gjennomsnittet (eller None). antall() gir antall runder.

Lagre tidene i en liste. Bruk min(self.tider) og sum(self.tider) / len(self.tider), men sjekk først at lista ikke er tom.

Forklar med egne ord hvorfor to objekter deler lista når den er standardverdi i __init__, men ikke når den lages inni konstruktøren.

Standardverdien til en parameter lages én gang, når def-linjen kjøres (altså når klassen defineres), og den samme lista brukes hver gang parameteren ikke oppgis. Alle objektene peker dermed på samme liste. Lager du lista inne i konstruktøren (self.varer = []), kjøres linjen på nytt for hvert nytt objekt, og hvert objekt får sin egen liste.

Oppsummering

Endre og svare

def tell(self):
    self.verdi += 1

def er_stor(self):
    return self.verdi > 10

Metoder bruker hverandre

def selg(self, sete):
    if not self.er_ledig(sete):
        return False

Samlinger i objekter

def __init__(self):
    self.varer = []   # ny liste hver gang
  • Bruk alltid self. foran attributter og metoder i objektet.
  • Lag lister og ordbøker i __init__, aldri som standardverdi.
  • La metoder enten endre objektet eller gi svar.

6.2.2 Klasseattributter

Alle billetter på kinoen koster det samme for voksne. Skal hver billett huske prisen sin, eller finnes prisen ett sted, som alle billettene deler? Noen opplysninger hører til hvert objekt (setet på billetten), og andre hører til klassen som helhet (billettprisen, eller hvor mange billetter som er laget). Det siste kalles klasseattributter.

Læringsmål

Etter dette delkapittelet skal du kunne

  • skille mellom objektattributter og klasseattributter,
  • bruke klasseattributter til konstanter og tellere,
  • forklare hva som skjer når du skriver til et klasseattributt gjennom self,
  • lage en klassemetode som lager objekter fra tekst.

Klasseattributter

Et klasseattributt skrives direkte i klassen, utenfor metodene. Det finnes bare én gang, og deles av alle objekter av klassen.

class Billett:
    PRIS_VOKSEN = 130          # felles for alle billetter
    antall_laget = 0           # teller, felles

    def __init__(self, sete):
        self.sete = sete       # hører til hver billett
        Billett.antall_laget += 1

b1 = Billett(12)
b2 = Billett(13)
print(Billett.PRIS_VOKSEN)
print(b1.PRIS_VOKSEN)
print(Billett.antall_laget)
130
130
2

Du kan lese et klasseattributt både gjennom klassen (Billett.PRIS_VOKSEN) og gjennom et objekt (b1.PRIS_VOKSEN). Skal du endre det, må du gå gjennom klassen (Billett.antall_laget += 1).

RegelObjektattributt eller klasseattributt?
  • Objektattributt (self.sete = sete i __init__): hvert objekt har sin egen verdi.
  • Klasseattributt (PRIS_VOKSEN = 130 i klassen): én verdi som deles av alle.

Spør: kan to objekter ha ulik verdi her? Ja: objektattributt. Nei, den er felles: klasseattributt.

Navn på konstanter, verdier som aldri endres, skrives med store bokstaver (PRIS_VOKSEN). Det er en avtale mellom programmerere, ikke en regel Python håndhever. Konstanter gjør koden lettere å lese og å endre: endrer prisen seg, rettes den på ett sted.

En butikk har klassen Vare med navn og pris (uten moms). Momsen er \(25\) %, og den er lik for alle varer. Lag et klasseattributt og metoden pris_med_moms().

MOMS = 0.25 i klassen, og i metoden bruker du self.MOMS eller Vare.MOMS.

class Vare:
    MOMS = 0.25

    def __init__(self, navn, pris):
        self.navn = navn
        self.pris = pris

    def pris_med_moms(self):
        return self.pris * (1 + self.MOMS)

print(Vare("Kaffe", 80).pris_med_moms())
100.0

Endres momsen, retter vi MOMS på ett sted, og alle varene får den nye satsen.

Telle objekter

Klasseattributter brukes ofte til å telle eller gi nummer til objekter. Her får hver sykkel et unikt serienummer:

class Sykkel:
    antall = 0

    def __init__(self, eier):
        Sykkel.antall += 1
        self.serienummer = Sykkel.antall
        self.eier = eier

a = Sykkel("Mia")
b = Sykkel("Jon")
print(a.serienummer, b.serienummer, Sykkel.antall)
1 2 2

Sykkel.antall økes hver gang et objekt lages, og den nye verdien blir serienummeret til objektet. Serienummeret hører til hver sykkel (objektattributt), mens telleren er felles (klasseattributt).

AdvarselSkriver du gjennom self, lager du et nytt attributt

Skriver du self.antall += 1 i stedet for Sykkel.antall += 1, endrer du ikke klasseattributtet. Du lager et nytt objektattributt med samme navn som skygger for det i klassen. Slik ser det ut:

class Feil:
    antall = 0

    def __init__(self):
        self.antall += 1       # lager objektattributt!

x = Feil()
y = Feil()
print(x.antall, y.antall, Feil.antall)
1 1 0

Hvert objekt har fått sin egen antall, og klassens teller er uendret. Skal du endre noe som deles, skriv klassenavnet foran.

Klassemetoder: lage objekter på en annen måte

En klassemetode hører til klassen og ikke til et enkelt objekt. Den skrives med @classmethod og får klassen (cls) som første parameter i stedet for self. Den brukes ofte til å lage objekter av data i en annen form, for eksempel tekst fra en fil:

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    @classmethod
    def fra_tekst(cls, tekst):
        tittel, varighet = tekst.split(";")
        return cls(tittel, int(varighet))

dune = Film.fra_tekst("Dune;155")
print(dune.tittel, dune.varighet)
Dune 155

Vi kaller den på klassen: Film.fra_tekst(...). cls(tittel, ...) lager et nytt objekt, akkurat som Film(...). Slik kan klassen ha flere måter å lage objekter på. Dette kommer til nytte når du leser data fra filer (kapittel 8).

AdvarselVanlige feil
  • Å bruke klasseattributt for noe som er ulikt fra objekt til objekt (som setenummer).
  • Å skrive self.antall += 1 i stedet for Klasse.antall += 1, så telleren aldri endres.
  • Å bruke en liste som klasseattributt til noe hvert objekt skal ha for seg selv. Alle objektene deler den.
  • Å glemme @classmethod over klassemetoden, eller cls som første parameter.
  • Å bruke små bokstaver på konstanter. Det virker, men bryter avtalen.

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

For hvert attributt i en klasse Elev: skal det være objektattributt eller klasseattributt?

navn

Kan to objekter ha ulik verdi?

Objektattributt. b) Klasseattributt (felles og aldri endret). c) Objektattributt. d) Klasseattributt (en felles teller).
SKOLENAVN (alle elevene går på samme skole)

Kan to objekter ha ulik verdi?

karakterer

Kan to objekter ha ulik verdi?

antall_elever (hvor mange elever som er laget)

Kan to objekter ha ulik verdi?

class Terning:
    antall = 0

    def __init__(self):
        Terning.antall += 1

a = Terning()
b = Terning()
c = Terning()
print(Terning.antall)
print(a.antall)

3 og 3. Klasseattributtet er felles, så alle tre objektene økte den samme telleren, og vi kan lese den både gjennom klassen og gjennom et objekt.

Nivå 2
class Bil:
    antall = 0

    def __init__(self):
        self.antall += 1

a = Bil()
b = Bil()
print(Bil.antall)
Hva skrives ut?

Hva lager self.antall += 1?

0.

Hva har skjedd med a.antall?

Hva lager self.antall += 1?

self.antall += 1 leser klasseattributtet (\(0\)), legger til \(1\) og lagrer resultatet som et nytt objektattributt antall i objektet. a.antall og b.antall er \(1\), mens klassens antall aldri endres.

Hvordan rettes det?

Hva lager self.antall += 1?

Skriv Bil.antall += 1.

Du lager klassen Billett og skriver prisen \(130\) rett inn i fem ulike metoder. Hva er problemet, og hva bør du gjøre?

Skal prisen endres, må du finne og rette alle fem stedene, og glemmer du ett, gir programmet feil svar. Lag i stedet en konstant PRIS_VOKSEN = 130 i klassen og bruk den i metodene. Da endres prisen på ett sted.

Kodeoppgaver

Skriv klassen Billett med klasseattributtene PRIS_VOKSEN = 130 og PRIS_BARN = 90. Konstruktøren tar sete og alder. Metoden pris() gir barnprisen hvis alderen er under \(12\), og ellers voksenprisen.

Skriv konstantene rett i klassen, utenfor metodene. I pris sjekker du self.alder < 12.

Skriv klassen Elev med navn. Klasseattributtet antall teller hvor mange elever som er laget, og hver elev får et nummer (nummer) fra \(1\) og oppover i rekkefølgen de lages.

Start med antall = 0 i klassen. I __init__: Elev.antall += 1 og så self.nummer = Elev.antall.

Telleren i klassen øker aldri. Rett koden.

Hvilket navn må stå foran .antall for at klassens verdi skal endres?

Skriv klassen Film med tittel og varighet (heltall). Legg til klassemetoden fra_tekst(tekst) som lager en film fra tekst på formen "Dune;155".

@classmethod, def fra_tekst(cls, tekst):. Del teksten med split(";"), og gjør varigheten om med int(...). Gi tilbake cls(tittel, varighet).

Utfordringer

Skriv klassen Kampanje med klasseattributtet rabatt = 0.0. Konstruktøren tar pris. Metoden salgspris() gir prisen med rabatt (pris * (1 - rabatt)). Klassemetoden sett_rabatt(r) setter klasseattributtet slik at alle kampanjer (også de som allerede er laget) får ny rabatt.

I klassemetoden skriver du cls.rabatt = r. Metoden salgspris leser self.rabatt, som finner klasseattributtet så lenge objektet ikke har sitt eget.

Hva er et «magisk tall» i kode, og hvordan unngår du dem med det du har lært her?

Et magisk tall er et tall som står rett i koden uten forklaring, for eksempel * 1.25 eller >= 150. Leseren vet ikke hva det betyr, og må rettes mange steder hvis verdien endres. Du unngår dem ved å gi tallet et navn som konstant, for eksempel MOMS = 0.25 eller STOR_SAL = 150, i klassen. Da er koden selvforklarende, og verdien kan endres på ett sted.

Oppsummering

Klasseattributt

class Billett:
    PRIS = 130
    antall = 0

    def __init__(self):
        Billett.antall += 1

Klassemetode

@classmethod
def fra_tekst(cls, tekst):
    ...
    return cls(a, b)

Hvilken type?

  • Ulikt per objekt: self.x
  • Felles for alle: Klasse.x
  • Endre klasseattributter gjennom klassen, ikke self.
  • Konstanter skrives med STORE bokstaver.
  • Lister som klasseattributter deles av alle objektene.

6.3 Innkapsling og egenskaper

En klasse er et løfte: «hvis du bruker meg riktig, er jeg alltid i en gyldig tilstand». Her ser du hvordan du holder det løftet.

6.3.1 Innkapsling

Tenk deg en minibank. Du kan sette inn og ta ut penger, men du kan ikke åpne kassen og rote i pengebuntene. Banken har sørget for at du bare kommer til pengene gjennom noen få, kontrollerte handlinger. Det kalles innkapsling: dataene ligger inni objektet, og utenfra kommer du bare til dem gjennom metodene. Da kan klassen passe på at reglene alltid holdes.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare hva innkapsling er og hvorfor den er nyttig,
  • markere et attributt som privat med understrek,
  • lage metoder som kontrollerer endringer og utløser ValueError ved ugyldige verdier,
  • gjøre klassen trygg slik at den ikke kan havne i en ugyldig tilstand.

Når dataene ligger åpent

Her er en konto uten beskyttelse:

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

k = Konto("Hege")
k.saldo = 1000000
k.saldo = -500
print(k.saldo)
-500

Hvem som helst kan sette saldoen til hva de vil, også til nonsens som negative beløp. Reglene for hva som er lov, står ingen steder, og de kan brytes fra hvor som helst i programmet. Finner vi senere en saldo som er feil, må vi lete gjennom hele koden.

Privat med understrek

I Python finnes det ikke noe som hindrer andre i å lese et attributt. I stedet har programmerere en avtale: et navn som starter med understrek (_saldo) er privat, og skal bare brukes av klassen selv. Dette tilsvarer - i UML-diagrammet.

class Konto:
    def __init__(self, eier):
        self.eier = eier
        self._saldo = 0          # privat, rør ikke utenfra

    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 på kontoen")
        self._saldo -= belop

    def hent_saldo(self):
        return self._saldo

k = Konto("Hege")
k.sett_inn(1000)
k.ta_ut(300)
print(k.hent_saldo())

try:
    k.ta_ut(5000)
except ValueError as feil:
    print("Feil:", feil)
700
Feil: Ikke nok penger på kontoen

Nå er det bare metodene sett_inn og ta_ut som endrer saldoen, og begge sjekker at endringen er lov. Utenfra bruker vi hent_saldo() til å lese verdien. Saldoen kan aldri bli negativ, så lenge alle holder avtalen. Vi bruker raise ValueError(...) fra 4.2.2 til å avvise ugyldige verdier med en tydelig melding.

RegelInnkapsling
  • Attributter er private (understrek): self._saldo.
  • Metoder som andre skal bruke, er offentlige (uten understrek).
  • Endringer går gjennom metoder som kontrollerer at verdien er gyldig.
  • Ugyldige verdier avvises med raise ValueError(...).

Mål: objektet kan aldri havne i en ugyldig tilstand.

Understreken er en avtale, og Python stopper deg ikke hvis du likevel skriver k._saldo = -5. Men da bryter du avtalen, og får skylden når noe går galt. Du kan gjøre det vanskeligere å komme til attributtet ved å bruke to understreker (__saldo). Python endrer da navnet bak kulissene til _Konto__saldo, så k.__saldo gir AttributeError. Men heller ikke det er en ekte lås, så den vanlige avtalen med én understrek er nok i dette kurset.

Lag klassen Termostat som husker en måltemperatur mellom \(5\) og \(30\) grader. Konstruktøren setter den til \(20\). Metoden sett_temp(grader) endrer den, men utløser ValueError hvis verdien er utenfor området. hent_temp() gir verdien.

Lagre verdien i self._temp, og sjekk 5 <= grader <= 30 før du endrer.

class Termostat:
    def __init__(self):
        self._temp = 20

    def sett_temp(self, grader):
        if not 5 <= grader <= 30:
            raise ValueError("Temperaturen må være mellom 5 og 30")
        self._temp = grader

    def hent_temp(self):
        return self._temp

t = Termostat()
t.sett_temp(22)
print(t.hent_temp())
try:
    t.sett_temp(50)
except ValueError as feil:
    print(feil)
print(t.hent_temp())
22
Temperaturen må være mellom 5 og 30
22

Etter det mislykkede forsøket har termostaten fortsatt den gamle verdien, siden vi sjekker før vi endrer.

Trygg fra første stund

Beskyttelsen hjelper ikke hvis konstruktøren lar deg lage et ugyldig objekt. Lager du Konto("Hege", -500), må det avvises med en gang. Sjekk derfor verdiene i konstruktøren også, gjerne ved å bruke samme metode som ellers:

class Sal:
    def __init__(self, nummer, antall_seter):
        if antall_seter <= 0:
            raise ValueError("En sal må ha minst ett sete")
        self._nummer = nummer
        self._antall_seter = antall_seter

    def hent_antall_seter(self):
        return self._antall_seter

try:
    Sal(1, 0)
except ValueError as feil:
    print(feil)
En sal må ha minst ett sete

Objektet blir ikke laget når konstruktøren utløser et unntak, så det finnes aldri en Sal med null seter.

NoteHvorfor ikke bare stole på de andre?

Du skriver kanskje alle klassene selv, men om en måned har du glemt reglene, og i et prosjekt er det flere som skriver kode. Innkapsling flytter reglene til ett sted: klassen. Er det feil, vet du hvor du skal lete, og du kan endre hvordan klassen lagrer dataene uten at resten av programmet må endres.

AdvarselVanlige feil
  • Å la attributter være åpne og håpe at alle bruker dem riktig.
  • Å sjekke verdien i metoden, men glemme å sjekke i konstruktøren.
  • Å endre verdien før sjekken, så en ugyldig verdi allerede er lagret når unntaket kommer.
  • Å bruke print i stedet for raise når verdien er ugyldig. Da fortsetter programmet som om ingenting har skjedd.
  • Å skrive self.saldo noen steder og self._saldo andre steder.
  • Å gjøre alt privat, også metodene andre må bruke.

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 innkapsling er, og gi en grunn til at vi bruker det.

Innkapsling betyr at dataene ligger inni objektet (private attributter), og at andre bare kommer til dem gjennom metodene. Da kan klassen kontrollere at verdiene alltid er gyldige, for eksempel at en saldo ikke blir negativ, og vi vet at reglene bare trenger å stå ett sted.

class Teller:
    def __init__(self):
        self._verdi = 0

    def tell(self):
        self._verdi += 1

    def hent(self):
        return self._verdi

t = Teller()
t.tell()
t.tell()
print(t.hent())

Hva betyr understreken foran _verdi?

Det skrives ut 2. Understreken betyr at attributtet er privat, og at utenforstående ikke skal bruke det direkte. De skal bruke tell() og hent().

Nivå 2
class Konto:
    def __init__(self, saldo):
        self._saldo = saldo

    def ta_ut(self, belop):
        if belop > self._saldo:
            raise ValueError("Ikke nok penger")
        self._saldo -= belop

Det finnes to måter å få en negativ saldo på. Hvilke?

Hva skjer hvis du lager kontoen med et negativt beløp? Og hvis du tar ut et negativt beløp?

  1. Konto(-100): konstruktøren sjekker ikke startsaldoen.
  2. ta_ut(-50): et negativt beløp er ikke større enn saldoen, så sjekken slipper det gjennom, og self._saldo -= -50 øker saldoen. (Og ta_ut(10) på en konto med negativ saldo gir enda lavere saldo.) Metoden bør kreve at beløpet er positivt, og konstruktøren at saldoen ikke er negativ.

Hva er galt med denne metoden, og hvorfor er rekkefølgen viktig?

def sett_temp(self, grader):
    self._temp = grader
    if not 5 <= grader <= 30:
        raise ValueError("Ugyldig temperatur")

Verdien lagres før den sjekkes. Når unntaket kommer, er den ugyldige verdien allerede lagret, og hvis den som kalte metoden fanger unntaket og fortsetter, har objektet en ugyldig tilstand. Sjekken må komme først, og lagringen etterpå.

Kodeoppgaver

Skriv klassen Konto med privat _saldo (starter på \(0\)). sett_inn(belop) og ta_ut(belop) utløser ValueError hvis beløpet ikke er positivt, og ta_ut også hvis det ikke er nok penger. hent_saldo() gir saldoen.

Sjekk først, og endre self._saldo til slutt. ta_ut har to sjekker: positivt beløp og nok penger.

Skriv klassen Termostat med privat _temp (starter på \(20\)). sett_temp(grader) utløser ValueError("Temperaturen må være mellom 5 og 30") for verdier utenfor området \(5\) til \(30\) (grensene er gyldige). hent_temp() gir verdien.

if not 5 <= grader <= 30: raise ValueError(...) før du lagrer.

Skriv klassen Sal der konstruktøren tar nummer og antall_seter. Er antall_seter mindre enn \(1\), utløses ValueError("En sal må ha minst ett sete"), og objektet blir ikke laget. Lag metodene hent_nummer() og hent_antall_seter().

Sjekk antall_seter øverst i __init__, før du lagrer noe.

Metoden lagrer verdien før den sjekker den. Rett rekkefølgen, slik at en ugyldig verdi aldri lagres.

Flytt sjekken opp over self._poeng = p.

Skriv klassen Bruker med navn (offentlig) og et privat passord. sett_passord(nytt) utløser ValueError("For kort") hvis passordet har under \(8\) tegn. Konstruktøren tar navn og passord, og bruker sett_passord, slik at et for kort passord avvises med en gang. sjekk_passord(forsok) gir True hvis forsøket er lik passordet.

I __init__: self.navn = navn og self.sett_passord(passord). Passordet lagres i self._passord.

Utfordringer

Skriv klassen Beholder med kapasitet (tall, må være positiv, ellers ValueError) og innhold (starter på \(0\)). fyll(mengde) legger til, men utløser ValueError hvis mengden er negativ eller beholderen ville blitt overfylt (og endrer da ingenting). tapp(mengde) fjerner, men utløser ValueError hvis mengden er negativ eller det er mindre enn dette i beholderen. innhold() gir innholdet, og ledig_plass() gir hvor mye det er plass til.

Sjekk alle betingelser før du endrer self._innhold.

Ta en av klassene du har skrevet i dette delkapittelet, og prøv å få den inn i en ugyldig tilstand uten å bryte avtalen om understrek. Klarer du det? Hva sier det om klassen?

Hvis klassen er skrevet riktig, finnes ingen vei inn i en ugyldig tilstand uten å bruke private attributter direkte: alle metoder og konstruktøren avviser ugyldige verdier. Klarer du å ødelegge den med vanlige metoder, har klassen et hull (for eksempel manglende sjekk av negative beløp), og du bør rette det. Å skrive k._saldo = -5 bryter avtalen, og kan ikke stoppes av Python.

Oppsummering

Privat attributt

self._saldo = 0

Understrek = rør ikke utenfra.

Kontrollert endring

def ta_ut(self, belop):
    if belop > self._saldo:
        raise ValueError("...")
    self._saldo -= belop

Trygg konstruktør

Sjekk verdiene også i __init__.

  • Sjekk først, endre etterpå.
  • Bruk raise, ikke print, for ugyldige verdier.
  • - i UML er understrek i koden.

6.3.2 Egenskaper med @property

k.hent_saldo() og k.sett_temp(22) er trygge, men tungvinte. Det er mye penere å skrive k.saldo og t.temp = 22, bare vi samtidig får kontrollen med hva som skjer. Python har en løsning: egenskaper (properties). Utenfra ser de ut som vanlige attributter, men bak kulissene kjører de metoder.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage en lesbar egenskap med @property,
  • lage en egenskap som kan endres med kontroll, med @navn.setter,
  • lage en egenskap som regnes ut fra andre attributter,
  • bruke en setter i konstruktøren, så objektet er gyldig fra første stund.

Lese med @property

@property over en metode gjør at du kan bruke metoden uten parentes, som om det var et attributt:

class Konto:
    def __init__(self):
        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

k = Konto()
k.sett_inn(500)
print(k.saldo)
500

Vi skriver k.saldo, ikke k.saldo(). Siden vi ikke har laget noen setter, kan saldoen leses men ikke endres utenfra:

try:
    k.saldo = 1000000
except AttributeError as feil:
    print("AttributeError:", feil)
AttributeError: property 'saldo' of 'Konto' object has no setter

I UML kan en slik skrivebeskyttet egenskap skrives + saldo: float {readOnly}.

Endre med @navn.setter

Vil du la verdien endres, men med kontroll, legger du til en setter: en metode med samme navn og dekoratoren @navn.setter. Den kjøres når noen skriver objekt.navn = verdi.

class Termostat:
    def __init__(self, temp):
        self.temp = temp            # bruker setteren under

    @property
    def temp(self):
        return self._temp

    @temp.setter
    def temp(self, grader):
        if not 5 <= grader <= 30:
            raise ValueError("Temperaturen må være mellom 5 og 30")
        self._temp = grader

t = Termostat(20)
t.temp = 25
print(t.temp)

try:
    t.temp = 50
except ValueError as feil:
    print("Feil:", feil)
print(t.temp)
25
Feil: Temperaturen må være mellom 5 og 30
25

Utenfra ser temp ut som et vanlig attributt: vi leser t.temp og skriver t.temp = 25. Men det er metodene som kjøres, og de kontrollerer verdien. Navnet på det private attributtet (_temp) er forskjellig fra egenskapen (temp), slik at de ikke blander seg.

Merk linjen self.temp = temp i konstruktøren. Den går gjennom setteren, så et ugyldig startverdi avvises på samme måte. Hadde vi skrevet self._temp = temp, ville kontrollen blitt hoppet over for den første verdien.

RegelEgenskap med kontroll
@property
def navn(self):
    return self._navn

@navn.setter
def navn(self, verdi):
    # sjekk verdien her
    self._navn = verdi
  • Getter (@property) og setter (@navn.setter) har samme navn.
  • Verdien lagres i et privat attributt med understrek.
  • Bruk self.navn = verdi i konstruktøren, så setteren kjøres også da.
  • Mangler setteren, kan egenskapen bare leses.

Lag klassen Person med navn og en egenskap alder som må være et heltall fra \(0\) til \(130\). Ugyldige verdier gir ValueError.

Setteren sjekker 0 <= alder <= 130. Konstruktøren bruker self.alder = alder.

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

    @property
    def alder(self):
        return self._alder

    @alder.setter
    def alder(self, verdi):
        if not 0 <= verdi <= 130:
            raise ValueError("Alderen må være mellom 0 og 130")
        self._alder = verdi

p = Person("Per", 17)
p.alder += 1
print(p.alder)
try:
    Person("Ola", -3)
except ValueError as feil:
    print(feil)
18
Alderen må være mellom 0 og 130

Legg merke til at p.alder += 1 virker som for et vanlig attributt, og går gjennom både getter og setter.

Egenskaper som regnes ut

En egenskap trenger ikke ha et lagret attributt bak seg. Den kan regnes ut hver gang den leses:

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

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

r = Rektangel(3, 4)
print(r.areal)
r.bredde = 10
print(r.areal)
12
40

Når bredden endres, endres arealet automatisk, siden det regnes ut på nytt hver gang. Vi trenger ikke passe på å holde en lagret verdi oppdatert. Dette er det vi diskuterte i 5.5.1: lagre ikke det du kan regne ut.

NoteMetode eller egenskap?

Bruk en egenskap når det oppleves som å lese en verdi: rektangel.areal, konto.saldo. Bruk en vanlig metode når det er en handling eller tar tid, eller har parametere: konto.sett_inn(100), forestilling.selg(12). Spør: høres det naturlig ut som et navneord eller et verb?

AdvarselVanlige feil
  • Å bruke samme navn på egenskapen og det private attributtet (self.temp = temp i en setter). Det gir uendelig rekursjon. Bruk self._temp i setteren.
  • Å glemme @temp.setter eller å skrive et annet navn enn egenskapen.
  • Å kalle egenskapen med parentes (k.saldo()). Den er ikke en metode lenger.
  • Å skrive self._temp = temp i konstruktøren, så setteren (og kontrollen) hoppes over.
  • Å lage en setter som ikke sjekker noe. Da trenger du ikke en egenskap.
  • Å lage en tung beregning som egenskap. Brukeren venter at det går raskt å lese et attributt.

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 Sirkel:
    def __init__(self, radius):
        self.radius = radius

    @property
    def diameter(self):
        return 2 * self.radius

s = Sirkel(5)
print(s.diameter)
s.radius = 7
print(s.diameter)

10 og så 14. diameter regnes ut på nytt hver gang den leses, så den følger radius.

I klassen Konto finnes @property def saldo men ingen setter. Hva skjer med k.saldo = 100?

Hva betyr det at en egenskap mangler setter?

Python gir AttributeError. Uten setter er egenskapen skrivebeskyttet, så saldoen kan bare endres gjennom metoder som sett_inn.

Nivå 2
class Termostat:
    def __init__(self, temp):
        self._temp = temp

    @property
    def temp(self):
        return self._temp

    @temp.setter
    def temp(self, grader):
        if not 5 <= grader <= 30:
            raise ValueError("Ugyldig")
        self._temp = grader

Termostat(99) virker uten feil. Hvorfor, og hvordan rettes det?

Konstruktøren skriver direkte til self._temp, og hopper over setteren, så verdien aldri kontrolleres. Rett ved å skrive self.temp = temp i konstruktøren, så setteren kjøres også da.

Bestem for hver: egenskap (@property) eller vanlig metode?

Antall ledige seter i en forestilling.
Egenskap (en verdi som regnes ut). b) Metode (en handling med parameter). c) Egenskap. d) Metode (en handling).
Å selge en billett.
Arealet til et rektangel.
Å nullstille en teller.
Kodeoppgaver

Skriv klassen Rektangel med bredde og hoyde, og de utregnede egenskapene areal og omkrets (ikke metoder).

Sett @property over hver metode, og ikke kall dem med parentes.

Skriv klassen Konto med egenskapen saldo (bare lesing, starter på \(0\)) og metodene sett_inn(belop) og ta_ut(belop) som utløser ValueError hvis beløpet ikke er positivt, eller (for uttak) større enn saldoen.

@property def saldo(self): return self._saldo, og ingen setter.

Skriv klassen Person med navn og egenskapen alder, som må være et heltall fra \(0\) til \(130\), ellers ValueError. Konstruktøren tar navn og alder og skal også avvise ugyldig alder.

Skriv self.alder = alder i __init__, og la setteren sjekke 0 <= verdi <= 130.

Setteren skal avvise negative priser, men Vare("kaffe", -5) virker. Rett koden.

Hvilken linje i __init__ hopper over setteren?

Skriv klassen Forestilling med antall_seter og en liste solgte. Lag egenskapen ledige (utregnet antall ledige seter) og metoden selg(sete) som legger til setet hvis det er mellom \(1\) og antall_seter og ikke solgt, og gir True eller False.

@property def ledige(self): return self.antall_seter - len(self.solgte).

Utfordringer

Skriv klassen Temperatur som lagrer grader celsius i _celsius. Lag en egenskap celsius med setter som avviser verdier under \(-273.15\) (ValueError), og en egenskap fahrenheit som kan både leses og settes. Fahrenheit regnes om: \(F = C \cdot 9/5 + 32\).

Setteren for fahrenheit regner om til celsius og skriver self.celsius = ..., så kontrollen kjøres.

Sammenlign k.hent_saldo() og k.saldo. Hva er fordelen med egenskaper? Finnes det en ulempe?

Egenskaper gir en enklere og mer lesbar bruk (k.saldo) samtidig som klassen kontrollerer hva som skjer. Du kan også begynne med et vanlig attributt, og senere gjøre det om til en egenskap med kontroll, uten at koden som bruker klassen må endres. Ulempen er at det ser ut som et vanlig attributt, så leseren kan overse at det kjører kode bak (som kan avvise verdier eller være treg). Bruk det til enkle verdier.

Oppsummering

Lese

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

Endre med kontroll

@saldo.setter
def saldo(self, verdi):
    if verdi < 0:
        raise ValueError("...")
    self._saldo = verdi

Utregnet

@property
def areal(self):
    return self.bredde * self.hoyde
  • Bruk self.navn = verdi i konstruktøren, så setteren kjører.
  • Lagre i self._navn, aldri i self.navn inni setteren.
  • Ingen setter betyr skrivebeskyttet.

6.4 Spesialmetoder

Python har et sett metoder med to understreker på hver side, som Python selv kaller i bestemte situasjoner. Du har allerede brukt __init__. Her lærer du de som styrer utskrift og sammenligning.

6.4.1 Tekst for objekter: str og repr

Du har lagt merke til hva som skjer når du skriver ut et objekt: du får <__main__.Film object at 0x...>. Det forteller deg ingenting. Heldigvis kan du bestemme selv hva Python skal vise, ved å skrive spesialmetoder i klassen. Det er mye lettere å lese utskriften av et program, og å feilsøke, når objektene kan presentere seg selv.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage __str__ som gir en lesbar tekst for brukeren,
  • lage __repr__ som gir en tydelig tekst for programmereren,
  • forklare når Python bruker hvilken,
  • skrive ut lister av objekter slik at innholdet vises.

str: tekst til brukeren

__str__ er en metode som gir en tekst (med return, ikke print). Python kaller den automatisk når du bruker print(objekt), str(objekt) eller setter objektet inn i en f-streng.

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def __str__(self):
        return f"{self.tittel} ({self.varighet} min)"

dune = Film("Dune", 155)
print(dune)
print(f"Kveldens film: {dune}")
tekst = str(dune)
print(len(tekst))
Dune (155 min)
Kveldens film: Dune (155 min)
14

Før vi skrev __str__, måtte vi lage en egen metode som vis_info() og kalle den. Nå virker det vanlige print rett ut.

Lag __str__ i klassen Billett (med sete og pris) slik at print(Billett(12, 130)) skriver Sete 12, 130 kr.

Metoden gir en tekst med return, den skriver ikke selv.

class Billett:
    def __init__(self, sete, pris):
        self.sete = sete
        self.pris = pris

    def __str__(self):
        return f"Sete {self.sete}, {self.pris} kr"

print(Billett(12, 130))
Sete 12, 130 kr

repr: tekst til programmereren

__repr__ er den andre tekstmetoden. Den skal gi en tydelig og utvetydig beskrivelse, helst slik at du kan se nøyaktig hva objektet inneholder. Konvensjonen er at den ser ut som koden som lager objektet: Film('Dune', 155). Python bruker __repr__ når objektet vises inni noe annet, som i en liste, og når du feilsøker.

Her er forskjellen på en liste med objekter uten og med __repr__:

class Sal:
    def __init__(self, nummer, antall_seter):
        self.nummer = nummer
        self.antall_seter = antall_seter

    def __str__(self):
        return f"Sal {self.nummer}"

saler = [Sal(1, 200), Sal(2, 120)]
print(saler[0])
print(str(saler).startswith("[<__main__.Sal object at"))
Sal 1
True

print(saler[0]) bruker __str__, og skriver Sal 1. Men skriver du ut lista, viser Python hvert element med __repr__, og den har vi ikke laget ennå, så du får adresser. La oss lage den:

class Sal:
    def __init__(self, nummer, antall_seter):
        self.nummer = nummer
        self.antall_seter = antall_seter

    def __str__(self):
        return f"Sal {self.nummer}"

    def __repr__(self):
        return f"Sal({self.nummer}, {self.antall_seter})"

saler = [Sal(1, 200), Sal(2, 120)]
print(saler)
print(saler[0])
print(repr(saler[1]))
[Sal(1, 200), Sal(2, 120)]
Sal 1
Sal(2, 120)

Nå viser lista nøyaktig hva som ligger i den, og print(saler[0]) gir fortsatt den korte teksten for brukeren.

Regelstr og repr
  • __str__: en pen tekst for brukeren. Brukes av print og str.
  • __repr__: en tydelig tekst for programmereren, helst som koden som lager objektet. Brukes i lister og ved feilsøking.
  • Begge gir en tekst med return.
  • Lager du bare én, lag __repr__. Finnes ikke __str__, bruker Python __repr__.

Det siste punktet er nyttig: har du bare __repr__, virker både print(objekt) og utskrift av lister. Du kan også be om __repr__ i en f-streng med !r: f"{objekt!r}".

class Punkt:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __repr__(self):
        return f"Punkt({self.x}, {self.y})"

p = Punkt(3, 4)
print(p)
print([p, Punkt(0, 0)])
print(f"Startpunkt: {p!r}")
Punkt(3, 4)
[Punkt(3, 4), Punkt(0, 0)]
Startpunkt: Punkt(3, 4)
class Hund:
    def __init__(self, navn):
        self.navn = navn

    def __str__(self):
        return "En hund"

    def __repr__(self):
        return f"Hund({self.navn!r})"

fido = Hund("Fido")
print(fido)
print([fido])

print(objekt) bruker __str__. Elementer i en liste vises med __repr__.

Først En hund, så [Hund('Fido')]. !r setter anførselstegn rundt teksten, så repr av "Fido" er 'Fido'.

Vanlige feil å unngå

Det er lett å komme i skade for å skrive print inni __str__ i stedet for return:

def __str__(self):
    print(self.tittel)          # Feil! Gir None tilbake

Da skriver print(objekt) først tittelen, og så krasjer Python med TypeError: __str__ returned non-string (type NoneType). Metoden må gi tilbake teksten.

AdvarselVanlige feil
  • Å skrive print i stedet for return i __str__ eller __repr__.
  • Å returnere noe som ikke er tekst (et tall eller en liste). Bruk f-streng eller str(...).
  • Å glemme understrekene: _str_ eller str.
  • Å glemme self som parameter.
  • Å lage en __repr__ som ikke viser verdiene, så feilsøking blir vanskelig.
  • Å bruke __str__ til å vise intern informasjon brukeren ikke skal se.

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 Bil:
    def __init__(self, modell):
        self.modell = modell

    def __str__(self):
        return f"Bil: {self.modell}"

b = Bil("Golf")
print(b)
print(str(b))
print(f"Jeg kjører en {b}")

Bil: Golf, Bil: Golf og Jeg kjører en Bil: Golf. Alle tre bruker __str__.

Hvilken metode bruker Python i hvert tilfelle (anta at begge finnes)?

print(objekt)
__str__. b) __repr__ (elementer i en liste vises med repr). c) __str__. d) __repr__.
print([objekt])
f"{objekt}"
repr(objekt)
Nivå 2
class Kunde:
    def __init__(self, navn):
        self.navn = navn

    def __str__(self):
        print(f"Kunde: {self.navn}")

Hva skjer med print(Kunde("Ola")), og hvordan rettes det?

Hva gir metoden tilbake?

Først skrives Kunde: Ola ut fra inni metoden, og så krasjer det med TypeError: __str__ returned non-string (type NoneType), fordi metoden ikke har noen return. Rett til return f"Kunde: {self.navn}".

Skriv __repr__ for klassen Billett med sete og pris slik at Billett(12, 130) vises som Billett(12, 130).

class Billett:
    def __init__(self, sete, pris):
        self.sete = sete
        self.pris = pris
    def __repr__(self):
        return f"Billett({self.sete}, {self.pris})"

Metoden legges inne i klassen. Den ser ut som koden som lager objektet.

Kodeoppgaver

Skriv klassen Film med tittel og varighet og __str__ som gir Dune (155 min).

return f"{self.tittel} ({self.varighet} min)". Husk return, ikke print.

Skriv klassen Punkt med x og y, og __repr__ som gir Punkt(3, 4). Siden __str__ ikke finnes, skal print(punkt) gi det samme.

Bare __repr__ trengs: return f"Punkt({self.x}, {self.y})".

Skriv klassen Elev med navn og klasse. __str__ gir Kari (2IT), og __repr__ gir Elev('Kari', '2IT').

Bruk !r i repr: f"Elev({self.navn!r}, {self.klasse!r})" setter anførselstegn rundt tekstene.

print(Bil("Golf")) krasjer. Rett klassen.

Skift print med return.

Skriv klassen Billett med sete og pris, og __str__ som gir Sete 12: 130 kr. Skriv så funksjonen oversikt(billetter) som gir én tekst med hver billett på sin linje (adskilt med "\n", ingen linjeskift til slutt).

"\n".join(str(b) for b in billetter), eller en løkke som bygger opp en liste med tekster.

Utfordringer

Skriv klassen Brok med teller og nevner. __str__ gir 3/4, men er nevneren \(1\) gir den bare telleren (5/1 blir 5). __repr__ gir Brok(3, 4). Nevneren kan ikke være \(0\) (ValueError).

I __str__: if self.nevner == 1: return str(self.teller).

Hvorfor har Python både __str__ og __repr__? Når passer det best med forskjellig tekst?

Den ene er for den som bruker programmet (en pen, kort tekst), og den andre for den som lager det (en nøyaktig tekst som viser hva objektet er, nyttig ved feilsøking og i lister). Har et objekt et kundenummer og et passord, vil __str__ bare vise kundenavnet til brukeren, mens __repr__ viser alt som trengs for å forstå en feil.

Oppsummering

str

def __str__(self):
    return f"{self.tittel}"

print(obj), str(obj), f-strenger

repr

def __repr__(self):
    return f"Film({self.tittel!r})"

Lister, feilsøking, repr(obj)

  • return en tekst, ikke print.
  • Mangler __str__, bruker Python __repr__.
  • __repr__ ser helst ut som koden som lager objektet.

6.4.2 Sammenligning: eq og lt

Er to billetter til samme sete på samme forestilling den samme billetten? For oss ja, men Python er forsiktig: som standard er to objekter bare like hvis de er det samme objektet i minnet. Skal Python sammenligne innhold, må vi si hva det betyr. Samme gjelder rekkefølge: hvordan skal Python sortere en liste med filmer, etter tittel eller varighet?

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare forskjellen på == og is for objekter,
  • lage __eq__ som sammenligner innholdet,
  • lage __lt__ slik at lister av objekter kan sorteres,
  • bruke key til å sortere etter ulike egenskaper.

eq: er de like?

Uten __eq__ er == det samme som is: bare det samme objektet er likt seg selv.

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

a = Film("Dune", 155)
b = Film("Dune", 155)
print(a == b)
print(a == a)
False
True

Selv om a og b har samme innhold, er de to ulike objekter, så a == b er False. Vi lager __eq__ for å si hva «lik» betyr:

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def __eq__(self, annen):
        if not isinstance(annen, Film):
            return NotImplemented
        return self.tittel == annen.tittel and self.varighet == annen.varighet

a = Film("Dune", 155)
b = Film("Dune", 155)
c = Film("Dune", 160)
print(a == b)
print(a == c)
print(a is b)
print(a == "Dune")
True
False
False
False

Nå er a == b sann, siden tittel og varighet er like, men a is b er fortsatt usann, for de er to ulike objekter. Sjekken isinstance(annen, Film) sørger for at vi ikke prøver å sammenligne med en tekst eller et tall, som ikke har tittel. Da gir vi NotImplemented, og Python svarer at de ikke er like.

Du bestemmer selv hva som skal telle med. Er to filmer like hvis tittelen er lik, uansett varighet? Da sammenligner du bare tittelen.

Noteeq og mengder

Når du lager __eq__, mister klassen muligheten til å brukes i mengder (set) og som nøkler i ordbøker, med mindre du også lager __hash__. Det trenger du ikke i dette kurset. Skal du ha unike objekter, kan du heller bruke en liste og sjekke med in.

Operatoren in bruker __eq__: film in filmer er sann hvis noe i lista er lik filmen.

filmer = [Film("Dune", 155), Film("Oppdrag Mars", 118)]
print(Film("Dune", 155) in filmer)
True

Lag __eq__ for Billett (med sete og forestilling) slik at to billetter er like hvis de gjelder samme sete på samme forestilling.

Sammenlign begge attributtene, og sjekk typen først.

class Billett:
    def __init__(self, sete, forestilling):
        self.sete = sete
        self.forestilling = forestilling

    def __eq__(self, annen):
        if not isinstance(annen, Billett):
            return NotImplemented
        return (self.sete == annen.sete
                and self.forestilling == annen.forestilling)

print(Billett(12, "f1") == Billett(12, "f1"))
print(Billett(12, "f1") == Billett(13, "f1"))
True
False

lt: hva er minst?

For å sortere må Python vite hvilket av to objekter som kommer først. Det forteller du med __lt__ («less than», <). Den gir True hvis self skal komme før annen:

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def __lt__(self, annen):
        return self.varighet < annen.varighet

    def __repr__(self):
        return f"Film({self.tittel!r}, {self.varighet})"

filmer = [Film("Dune", 155), Film("Pondus på tur", 94),
          Film("Oppdrag Mars", 118)]
print(sorted(filmer))
print(min(filmer))
print(max(filmer))
print(Film("A", 90) < Film("B", 100))
[Film('Pondus på tur', 94), Film('Oppdrag Mars', 118), Film('Dune', 155)]
Film('Pondus på tur', 94)
Film('Dune', 155)
True

Med __lt__ virker <, sorted, .sort(), min og max på objektene. Her sorterer vi etter varighet, kortest først. Vi lagde også __repr__ så vi ser hva som skrives ut.

Sortere på flere måter med key

En klasse kan bare ha én __lt__. Vil du sortere etter forskjellige egenskaper ved ulike anledninger, bruker du heller key, som du kjenner fra 2.3.1:

print(sorted(filmer, key=lambda f: f.tittel))
print(sorted(filmer, key=lambda f: f.varighet, reverse=True))
[Film('Dune', 155), Film('Oppdrag Mars', 118), Film('Pondus på tur', 94)]
[Film('Dune', 155), Film('Oppdrag Mars', 118), Film('Pondus på tur', 94)]

key bestemmer hva som sammenlignes, og trenger ingen __lt__. Bruk __lt__ når det finnes én naturlig rekkefølge (for eksempel etter dato), og key når du trenger flere.

RegelSammenligning
  • __eq__(self, annen) styrer == og in. Sammenlign innholdet.
  • __lt__(self, annen) styrer <, sorted, min og max. Gi True hvis self kommer først.
  • Sjekk isinstance(annen, Klasse) i __eq__, og gi NotImplemented ellers.
  • key= sorterer etter en egenskap uten å lage __lt__.

Lag Spiller med navn og poeng, slik at sorted(spillere) gir den med færrest poeng først. Hvordan får du den med flest poeng først?

__lt__ sammenligner poeng. Husk reverse=True.

class Spiller:
    def __init__(self, navn, poeng):
        self.navn = navn
        self.poeng = poeng

    def __lt__(self, annen):
        return self.poeng < annen.poeng

    def __repr__(self):
        return f"{self.navn}: {self.poeng}"

spillere = [Spiller("Mia", 40), Spiller("Jon", 75), Spiller("Eva", 55)]
print(sorted(spillere))
print(sorted(spillere, reverse=True))
[Mia: 40, Eva: 55, Jon: 75]
[Jon: 75, Eva: 55, Mia: 40]
AdvarselVanlige feil
  • Å tro at == sammenligner innholdet uten __eq__. Standard er identitet.
  • Å glemme å sjekke typen i __eq__, så sammenligning med en tekst krasjer.
  • Å skrive __lt__ som gir tekst eller tall i stedet for True eller False.
  • Å bruke <= eller > i __lt__, så sorteringen blir feil for like objekter.
  • Å glemme at __eq__ og __lt__ må ha self og annen som parametere.
  • Å bruke is når du mener ==.

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 Punkt:
    def __init__(self, x, y):
        self.x = x
        self.y = y

a = Punkt(1, 2)
b = Punkt(1, 2)
c = a
print(a == b)
print(a == c)
print(a is c)

Uten __eq__ sammenligner == identiteten.

False, True og True. Uten __eq__ er == det samme som is. a og b er to objekter, men c er samme objekt som a.

Hvilken spesialmetode styrer hver av disse: a) x == y, b) x < y, c) sorted(lista), d) x in lista.

  1. __eq__. b) __lt__. c) __lt__ (sorterer ved å bruke <). d) __eq__ (sjekker likhet med hvert element).
Nivå 2
class Elev:
    def __init__(self, navn, alder):
        self.navn = navn
        self.alder = alder

    def __lt__(self, annen):
        return self.alder < annen.alder

    def __repr__(self):
        return self.navn

elever = [Elev("Kari", 18), Elev("Ola", 16), Elev("Mia", 17)]
print(sorted(elever))
print(max(elever))

[Ola, Mia, Kari] og Kari. Elevene sorteres etter alder, yngst først, og max gir den eldste.

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def __eq__(self, annen):
        return self.tittel == annen.tittel

Hva skjer med Film("Dune", 155) == "Dune", og hvordan rettes det?

Teksten "Dune" har ikke attributtet tittel, så det gir AttributeError. Rett det ved å sjekke typen: if not isinstance(annen, Film): return NotImplemented.

Kodeoppgaver

Skriv klassen Film med tittel og varighet og __eq__ som er sann når begge er like. Sammenligning med noe som ikke er en film, skal gi False.

Sjekk isinstance(annen, Film) først og gi NotImplemented ellers. Så sammenligner du begge attributtene.

Skriv klassen Film med tittel og varighet og __lt__ som sammenligner varighet. Skriv så funksjonen kortest(filmer) som gir tittelen til den korteste filmen i lista, eller None for en tom liste.

__lt__ gir self.varighet < annen.varighet. min(filmer).tittel gir den korteste.

Skriv klassen Spiller med navn og poeng. Lag __lt__ slik at spilleren med flest poeng regnes som «minst» (kommer først i sorted). Skriv rangering(spillere) som gir lista med navn, best først.

__lt__ kan sammenligne self.poeng > annen.poeng. Så er sorted(spillere) best først.

Gitt klassen Elev med navn og alder. Skriv etter_navn(elever) (sortert alfabetisk etter navn) og eldst_forst(elever) (eldst først), begge uten å lage __lt__.

sorted(elever, key=lambda e: e.navn). For eldst først bruker du også reverse=True. sorted endrer ikke originalen.

Utfordringer

Skriv klassen Dato med ar, maned og dag. Lag __eq__ (alle tre like), __lt__ (tidligere dato er mindre) og __str__ som gir 2026-11-18 (med nuller foran, to siffer for måned og dag).

Sammenlign tuplene (self.ar, self.maned, self.dag) < (annen.ar, annen.maned, annen.dag). Tupler sammenlignes element for element. Formatér med :02d.

Du har klassen Bil med modell, pris og årsmodell. Når passer det best å bruke __lt__, og når key?

Finnes det én naturlig rekkefølge som alltid gjelder (for eksempel etter pris), kan du lage __lt__, og da virker sorted, min, max og < automatisk. Skal du sortere på ulike måter avhengig av situasjon (pris, så årsmodell, så modell), er key bedre, siden du velger hva som sammenlignes hver gang, og slipper at klassen bestemmer for alle.

Oppsummering

eq

def __eq__(self, annen):
    if not isinstance(annen, Film):
        return NotImplemented
    return self.tittel == annen.tittel

lt

def __lt__(self, annen):
    return self.varighet < annen.varighet

Sortere

sorted(filmer)
sorted(filmer, key=lambda f: f.tittel)
  • Uten __eq__ er == det samme som is.
  • __lt__ gir True eller False.
  • key= når du trenger flere måter å sortere på.

6.5 Objekter som samarbeider

Et program består sjelden av ett enkelt objekt. Her ser du hvordan du arbeider med mange objekter, og hvordan objekter kan bruke hverandre.

6.5.1 Objekter i lister og ordbøker

Kinoen har ikke én film, men mange. En skole har mange elever, og et spill har mange fiender. Det er her objektene virkelig kommer til nytte: du lager mange objekter av samme klasse, samler dem i en liste eller en ordbok, og bruker de teknikkene du kan fra kapittel 2 til å summere, søke, filtrere og sortere.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lage en liste av objekter og gå gjennom den med en løkke,
  • summere, søke, filtrere og sortere objekter,
  • bruke en ordbok til å slå opp objekter,
  • forklare at to variabler kan peke på samme objekt.

Liste av objekter

Objekter kan ligge i lister akkurat som tall og tekster. Hvert element er et objekt, og du bruker punktum for å nå attributtene:

class Film:
    def __init__(self, tittel, varighet):
        self.tittel = tittel
        self.varighet = varighet

    def __repr__(self):
        return f"Film({self.tittel!r}, {self.varighet})"

filmer = [
    Film("Dune", 155),
    Film("Oppdrag Mars", 118),
    Film("Pondus på tur", 94),
]

for film in filmer:
    print(film.tittel)

total = 0
for film in filmer:
    total += film.varighet
print("Samlet spilletid:", total)
Dune
Oppdrag Mars
Pondus på tur
Samlet spilletid: 367

Samme mønstre som for andre lister virker. Her er noen vanlige:

# Søke: første film med en bestemt tittel
def finn_film(filmer, tittel):
    for film in filmer:
        if film.tittel == tittel:
            return film
    return None

# Filtrere: alle filmer under 120 minutter
korte = [f for f in filmer if f.varighet < 120]

# Finne største: den lengste filmen
lengste = max(filmer, key=lambda f: f.varighet)

# Sortere: etter tittel
alfabetisk = sorted(filmer, key=lambda f: f.tittel)

print(finn_film(filmer, "Dune"))
print(finn_film(filmer, "Titanic"))
print(korte)
print(lengste)
print(alfabetisk)
Film('Dune', 155)
None
[Film('Oppdrag Mars', 118), Film('Pondus på tur', 94)]
Film('Dune', 155)
[Film('Dune', 155), Film('Oppdrag Mars', 118), Film('Pondus på tur', 94)]

Nøkkelen er å skrive film.varighet der du ellers ville skrevet bare tallet. finn_film gir None hvis ingenting passer. Husk å sjekke for None før du bruker resultatet.

Gitt en liste med Elev-objekter (med attributtet alder). Skriv koden som regner ut gjennomsnittsalderen.

Summer elev.alder i en løkke, og del på antall.

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

elever = [Elev("Kari", 18), Elev("Ola", 16), Elev("Mia", 17)]
sum_alder = 0
for elev in elever:
    sum_alder += elev.alder
print(sum_alder / len(elever))
17.0

Det kan også skrives sum(e.alder for e in elever) / len(elever).

Ordbok med objekter

Må du ofte finne et objekt ut fra en nøkkel, er en ordbok bedre enn å lete gjennom en liste hver gang. Nøkkelen kan være en tittel, et nummer eller et navn, og verdien er objektet:

film_etter_tittel = {}
for film in filmer:
    film_etter_tittel[film.tittel] = film

dune = film_etter_tittel["Dune"]
print(dune.varighet)
print("Titanic" in film_etter_tittel)
155
False

Oppslag i en ordbok går raskt, og koden blir kortere enn en søkeløkke. Ordbøker passer når nøkkelen er unik, som et kundenummer eller en tittel.

RegelListe eller ordbok?
  • Liste: objektene har en rekkefølge, eller du går gjennom alle. Du søker sjelden.
  • Ordbok: du slår ofte opp ett objekt ut fra en unik nøkkel (nummer, navn).

To navn, samme objekt

Når du legger et objekt i en liste, eller gir det til en variabel, kopieres ikke objektet. Du får bare et nytt navn som peker på det samme objektet. Det er lett å bli overrasket av:

dune = Film("Dune", 155)
filmer = [dune]
ordbok = {"Dune": dune}

dune.varighet = 160
print(filmer[0].varighet)
print(ordbok["Dune"].varighet)
160
160

Vi endret varigheten bare én gang, men den er endret overalt, fordi dune, filmer[0] og ordbok["Dune"] alle peker på ett og samme objekt. Det er ofte det vi vil (én film, mange steder), men vær klar over det. Skal du ha to uavhengige objekter, må du lage to objekter med Film(...).

En vanlig feil er å lage en liste med samme objekt gjentatt, i stedet for mange objekter:

feil = [Film("Ukjent", 0)] * 3
feil[0].tittel = "Endret"
print(feil)

riktig = [Film("Ukjent", 0) for _ in range(3)]
riktig[0].tittel = "Endret"
print(riktig)
[Film('Endret', 0), Film('Endret', 0), Film('Endret', 0)]
[Film('Endret', 0), Film('Ukjent', 0), Film('Ukjent', 0)]

Den første lista har tre plasser som peker på samme film, så en endring vises på alle. I den andre lages tre egne objekter.

AdvarselVanlige feil
  • Å skrive liste * 3 med et objekt og tro at du får tre ulike objekter.
  • Å glemme None når et søk ikke finner noe: finn_film(...).tittel krasjer med AttributeError på None.
  • Å endre et objekt i en løkke og tro at det er en kopi. Endringen gjelder det virkelige objektet.
  • Å skrive film når du mener film.tittel, så du sammenligner et objekt med en tekst.
  • Å bruke en ordbok med en nøkkel som ikke er unik. Den siste vinner, og de andre forsvinner.
  • Å legge til i lista mens du går gjennom den med en løkke.

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 Elev:
    def __init__(self, navn, poeng):
        self.navn = navn
        self.poeng = poeng

elever = [Elev("Kari", 40), Elev("Ola", 25), Elev("Mia", 35)]
total = 0
for e in elever:
    total += e.poeng
print(total)
print(elever[1].navn)
print(len(elever))

100, Ola og 3. Summen er \(40 + 25 + 35\), elever[1] er det andre objektet, og lista har tre elementer.

Velg liste eller ordbok for hver situasjon.

Alle kundene skal skrives ut i rekkefølge.
Liste (du går gjennom alle). b) Ordbok med kundenummer som nøkkel. c) Liste (du går gjennom alle).
Du skal ofte finne en kunde ut fra kundenummeret.
Du skal finne gjennomsnittsalder for alle elevene.
Nivå 2
class Teller:
    def __init__(self):
        self.verdi = 0

a = Teller()
b = a
c = Teller()
b.verdi = 5
print(a.verdi, b.verdi, c.verdi)

Hvor mange objekter er det laget?

5 5 0. Det er laget to objekter. a og b peker på det første, så endringen via b vises i a. c er et eget objekt.

class Spiller:
    def __init__(self):
        self.poeng = 0

spillere = [Spiller()] * 3
spillere[0].poeng = 10
print([s.poeng for s in spillere])

Hva skrives ut, og hvordan rettes det?

[10, 10, 10], siden alle tre plassene peker på samme objekt. Rett med [Spiller() for _ in range(3)], som lager tre ulike spillere. Da blir utskriften [10, 0, 0].

Kodeoppgaver

Gitt klassen Film med varighet. Skriv funksjonen total_tid(filmer) som gir summen av varighetene.

Løkke med total += film.varighet, eller sum(f.varighet for f in filmer).

Skriv funksjonen finn_film(filmer, tittel) som gir filmobjektet med tittelen, eller None hvis den ikke finnes.

Gå gjennom lista. Sammenlign film.tittel med tittel. Gi None etter løkka.

Skriv funksjonen korte_filmer(filmer, grense) som gir lista med titlene til filmene som er kortere enn grense minutter, sortert alfabetisk.

sorted([f.tittel for f in filmer if f.varighet < grense]).

Skriv funksjonen lag_ordbok(elever) som gir en ordbok fra navn til elev-objektet.

Lag en tom ordbok og sett ordbok[elev.navn] = elev for hver elev.

Funksjonen skal gi tre uavhengige spillere, men alle deler samme objekt. Rett koden.

Bruk en listeforståelse som kjører Spiller("Ny") tre ganger.

Skriv funksjonen beste(spillere) som gir navnet til spilleren med flest poeng, eller None for en tom liste. Er flere like, gir den den første av dem.

max(spillere, key=lambda s: s.poeng) gir den første ved likt. Sjekk tom liste først.

Utfordringer

Gitt Vare-objekter med navn og kategori. Skriv funksjonen grupper(varer) som gir en ordbok fra kategori til liste med navnene på varene i kategorien, i rekkefølgen de stod.

Er kategorien ikke i ordboka, lag en tom liste først. Så legger du til navnet.

Du har en liste filmer og lager kopi = filmer, og så kopi2 = list(filmer). Hva skjer med filmer hvis du (a) legger en ny film til kopi, (b) legger en ny film til kopi2, (c) endrer varigheten til første film i kopi2?

Er det samme liste? Er det samme objekter inni?

  1. kopi = filmer gir et nytt navn på samme liste, så filmen legges til i filmer også. b) list(filmer) lager en ny liste, så filmer er uendret. c) Den nye lista inneholder de samme filmobjektene, så endringen vises også i filmer. Å kopiere lista kopierer ikke objektene i den.

Oppsummering

Liste av objekter

for film in filmer:
    print(film.tittel)
total = sum(f.varighet for f in filmer)

Søke, filtrere, sortere

for f in filmer:
    if f.tittel == t:
        return f
return None

[f for f in filmer if f.varighet < 120]
sorted(filmer, key=lambda f: f.tittel)

Ordbok

film = {}
for f in filmer:
    film[f.tittel] = f
  • Å legge et objekt i en liste kopierer det ikke.
  • [objekt] * 3 gir tre navn på samme objekt.
  • Sjekk for None når et søk kan mislykkes.

6.5.2 Objekter som bruker hverandre

I kapittel 5 tegnet vi pilene mellom klassene: en forestilling kjenner en film og en sal, og en billett kjenner forestillingen og kunden. Nå gjør vi pilene til kode. Det er enkelt: en relasjon er et attributt som peker på et annet objekt. Når du har det, kan objektene kalle hverandres metoder og samarbeide, akkurat som i scenariet vi fulgte i 5.2.1.

Læringsmål

Etter dette delkapittelet skal du kunne

  • lagre et objekt som attributt i et annet objekt,
  • la et objekt kalle metoder i et annet objekt,
  • gjøre en modell fra kapittel 5 om til kode,
  • la et objekt opprette og eie andre objekter (komposisjon),
  • teste samarbeidende klasser.

Et objekt som attributt

Relasjonen Forestilling --> Film blir til at forestillingen har et attributt film som er selve filmobjektet:

class Film:
    def __init__(self, tittel, varighet, aldersgrense):
        self.tittel = tittel
        self.varighet = varighet
        self.aldersgrense = aldersgrense

class Sal:
    def __init__(self, nummer, antall_seter):
        self.nummer = nummer
        self.antall_seter = antall_seter

class Forestilling:
    def __init__(self, film, sal, tidspunkt):
        self.film = film
        self.sal = sal
        self.tidspunkt = tidspunkt

dune = Film("Dune", 155, 12)
sal1 = Sal(1, 200)
f = Forestilling(dune, sal1, "19:00")

print(f.film.tittel)
print(f.sal.antall_seter)
print(f.film.aldersgrense)
Dune
200
12

f.film er filmobjektet, og f.film.tittel er tittelen til den filmen. Du kan kjede punktum så langt du trenger. Forestillingen kjenner til filmen og salen, men de er ikke kopiert: f.film is dune er sann, så endrer du filmen, endres den også for forestillingen.

La objektene samarbeide

Dette er modellen fra kapittel 5 som vi nå skal lage kode for (forenklet):

classDiagram
    Forestilling --> Film
    Forestilling --> Sal
    Forestilling "1" *-- "*" Billett
    Kunde "1" --> "*" Billett

Nå tar vi med billetten og kunden, og lar forestillingen selge billetter. Dette er scenariet fra 5.2.1, som kode: kunden ber forestillingen om en billett, forestillingen sjekker, lager billetten og gir den tilbake.

class Kunde:
    def __init__(self, navn, alder):
        self.navn = navn
        self.alder = alder
        self.billetter = []

class Billett:
    def __init__(self, sete, pris, forestilling, kunde):
        self.sete = sete
        self.pris = pris
        self.forestilling = forestilling
        self.kunde = kunde

class Forestilling:
    PRIS_VOKSEN = 130
    PRIS_BARN = 90

    def __init__(self, film, sal, tidspunkt):
        self.film = film
        self.sal = sal
        self.tidspunkt = tidspunkt
        self.billetter = []

    def er_ledig(self, sete):
        if not 1 <= sete <= self.sal.antall_seter:
            return False
        for billett in self.billetter:
            if billett.sete == sete:
                return False
        return True

    def selg_billett(self, sete, kunde):
        if kunde.alder < self.film.aldersgrense:
            raise ValueError("Kunden er for ung for filmen")
        if not self.er_ledig(sete):
            return None
        pris = self.PRIS_BARN if kunde.alder < 12 else self.PRIS_VOKSEN
        billett = Billett(sete, pris, self, kunde)
        self.billetter.append(billett)
        kunde.billetter.append(billett)
        return billett

ola = Kunde("Ola", 30)
f = Forestilling(dune, sal1, "19:00")

b = f.selg_billett(12, ola)
print(b.sete, b.pris, b.kunde.navn)
print(f.selg_billett(12, ola))
print(len(ola.billetter))
print(b.forestilling.film.tittel)
12 130 Ola
None
1
Dune

Her skjer det mye samtidig, så gå gjennom det steg for steg:

  1. f.selg_billett(12, ola) kalles med et sete og et kundeobjekt.
  2. Forestillingen sjekker alderen mot aldersgrensen til filmen: self.film.aldersgrense. Den spør filmen, den kopierer ikke tallet.
  3. self.er_ledig(sete) bruker salen (self.sal.antall_seter) og billettene som allerede er solgt.
  4. Forestillingen lager en Billett som peker tilbake på forestillingen og kunden, og husker den i self.billetter.
  5. Kunden får også billetten i sin liste.
  6. Billetten gis tilbake, og b.forestilling.film.tittel leder oss tilbake til filmen.

Salg av samme sete gir None, og ingen ny billett lages. Hver klasse har sitt ansvar: Forestilling vet om salg og seter, Billett holder opplysningene, Kunde vet hvem og alder, og Film kjenner aldersgrensen.

RegelRelasjoner i kode
  • A --> B blir et attributt i A som peker på et B-objekt: self.film = film.
  • Multiplisitet * blir en liste: self.billetter = [].
  • Objektene samarbeider ved å kalle hverandres metoder: self.sal.antall_seter, kunde.billetter.append(...).
  • Unngå å gjøre alt dobbelt: har billetten en forestilling, trenger den ikke også tittel og tidspunkt.

Komposisjon: objektet som lager delene sine

Ved komposisjon (*--) hører delene til helheten og finnes ikke uten den. I koden lar vi da helheten lage delene selv. En kino består av saler, så kinoen lager dem:

class Kino:
    def __init__(self, navn, seter_per_sal):
        self.navn = navn
        self.saler = []
        for nummer, antall in enumerate(seter_per_sal, start=1):
            self.saler.append(Sal(nummer, antall))

    def stor_sal(self):
        return max(self.saler, key=lambda s: s.antall_seter)

gimle = Kino("Gimle", [200, 120, 60])
print(len(gimle.saler))
print(gimle.stor_sal().nummer)
print(gimle.saler[1].antall_seter)
3
1
120

Utenfra sender vi bare tallene, og kinoen oppretter og eier salene. Ved assosiasjon og aggregering (som Forestilling --> Film) lager vi objektene utenfor og sender dem inn, slik vi gjorde med Film over.

I koden over: hvilket av disse lages av et annet objekt, og hvilket sendes inn utenfra? a) salene i Kino, b) filmen i Forestilling, c) billetten i selg_billett.

Se hvor Sal(...), Film(...) og Billett(...) kalles.

  1. Salene lages inni Kino (komposisjon: kinoen eier dem). b) Filmen lages utenfor og sendes inn til Forestilling (assosiasjon: filmen finnes selv om forestillingen forsvinner). c) Billetten lages inni selg_billett i forestillingen (komposisjon: forestillingen eier billettene sine).

Pass på sirkler

Her peker billetten på kunden, og kunden har en liste med billetter. Det er lov, men vær forsiktig: skriver du ut et objekt som peker på et annet som peker tilbake (med __repr__ som skriver ut begge), kan det bli uendelig. Hold __repr__ og __str__ korte, og skriv bare det som trengs. Vurder også om begge retningene trengs, siden du må holde dem i takt: selger du en billett, må du huske å legge den i begge listene.

Å teste klasser som samarbeider

Klasser som samarbeider er enkle å teste hver for seg. Lag objektene du trenger, kall metodene, og sjekk resultatet med assert (se 4.4.1) eller pytest (4.4.2):

def test_selg_billett():
    film = Film("Test", 90, 0)
    forestilling = Forestilling(film, Sal(1, 3), "12:00")
    kunde = Kunde("Test", 30)
    billett = forestilling.selg_billett(2, kunde)
    assert billett is not None
    assert billett.pris == 130
    assert forestilling.selg_billett(2, kunde) is None
    assert forestilling.selg_billett(4, kunde) is None

test_selg_billett()
print("Testen gikk bra")
Testen gikk bra

Merk at testen lager sin egen minste mulige film, sal og kunde, og at den tester både vanlig salg, dobbeltsalg og et sete som ikke finnes.

AdvarselVanlige feil
  • Å kopiere opplysninger inn i et annet objekt i stedet for å peke på objektet (self.tittel = film.tittel i stedet for self.film = film). Da kan de bli ulike.
  • Å lagre bare et navn eller nummer når du trenger objektet selv.
  • Å glemme å oppdatere begge sider av en toveis relasjon.
  • Å lage delene utenfor og sende dem inn når modellen sier at helheten eier dem (komposisjon).
  • Å glemme at objektet kan være None før du leser attributtene dets.
  • Å lage et __repr__ som skriver ut hele objektgrafen.

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 Motor:
    def __init__(self, hk):
        self.hk = hk

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

m = Motor(150)
bil = Bil("Golf", m)
print(bil.motor.hk)
m.hk = 200
print(bil.motor.hk)
print(bil.motor is m)

150, 200 og True. Bilen har ikke en kopi av motoren, men peker på selve objektet. Endres m, ser bilen endringen.

Klassediagrammet viser Elev --> Klasse (en elev går i én klasse) og Klasse "1" o-- "*" Elev. Hvilke attributter får Elev og Klasse?

En enkelt relasjon blir ett attributt, og en til-mange-relasjon blir en liste.

Elev får et attributt klasse som peker på et Klasse-objekt (self.klasse = klasse). Klasse får en liste elever (self.elever = []) med Elev-objekter.

Nivå 2

Hvilke av disse bør lages inne i klassen (komposisjon), og hvilke sendes inn?

Rommene i et Hus.
Lages inne (komposisjon). b) Sendes inn (assosiasjon: sjåføren finnes uavhengig). c) Lages inne (komposisjon). d) Sendes inn (aggregering: spillerne finnes videre).
Sjåføren til en Bil.
Motoren til en Bil (som finnes bare som del av bilen).
Spillerne i et Lag (som finnes selv om laget legges ned).
class Kunde:
    def __init__(self, navn):
        self.navn = navn
        self.ordrer = []

class Ordre:
    def __init__(self, kunde, belop):
        self.kunde = kunde
        self.belop = belop
        kunde.ordrer.append(self)

ola = Kunde("Ola")
o1 = Ordre(ola, 100)
o2 = Ordre(ola, 250)
print(len(ola.ordrer))
print(sum(o.belop for o in ola.ordrer))
print(o1.kunde.navn)

Hva gjør konstruktøren i Ordre med kundens liste?

2, 350 og Ola. Konstruktøren i Ordre legger ordren til i kundens liste, så begge retninger holdes i takt automatisk.

Kodeoppgaver

Skriv klassene Motor (med hk) og Bil (med modell og motor, der motoren sendes inn). Legg til metoden effekt() i Bil som gir hestekreftene til motoren.

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

Skriv klassene Elev (med navn) og Klasse (med navn og en tom liste elever). Klasse.meld_inn(elev) legger eleven til i lista og gir True, men hvis eleven allerede er med (samme objekt), gir den False. antall() gir antall elever, og navnene() gir lista med navn.

if elev in self.elever: return False. Uten __eq__ sammenligner in objektidentitet, som er det vi vil her.

Skriv klassene Kunde (med navn og en tom liste ordrer) og Ordre (med kunde og belop). Når en Ordre lages, skal den legges i kundens liste automatisk. Legg til Kunde.total() som gir summen av alle ordrene.

I Ordre.__init__: kunde.ordrer.append(self).

Skriv klassene Sal (med nummer og antall_seter) og Kino. Kino(navn, seter_per_sal) tar en liste med antall seter og lager salene selv, nummerert fra \(1\). totalt_antall_seter() gir summen av setene i alle salene, og finn_sal(nummer) gir salen med det nummeret eller None.

Bruk enumerate(seter_per_sal, start=1) til å lage salene i konstruktøren.

Gitt klassene under. Skriv metoden selg_billett(sete) i Forestilling: hvis setet er ledig (mellom \(1\) og antall seter i salen, og ikke solgt), lager den en Billett, legger den til i billetter og gir den tilbake. Ellers gir den None.

Gå gjennom self.billetter og sjekk om noen har samme sete. Bruk self.sal.antall_seter til å sjekke grensene.

Gjør det i VS Code

Nå skal du bygge kinomodellen i VS Code, slik du gjør i prosjektene.

  1. Lag en mappe kino og filen kino.py. Skriv klassene Film, Sal, Kunde, Billett og Forestilling fra delkapittelet (du kan skrive dem selv, i stedet for å kopiere). La selg_billett også avvise kunder som er for unge.
  2. Lag test_kino.py i samme mappe, og skriv minst fem pytest-tester som from kino import ...: vanlig salg, dobbeltsalg, sete som ikke finnes, barnepris og for ung kunde (med pytest.raises(ValueError)).
  3. Kjør python -m pytest i terminalen, og se at alle er grønne.
  4. Legg til metoden inntekt() i Forestilling, som gir summen av prisene på alle solgte billetter. Skriv testen først, og se at den er rød, før du skriver metoden (TDD, se 4.5.1).
  5. Lag en commit i Git.

Filen test_kino.py kan se slik ut (de fem første testene og testen for inntekt):

import pytest
from kino import Film, Sal, Kunde, Forestilling


def lag():
    film = Film("Test", 90, 12)
    return Forestilling(film, Sal(1, 3), "12:00")


def test_vanlig_salg():
    b = lag().selg_billett(2, Kunde("Ola", 30))
    assert b.sete == 2 and b.pris == 130


def test_dobbeltsalg():
    f = lag()
    k = Kunde("Ola", 30)
    f.selg_billett(2, k)
    assert f.selg_billett(2, k) is None


def test_sete_finnes_ikke():
    assert lag().selg_billett(4, Kunde("Ola", 30)) is None


def test_barnepris():
    # Filmen har aldersgrense 12, så bruk en film uten grense her
    film = Film("Barnefilm", 80, 0)
    f = Forestilling(film, Sal(1, 3), "12:00")
    assert f.selg_billett(1, Kunde("Mia", 8)).pris == 90


def test_for_ung():
    with pytest.raises(ValueError):
        lag().selg_billett(1, Kunde("Mia", 8))


def test_inntekt():
    f = lag()
    f.selg_billett(1, Kunde("Ola", 30))
    f.selg_billett(2, Kunde("Kari", 40))
    assert f.inntekt() == 260

Metoden som får test_inntekt grønn:

    def inntekt(self):
        return sum(b.pris for b in self.billetter)
Utfordringer

Skriv kode (klasser med konstruktører) for dette diagrammet. Lag objekter og vis at det virker.

classDiagram
    Skole "1" *-- "*" Klasse
    Klasse "1" o-- "*" Elev
    Elev "*" --> "*" Fag

Komposisjon betyr at Skole lager klassene selv. Aggregering og assosiasjon betyr at objektene sendes inn.

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


class Elev:
    def __init__(self, navn):
        self.navn = navn
        self.fag = []          # mange-til-mange


class Klasse:
    def __init__(self, navn):
        self.navn = navn
        self.elever = []       # aggregering: eleven sendes inn

    def meld_inn(self, elev):
        self.elever.append(elev)


class Skole:
    def __init__(self):
        self.klasser = []

    def ny_klasse(self, navn):   # komposisjon: skolen lager klassen
        klasse = Klasse(navn)
        self.klasser.append(klasse)
        return klasse

Du modellerer elever og klasser. Er det best at Elev har attributtet klasse (ett objekt), at Klasse har en liste elever, eller begge deler? Begrunn med det du har lært om dobbeltlagring i 5.5.1.

Å ha begge gir rask tilgang fra begge sider, men det betyr at du må holde dem i takt: meldes en elev inn, må både eleven og klassen oppdateres, ellers blir dataene ulike. Har du bare listen i Klasse, finner du elevene i en klasse enkelt, men må lete gjennom alle klassene for å finne ut hvilken klasse en elev går i. Velg ut fra hva programmet trenger oftest, og er det begge, lag en metode (som meld_inn) som oppdaterer begge sider, slik at ingen kan glemme det.

Oppsummering

Relasjon blir attributt

class Forestilling:
    def __init__(self, film, sal):
        self.film = film       # -->
        self.billetter = []    # 0..*

Samarbeid

sete_antall = self.sal.antall_seter
billett = Billett(sete, self)
self.billetter.append(billett)

Eier du delene?

  • Komposisjon: lag dem inne i klassen
  • Assosiasjon og aggregering: send dem inn
  • En relasjon er et attributt som peker på et annet objekt.
  • Pek på objektet, ikke kopier opplysningene.
  • Hold begge sider av en toveis relasjon i takt.

6.6 Bruk det i prosjektene

6.7 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?

Du vil at print(film) skal skrive tittelen.
__str__. b) Et klasseattributt (PRIS_VOKSEN = 130). c) Innkapsling: privat attributt og kontroll i metodene (eller en setter). d) __lt__ (eller key). e) __eq__. f) @property.
Du vil at alle billetter skal dele samme voksenpris.
Du vil forhindre at en saldo blir negativ.
Du vil sortere filmer etter varighet med sorted.
Du vil at film1 == film2 skal være sann når tittel og varighet er like.
Du vil kunne skrive rektangel.areal uten parentes.

I Forestilling fra 6.5.2 ligger metoden er_ledig. Forklar hvorfor den ligger der og ikke i Billett eller Kunde, og hva som må endres hvis salen får et nytt sete-system (for eksempel rader og plasser).

Forestilling har billettene og salen, altså det som trengs for å avgjøre om et sete er ledig («den som har dataene, gjør jobben»). Skifter sete-systemet, endres bare er_ledig og Sal. Kunde og Billett påvirkes ikke, siden de ikke bryr seg om hvordan ledighet avgjøres.

Skriv klassen Spiller med navn og et privat helsepoeng (starter på \(100\)). Egenskapen helse kan leses, men ikke settes. Metoden ta_skade(n) trekker fra helse (aldri under \(0\)), og helbred(n) legger til (aldri over \(100\)). Negative verdier gir ValueError. Egenskapen er_levende er sann når helsen er over \(0\). __str__ gir Mia (helse: 80).

Bruk self._helse, og @property for helse og er_levende. I ta_skade: self._helse = max(0, self._helse - n).

Gitt klassen Spiller med navn og poeng. Skriv __lt__ (flest poeng først) og funksjonen toppliste(spillere, n) som gir tekstlinjene 1. Jon (75), 2. Eva (55) for de n beste, adskilt med "\n".

sorted(spillere)[:n], og enumerate(..., start=1) gir rangeringen. Husk at klassen må utvides med __lt__.

Se på klassen under og finn minst fire problemer eller forbedringer.

class Bruker:
    brukere = []

    def __init__(self, navn, alder, passord=[]):
        self.navn = navn
        self.alder = alder
        self.passord = passord
        brukere.append(self)

    def vis(self):
        print(self.navn, self.alder)

Se på standardverdien, lista brukere, passordet og vis.

  1. passord=[] er en liste som standardverdi, så alle brukere deler den. Bruk None eller lag lista i konstruktøren (og et passord bør uansett ikke være en liste).
  2. brukere.append(self) mangler klassenavnet. Det må være Bruker.brukere.append(self), ellers NameError.
  3. Passordet er et åpent attributt, så alle kan lese og endre det. Gjør det privat (_passord) og lag en metode som sjekker passordet, uten å gi det ut.
  4. alder kan få hvilken verdi som helst, også negativ. Bruk en egenskap med kontroll.
  5. vis skriver ut i stedet for å gi tekst. Lag __str__, så print(bruker) virker.

Velg et lite system (en bokhylle, et kortspill, en butikk). Tegn klassediagrammet (kapittel 5), og skriv klassene i Python med innkapsling, __str__ og minst én relasjon mellom klassene. Skriv minst fem tester med pytest.

Sjekk at diagrammet og koden stemmer overens (hver boks er en klasse, hver pil er et attributt, * er en liste), at attributtene er private der de må kontrolleres, at ugyldige verdier gir ValueError, og at testene dekker vanlige tilfeller, grensetilfeller og feil.

6.8 Oppsummering

Klasser og objekter

Klassen

class Film:
    PRIS = 130            # klasseattributt

    def __init__(self, tittel):
        self.tittel = tittel   # objektattributt

    def vis(self):
        print(self.tittel)

Objekter

dune = Film("Dune")
dune.vis()
print(dune.tittel)

Klassemetode

@classmethod
def fra_tekst(cls, tekst):
    return cls(tekst)

Innkapsling

Privat og kontrollert

self._saldo = 0

def ta_ut(self, belop):
    if belop > self._saldo:
        raise ValueError("...")
    self._saldo -= belop

Egenskap

@property
def temp(self):
    return self._temp

@temp.setter
def temp(self, verdi):
    # sjekk verdien
    self._temp = verdi

Spesialmetoder

Tekst

def __str__(self):
    return f"{self.tittel}"

def __repr__(self):
    return f"Film({self.tittel!r})"

Sammenligning

def __eq__(self, annen):
    if not isinstance(annen, Film):
        return NotImplemented
    return self.tittel == annen.tittel

def __lt__(self, annen):
    return self.varighet < annen.varighet

Objekter som samarbeider

Samlinger

filmer = [Film("A"), Film("B")]
oppslag = {f.tittel: f for f in filmer}

Relasjoner

self.film = film        # -->
self.billetter = []     # 0..*
  • self er alltid første parameter, og self.x = x lagrer.
  • Lag lister i __init__, aldri som standardverdi.
  • Sjekk først, endre etterpå, og bruk raise for ugyldige verdier.
  • Et objekt i en liste er ikke en kopi.