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
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.
Etter å ha arbeidet med kapittelet skal du kunne
@property,__str__, __repr__, __eq__ og __lt__,Her lager du din første klasse og dine første objekter.
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.
Etter dette delkapittelet skal du kunne
class og konstruktøren __init__,self er,Vi skriver klassen Film fra kinomodellen. Den har attributtene tittel og 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.__init__, og første parameter er alltid self.self.navn = verdi.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.
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:
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.
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:
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.
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): |
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).
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).self som første parameter i metoder og konstruktør.tittel = tittel i stedet for self.tittel = tittel. Da blir ikke verdien lagret i objektet.self.tittel når du mener parameteren, eller omvendt, inne i __init__.__init__.Film.tittel i stedet for dune.tittel).return i en metode som skal gi et svar, slik at du får None.dune.vis_info).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.
golf.beskriv() sender golf inn som self.
Først Golf: 500 kr, så 900.
golf.beskriv() sender golf inn som self.
To objekter (golf og tesla) og én klasse (Bil).
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.
Se på første parameter i begge metodene, og på linjen som lagrer nummeret.
__init__ mangler self som første parameter.nummer = nummer lagrer ikke noe i objektet. Det skal stå self.nummer = nummer.er_stor mangler self som parameter.er_stor bruker self, som ikke finnes når parameteren mangler.Riktig:
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.
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)")
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.
En klasse
Delene
__init__: kjører ved opprettelseself: objektet selvself.x: attributt i objektetself er alltid første parameter, men du sender den ikke selv.self.tittel = tittel lagrer. tittel = tittel gjør ikke det.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.
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.
Etter dette delkapittelet skal du kunne
self,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.
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.
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).
self.: self.solgte, self.er_ledig(sete).self. er det en vanlig variabel eller funksjon, og Python finner den ikke i objektet.__init__, slik at alle objekter har dem fra første stund.Konstruktøren kan ha parametere med standardverdi, akkurat som vanlige funksjoner (se 3.1.1):
500 900
Men vær forsiktig med lister. En liste som standardverdi lages én gang, når funksjonen defineres, og deles mellom alle objektene:
['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:
['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.
self.: er_ledig(sete) i stedet for self.er_ledig(sete). Du får NameError.__init__. Alle objektene deler den.self. foran attributtet når du endrer det: verdi += 1 i stedet for self.verdi += 1.return i en metode som skal gi svar.__init__. Da har ikke alle objekter dem, og du får AttributeError.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.
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)
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
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.
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.
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.
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.
self. foran attributter og metoder i objektet.__init__, aldri som standardverdi.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.
Etter dette delkapittelet skal du kunne
self,Et klasseattributt skrives direkte i klassen, utenfor metodene. Det finnes bare én gang, og deles av alle objekter av klassen.
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).
self.sete = sete i __init__): hvert objekt har sin egen verdi.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.
Klasseattributter brukes ofte til å telle eller gi nummer til objekter. Her får hver sykkel et unikt serienummer:
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).
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:
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.
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:
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).
self.antall += 1 i stedet for Klasse.antall += 1, så telleren aldri endres.@classmethod over klassemetoden, eller cls som første parameter.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.
For hvert attributt i en klasse Elev: skal det være objektattributt eller klasseattributt?
navn
Kan to objekter ha ulik verdi?
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?
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.
Hva lager self.antall += 1?
0.
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.
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.
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).
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.
Hvilken type?
self.xKlasse.xself.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.
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.
Etter dette delkapittelet skal du kunne
ValueError ved ugyldige verdier,Her er en konto uten beskyttelse:
-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.
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.
self._saldo.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.
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:
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.
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.
print i stedet for raise når verdien er ugyldig. Da fortsetter programmet som om ingenting har skjedd.self.saldo noen steder og self._saldo andre steder.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.
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.
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().
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?
Konto(-100): konstruktøren sjekker ikke startsaldoen.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?
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å.
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.
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.
Kontrollert endring
Trygg konstruktør
Sjekk verdiene også i __init__.
raise, ikke print, for ugyldige verdier.- i UML er understrek i koden.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.
Etter dette delkapittelet skal du kunne
@property,@navn.setter,@property over en metode gjør at du kan bruke metoden uten parentes, som om det var et attributt:
500
Vi skriver k.saldo, ikke k.saldo(). Siden vi ikke har laget noen setter, kan saldoen leses men ikke endres utenfra:
AttributeError: property 'saldo' of 'Konto' object has no setter
I UML kan en slik skrivebeskyttet egenskap skrives + saldo: float {readOnly}.
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.
@property) og setter (@navn.setter) har samme navn.self.navn = verdi i konstruktøren, så setteren kjøres også da.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.
En egenskap trenger ikke ha et lagret attributt bak seg. Den kan regnes ut hver gang den leses:
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.
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?
self.temp = temp i en setter). Det gir uendelig rekursjon. Bruk self._temp i setteren.@temp.setter eller å skrive et annet navn enn egenskapen.k.saldo()). Den er ikke en metode lenger.self._temp = temp i konstruktøren, så setteren (og kontrollen) hoppes over.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.
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.
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?
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).
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.
Endre med kontroll
self.navn = verdi i konstruktøren, så setteren kjører.self._navn, aldri i self.navn inni setteren.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.
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.
Etter dette delkapittelet skal du kunne
__str__ som gir en lesbar tekst for brukeren,__repr__ som gir en tydelig tekst for programmereren,__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.
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.
__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__:
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.
__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.return.__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}".
Punkt(3, 4)
[Punkt(3, 4), Punkt(0, 0)]
Startpunkt: Punkt(3, 4)
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'.
Det er lett å komme i skade for å skrive print inni __str__ i stedet for return:
Da skriver print(objekt) først tittelen, og så krasjer Python med TypeError: __str__ returned non-string (type NoneType). Metoden må gi tilbake teksten.
print i stedet for return i __str__ eller __repr__.str(...)._str_ eller str.self som parameter.__repr__ som ikke viser verdiene, så feilsøking blir vanskelig.__str__ til å vise intern informasjon brukeren ikke skal se.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.
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)
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).
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.
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.
return en tekst, ikke print.__str__, bruker Python __repr__.__repr__ ser helst ut som koden som lager objektet.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?
Etter dette delkapittelet skal du kunne
== og is for objekter,__eq__ som sammenligner innholdet,__lt__ slik at lister av objekter kan sorteres,key til å sortere etter ulike egenskaper.Uten __eq__ er == det samme som is: bare det samme objektet er likt seg selv.
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.
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.
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
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.
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:
[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.
__eq__(self, annen) styrer == og in. Sammenlign innholdet.__lt__(self, annen) styrer <, sorted, min og max. Gi True hvis self kommer først.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]
== sammenligner innholdet uten __eq__. Standard er identitet.__eq__, så sammenligning med en tekst krasjer.__lt__ som gir tekst eller tall i stedet for True eller False.<= eller > i __lt__, så sorteringen blir feil for like objekter.__eq__ og __lt__ må ha self og annen som parametere.is når du mener ==.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.
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.
__eq__. b) __lt__. c) __lt__ (sorterer ved å bruke <). d) __eq__ (sjekker likhet med hvert element).[Ola, Mia, Kari] og Kari. Elevene sorteres etter alder, yngst først, og max gir den eldste.
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.
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.
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.
eq
__eq__ er == det samme som is.__lt__ gir True eller False.key= når du trenger flere måter å sortere på.Et program består sjelden av ett enkelt objekt. Her ser du hvordan du arbeider med mange objekter, og hvordan objekter kan bruke hverandre.
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.
Etter dette delkapittelet skal du kunne
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.
17.0
Det kan også skrives sum(e.alder for e in elever) / len(elever).
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:
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.
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:
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:
[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.
liste * 3 med et objekt og tro at du får tre ulike objekter.None når et søk ikke finner noe: finn_film(...).tittel krasjer med AttributeError på None.film når du mener film.tittel, så du sammenligner et objekt med en tekst.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.
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.
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].
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.
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?
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.Søke, filtrere, sortere
[objekt] * 3 gir tre navn på samme objekt.None når et søk kan mislykkes.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.
Etter dette delkapittelet skal du kunne
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.
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:
f.selg_billett(12, ola) kalles med et sete og et kundeobjekt.self.film.aldersgrense. Den spør filmen, den kopierer ikke tallet.self.er_ledig(sete) bruker salen (self.sal.antall_seter) og billettene som allerede er solgt.Billett som peker tilbake på forestillingen og kunden, og husker den i self.billetter.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.
A --> B blir et attributt i A som peker på et B-objekt: self.film = film.* blir en liste: self.billetter = [].self.sal.antall_seter, kunde.billetter.append(...).forestilling, trenger den ikke også tittel og tidspunkt.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.
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).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.
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.
self.tittel = film.tittel i stedet for self.film = film). Da kan de bli ulike.None før du leser attributtene dets.__repr__ som skriver ut hele objektgrafen.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.
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.
Hvilke av disse bør lages inne i klassen (komposisjon), og hvilke sendes inn?
Hus.
Bil.
Bil (som finnes bare som del av bilen).
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.
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.
Nå skal du bygge kinomodellen i VS Code, slik du gjør i prosjektene.
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.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)).python -m pytest i terminalen, og se at alle er grønne.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).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() == 260Metoden som får test_inntekt grønn:
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 klasseDu 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.
Relasjon blir attributt
Samarbeid
Eier du delene?
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?
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.
sorted.
film1 == film2 skal være sann når tittel og varighet er like.
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.
Se på standardverdien, lista brukere, passordet og vis.
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).brukere.append(self) mangler klassenavnet. Det må være Bruker.brukere.append(self), ellers NameError._passord) og lag en metode som sjekker passordet, uten å gi det ut.alder kan få hvilken verdi som helst, også negativ. Bruk en egenskap med kontroll.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.
self er alltid første parameter, og self.x = x lagrer.__init__, aldri som standardverdi.raise for ugyldige verdier.