5.2 Innkapsling: underscore, aksessor og mutator

Prinsippet om at et objekt skal holde verdiene sine for seg selv, og at resten av programmet bare skal kunne snakke med det gjennom metodene.

Fordelen er ikke hemmelighold — det er kontroll. Går alle endringer gjennom en metode, kan objektet passe på at reglene holdes: at saldoen ikke blir negativ, at antall påmeldte ikke overstiger kapasiteten, at to ting som hører sammen, oppdateres samtidig.

Den andre fordelen merker du når noe skal endres. Bestemmer klassen seg for å lagre alderen som fødselsår i stedet, er det bare klassens egne linjer som må skrives om — alle som kaller hent_alder(), merker ingenting.

Konvensjonen som sier «denne verdien hører til objektet selv — ikke rør den utenfra». Instansvariabler skrives derfor self._tittel, ikke self.tittel.

Python håndhever ingenting. Understreken er et signal til andre som leser koden, og skrivemåten b._utlaant = True er fullt lovlig for Python. Den er likevel gal i dette kurset, og den er nummerert i bokas feilregister som #11
— direkte tilgang til en instansvariabel utenfra.

Regelen er enkel og mekanisk: inne i klassen skriver du self._x fritt.
Utenfor klassen rører du aldri noe som begynner med understrek.

En metode som leser en instansvariabel og gir verdien tilbake:

class Medlem:
    def __init__(self, navn):
        self._navn = navn

    def hent_navn(self):
        return self._navn

m = Medlem("Ada")
print(m.hent_navn())

Utskrift:

Ada

Kroppen er alltid én linje: return self._x. Ingen parametere utover self, fordi metoden ikke trenger noe utenfra.

Ordet aksessor betyr bare «lesemetode». Møter du det i en oppgavetekst, er det denne ene linjen som etterspørres.

En metode som endrer en instansvariabel til en verdi den får inn:

class Medlem:
    def __init__(self, navn):
        self._navn = navn

    def hent_navn(self):
        return self._navn

    def sett_navn(self, nytt):
        self._navn = nytt

m = Medlem("Ada")
m.sett_navn("Nora")
print(m.hent_navn())

Utskrift:

Nora

Mutatoren har alltid en parameter i tillegg til self — den nye verdien. En mutator uten parameter er en klassisk feil: den har ingenting å sette verdien til.

Ordet mutator betyr «endringsmetode». Noen oppgavetekster sier «sett-metode»
eller «endre-metode» om det samme.

Alle de offentlige metodene til en klasse, med navn og parametere — og ingenting annet.

Grensesnittet forteller hva du kan be objektet om, ikke hvordan det gjør det. Metodekroppene er ikke del av det, og instansvariablene er det heller ikke.

For klassen Rett fra Eksempel 2 er grensesnittet disse fire:

__init__(navn, pris)
hent_navn()
hent_pris()
sett_pris(ny_pris)

Blokken er merket som ikke-kjørbar fordi den er en oppstilling, ikke et program.
Legg merke til at self ikke er med: den fylles ut av Python og er ikke noe den som kaller, skal forholde seg til.

Prøvesteinen: kan en annen del av programmet skrive det, uten å bryte
konvensjonen? Da er det del av grensesnittet.

Navnet på en metode pluss parameterne den tar: sett_pris(ny_pris).

Signaturen er det den som kaller, trenger å vite — hva metoden heter, og hvor mange verdier den vil ha inn. Hva som skjer inni, er ikke signaturens sak.

I en eksamensbesvarelse skriver du gjerne grensesnittet som en liste av signaturer med en kort forklaring i naturlig språk bak hver:

hent_pris() - gir prisen i kroner sett_pris(ny_pris) - setter en ny pris

Det er nok. Oppgaven ber om signaturene, ikke om koden.

En mutator som sjekker verdien før den settes:

class Medlem:
    def __init__(self, navn):
        self._navn = navn self._alder = 0

    def sett_alder(self, ny):
        if ny < 0:
            print("Ugyldig alder")
        else:
            self._alder = ny

    def hent_alder(self):
        return self._alder

m = Medlem("Ada")
m.sett_alder(-3)
m.sett_alder(24)
print(m.hent_alder())

Utskrift:

Ugyldig alder
24

Mønsteret er alltid det samme: if på det ugyldige tilfellet, else som setter verdien. Skriv else-grenen, ikke bare if — en mutator som setter verdien uansett og bare skriver ut en advarsel, har ikke beskyttet noe.

Hva som skal skje ved en ugyldig verdi, sier oppgaveteksten. Sier den ingenting, skriv en kommentar om hva du har valgt.

De to sidene av et objekt. Offentlig er det andre kan bruke: metodene uten understrek. Privat er innsiden: instansvariablene med understrek.

I språk som Java håndheves skillet av kompilatoren. I Python er det en avtale — og en avtale som fasiten og sensor forholder seg til som om den var håndhevet.

Skillet er også en lesehjelp. Ser du et navn med understrek i en kodesnutt, vet du med én gang at det hører til innsiden, uten å lete etter hvor det kom fra.

Metoden som gir deg en verdi ut av objektet: def hent_x(self): return self._x.

Kjenn den igjen på tre trekk: navnet begynner med hent_ (eller er_ når svaret er sant eller usant), den har ingen parametere utover self, og kroppen er én
return-linje.

I en oppgavetekst dukker den opp som «skriv en metode som returnerer …» eller
«klassen skal ha aksessorer for …».

Metoden som endrer en verdi inne i objektet:
def sett_x(self, ny): self._x = ny.

Kjenn den igjen på at den alltid har en parameter i tillegg til self — den nye verdien. Uten den har den ingenting å sette.

Mutatorer kan være mer enn én linje. Skal klassen passe på en regel, står if og
else inne i mutatoren, ikke hos den som kaller.

Alle offentlige metoder til en klasse, med navn og parametere.

Instansvariablene er ikke med, heller ikke de som har en aksessor.
Metodekroppene er ikke med. self skrives ikke, fordi den som kaller, ikke oppgir den.

Testspørsmålet på eksamen har alltid samme svar: «er _kaffekopper del av grensesnittet?» — nei, men hent_kaffekopper() er det.

Det motsatte av grensesnittet: hvordan klassen gjør jobben sin. Kroppene til metodene og valget av instansvariabler.

Implementasjonen kan skrives helt om uten at noen merker det, så lenge grensesnittet er det samme. En klasse kan bytte fra å lagre et tall til å lagre en liste den summerer — så lenge hent_poeng() fortsatt gir et tall.

Det er den friheten innkapsling kjøper deg, og den er grunnen til at direkte tilgang utenfra er en så dyr vane.

En regel programmerere har blitt enige om, men som språket ikke håndhever.
Understreken er den viktigste i dette faget.

Andre konvensjoner du allerede følger: stor forbokstav på klassenavn, fire mellomrom innrykk, self som navn på den første parameteren.

At noe er en konvensjon, gjør det ikke valgfritt på eksamen. Fasiten følger dem, og en besvarelse som ikke gjør det, er vanskeligere å lese og gir dårligere uttelling.

Formen aksessoren tar når verdien er sann eller usann: er_utlaant(),
er_ledig(), er_full().

Den leses bedre enn hent_utlaant(), fordi kallet blir en påstand:
if bok.er_utlaant(): sier akkurat det den gjør. Begge former er riktige, og fasiten bruker begge.

Metoden returnerer True eller False, som Python skriver med stor forbokstav — verdt å huske til kortsvarsoppgavene.

Oppgaveteksten er oppskriften. «Prisen skal kunne oppdateres» betyr mutator;
«hver rett har et navn» betyr bare aksessor.

Skriv de metodene teksten ber om, og la resten være. En klasse med åtte unødvendige sett-metoder er ikke bedre enn en med to nødvendige — den er dårligere, fordi hver overflødig mutator åpner et hull i kontrollen.

Er teksten uklar, velg det som gir mening i domenet og skriv en kommentar om valget. Det er den ene legitime bruken av kommentarer i en besvarelse.

Mønsteret der mutatoren sjekker verdien før den settes:

    def sett_x(self, ny):
        if ny < 0:
            print("Ugyldig")
        else:
            self._x = ny

Blokken er en mal med plassholdernavn og er merket som ikke-kjørbar.

To ting avgjør om mønsteret er riktig skrevet: at else-grenen finnes (ellers settes verdien uansett), og at kantverdien er testet — > og >= gir ulikt svar når de to tallene er like.

Direkte tilgang til en instansvariabel utenfra: obj._x eller obj._x = verdi.

Feilen er stum. Python kjører linjen uten et pip, programmet gir riktig svar der og da, og det er nettopp derfor den er så lett å gjøre — og derfor sensor må se etter den.

Kostnaden kommer to steder: klassens egne regler hoppes over, og den delen av programmet faller sammen i det øyeblikket klassens innside endres.

Python har også en form med to understreker foran, som gjør navnet vanskeligere å nå utenfra.

Denne boka bruker den ikke, og fagets løsningsforslag gjør det heller ikke. Én understrek er konvensjonen i IN1000, og det er den formen sensor forventer.

Skriv self._navn, ikke self.__navn. Og bland den ikke med __init__, som har to understreker på begge sider fordi den er en spesialmetode.

Formen en eksamensoppgave ber om når den sier «skriv grensesnittet»: en liste av metodesignaturer med en kort forklaring i naturlig språk bak hver.

hent_pris()        - gir prisen i kroner sett_pris(ny)      - setter en ny pris

Blokken er en oppstilling, ikke et program, og er derfor merket som ikke-kjørbar.

Det er nok. Oppgaven ber om signaturene, ikke om kodene — og self skal ikke med, siden den som kaller, aldri oppgir den.

At objektet eier verdiene sine, og at omverdenen snakker med det gjennom metodene.

Gevinsten er tredelt: klassen kan passe på sine egne regler, den kan endres innvendig uten at noe annet må skrives om, og den som leser koden, ser med én gang hva som er ment å brukes utenfra.

Kostnaden er noen linjer ekstra. I den store oppgaven er de linjene poenggivende i seg selv, så regnestykket går alltid i din favør.

Å utelate mutatoren med vilje, slik at en verdi bare kan settes i konstruktøren.

Tittelen på en bok, materialet i en boks, nummeret på en kollektivrute: alle er verdier som ikke endrer seg etter at objektet er laget.

Låsingen er ikke synlig i koden som en egen linje — den er fraværet av en metode. Skriv gjerne en kommentar om at det er et valg, så leseren ikke tror du glemte den.

En aksessor trenger ikke å returnere en lagret verdi. Den kan regne ut svaret:

    def hent_ledige(self):
        return self._plasser - self._sykler

Blokken er et utdrag av en klasse og er merket som ikke-kjørbar.

For den som bruker klassen, er det ingen forskjell — og det er poenget.
Grensesnittet lover et tall, ikke en bestemt lagringsmåte. Å regne ut i stedet for å lagre er dessuten tryggere: verdien kan aldri komme i utakt med de to den bygger på.

Står det samme regnestykket to steder i klassen, legg det i en egen metode og kall den med self. foran.

        if antall > self.hent_ledige():

Blokken er et utdrag og er merket som ikke-kjørbar.

Gevinsten er at endringer gjøres ett sted. Skal ledige plasser senere regnes ut annerledes, treffer endringen begge stedene automatisk.

En kategori feil verdt å kjenne: koden kjører helt fint, og gir riktig svar, men bryter en konvensjon sensor ser etter.

Feilkode #11 er den viktigste. Andre i samme familie: instansvariabler uten understrek, klassenavn med liten forbokstav, aksessor som skriver ut i stedet for å returnere.

Fordi de ikke gir feilmelding, finner du dem ikke ved å teste. Du finner dem ved å lese gjennom besvarelsen med konvensjonene i hodet — bruk fem minutter på det til slutt.

Ferdigheten grensesnitt-spørsmålene måler: å se på en klasse og med én gang vite hva andre kan be den om.

Framgangsmåten er mekanisk. Stryk alt som begynner med understrek. Stryk metodekroppene. Det som står igjen — metodenavnene med parameterlistene — er grensesnittet.

Gjør du det på papir før du svarer, faller både «skriv grensesnittet» og «er
_x del av grensesnittet» av seg selv.

En liten skrivedetalj som er verdt å vite om: et navn som _navn skrevet uten kodemarkering kan bli feil formatert i tekst.

I denne boka står derfor alle Python-navn i kodemarkering — self._navn,
hent_pris(), __init__. På eksamen i Inspera er det ikke noe problem, for der skriver du koden i et kodefelt.

Regelen er verdt å ta med seg til egne notater: skriver du om kode i vanlig tekst, marker den som kode.

To objekter kan ha nøyaktig like verdier og likevel være helt forskjellige objekter.

Et bibliotek med to eksemplarer av «Sult» har to Eksemplar-objekter med samme tittel. Lånes det ene ut, er det andre fortsatt inne.

Dette er verdt å ha klart før kap. 5.4, der spørsmålet snus: når er to navn to objekter, og når er de to navn på det samme
objektet?

Den skrives uten self, som de andre: __init__(navn, kapasitet).

Noen oppgavetekster ber bare om «metodene klassen tilbyr». Ta konstruktøren med uansett; det trekker aldri, og glemmer du den, mister du en linje.

Slik konvensjonen viser seg i Oppgave 4, som er nesten halve eksamen.

Hver klasse du skriver, får instansvariabler med understrek, aksessorer for det oppgaven vil ha ut, og mutatorer bare der noe faktisk skal kunne endres. Når to klasser samarbeider, kaller den ene metoder på den andre — aldri
annet_objekt._x.

Det siste er den vanligste formen feilkode #11 tar i den store oppgaven, og den kommer for alvor i kap. 6.2.

Det er ikke sikkerhet. En understrek stopper ingen — verken en angriper eller en kollega med dårlig tid.

Det er ikke hemmelighold heller. Alle kan lese koden og se nøyaktig hvilke instansvariabler klassen har.

Det er arbeidsdeling: klassen tar ansvaret for sine egne regler, og resten av programmet slipper å kjenne dem. Klarer du å si det med egne ord på eksamen, har du grensesnitt-spørsmålet i boks.