5.4 Referansesemantikk

Det en variabel faktisk holder når den «inneholder» et objekt: en peker til hvor objektet ligger, ikke objektet selv.

Bildet som hjelper: objektet er et hus, variabelen er en lapp med adressen.
Kopierer du lappen, får du to lapper til samme hus — ikke to hus.

Konsekvensen ser du med én gang du endrer noe. Går du inn i huset via den ene lappen og maler stua, er stua malt også når du kommer inn via den andre.

Tilordningen kopierer referansen, ikke objektet. Etterpå peker begge variablene på den samme tingen:

class Kurv:
    def __init__(self):
        self._antall = 0

    def legg_i(self):
        self._antall = self._antall + 1

    def hent(self):
        return self._antall

a = Kurv()
b = a a.legg_i()
print(a.hent(), b.hent())

Utskrift:

1 1

Sammenlign med forkunnskapsboksen, der b = Kurv() laget et nytt objekt og svaret ble 1 0. Forskjellen er én linje, og den avgjør alt.

Regelen i én setning: Klassenavn(...) lager et nytt objekt, = mellom to
variabler gjør det ikke.

Framgangsmåten som løser hvert eneste flervalg om referanser: tegn objektene som bokser og variablene som piler inn i dem.

En tilordning b = a tegnes ved å la b-pilen peke der a-pilen peker. En tilordning b = Kurv() tegnes ved å lage en ny boks og la b peke på den.

Et metodekall som endrer en verdi, tegnes ved å endre tallet inne i boksen — pilene rører du ikke.

Tre tegn er nok: boks, pil, navn. Bruk to minutter på tegningen før du svarer, så faller de fleste spørsmålene av seg selv.

Å la en variabel peke på noe annet enn før: x = nytt_objekt.

Tre ting skjer, og det er den midterste folk overser:

- pilen fra x flyttes til det nye objektet,
- det gamle objektet endres ikke i det hele tatt,
- det gamle objektet lever videre hvis en annen variabel fortsatt peker på det.

Skillet er verdt å si høyt: x.sett_navn("Ada") endrer objektet;
x = Person("Ada") endrer pilen. Det første sees av alle som peker på objektet; det andre sees bare av x.

De to tingene som kan skje i en tilordning, og som avgjør hvert eneste flervalgsspørsmål:

class Boks:
    def __init__(self, tall):
        self._tall = tall

    def sett(self, nytt):
        self._tall = nytt

    def hent(self):
        return self._tall

a = Boks(1)
b = a a.sett(9)
print(a.hent(), b.hent())

a = Boks(5)
print(a.hent(), b.hent())

Utskrift:

9 9
5 9

Første print: a.sett(9) endret objektet, og begge navnene ser det.

Andre print: a = Boks(5) flyttet pilen fra a til et nytt objekt. b peker fortsatt på det gamle, som fremdeles har 9 i seg. Ingen verdi ble overskrevet — de to navnene peker bare ikke lenger på det samme.

En instansvariabel kan peke på et annet objekt, akkurat som en vanlig variabel:

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

    def hent_navn(self):
        return self._navn

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

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

    def hent_eier_navn(self):
        return self._eier.hent_navn()

ada = Eier("Ada")
k = Konto(ada)
print(k.hent_eier_navn())
ada.sett_navn("Ada Lovelace")
print(k.hent_eier_navn())

Utskrift:

Ada
Ada Lovelace

Kontoen fikk aldri beskjed om navneendringen — den peker på eier-objektet, og
leser navnet på nytt hver gang. Hadde konstruktøren i stedet lagret
self._eier_navn = eier.hent_navn(), ville kontoen hatt et gammelt navn liggende etter endringen.

Det er hele argumentet for å lagre objektreferanser og ikke rådata: modellen
holder seg i takt av seg selv.

Skal ett objekt holde mange andre, legges referansene i en liste eller en ordbok:

class Bok:
    def __init__(self, tittel):
        self._tittel = tittel

    def __str__(self):
        return self._tittel

class Hylle:
    def __init__(self):
        self._boker = []

    def sett_inn(self, b):
        self._boker.append(b)

    def antall(self):
        return len(self._boker)

sult = Bok("Sult")
h1 = Hylle()
h2 = Hylle()
h1.sett_inn(sult)
h2.sett_inn(sult)
print(h1.antall(), h2.antall())

Utskrift:

1 1

Legg merke til at det bare finnes én bok. Den ligger i to hyller samtidig,
fordi begge listene holder en referanse til det samme objektet. Endres boka, endres den begge steder.

Om det er ønsket eller ikke, avhenger av oppgaven. Poenget er at du vet at det er slik det virker.

Tall, tekster og sannhetsverdier kan ikke endres etter at de er laget.

x = x + 1 endrer ikke tallet — det lager tallet 6 og lar x peke på det. Det er en rebinding, ikke en endring.

a = 5 b = a a = a + 1 print(a, b)

s = "ru" u = s s = s + "te" print(s, u)

Utskrift:

6 5 rute ru

Derfor oppfører tall og tekster seg «som verdier» i praksis, selv om de teknisk sett er objekter. Lister, ordbøker og dine egne klasser kan derimot endres, og da blir delingen synlig.

Kort huskeregel: kan du endre den, merker du referansen. Kan du ikke, merker du den aldri.

Sammenlign de to tilfellene, med samme form på koden:

class Kurv:
    def __init__(self):
        self._n = 0

    def opp(self):
        self._n = self._n + 1

    def hent(self):
        return self._n

a = 5 b = a a = a + 1 print("tall:  ", a, b)

liste_a = [1]
liste_b = liste_a liste_a.append(2)
print("liste: ", liste_a, liste_b)

k1 = Kurv()
k2 = k1 k1.opp()
print("objekt:", k1.hent(), k2.hent())

Utskrift:

tall:   6 5 liste:  [1, 2] [1, 2]
objekt: 1 1

Første linje: tallene skiller lag. a = a + 1 er en rebinding.

Andre og tredje linje: lista og objektet følges av. append og opp endrer
tingen selv, og begge navnene ser det.

Det er nettopp fordi tall oppfører seg «snilt» at objektene overrasker. Ta med deg mistanken: er verdien noe som kan endres, er delingen synlig.

Regelen om at en variabel holder en peker til et objekt, ikke objektet selv.

Konsekvensen er den ene setningen hele kapitlet handler om: to variabler kan peke på det samme, og da sees enhver endring begge steder.

Ordet «semantikk» betyr her bare «hva tilordningen betyr». Alternativet, som noen språk har for enkelte typer, kalles verdisemantikk: der lager b = a en faktisk kopi. Python gjør aldri det av seg selv.

To eller flere navn på det samme objektet. Oppstår av b = a, av en
append(a), av et funksjonskall f(a) og av self._x = a.

Alias er ikke en feil — det er ofte nettopp det du vil ha, som når det samme medlemmet ligger i både medlemslista og ventelista.

Feilen er å glemme at det er et alias. Det er feilkode #15 for lister, og feilkode #2 for objekter — samme misforståelse i to drakter.

Å flytte en variabel til å peke på noe annet: x = nytt_objekt.

Det som ikke skjer: det gamle objektet endres ikke, og andre variabler som peker på det, merker ingenting.

Kjenn den igjen i koden på at det står et klassenavn med parentes, eller et annet variabelnavn, på høyre side av likhetstegnet — ikke et metodekall på venstre.

Foranderlige: lister, ordbøker og dine egne klasser. De kan endres, og da blir
delingen synlig.

Huskeregelen: er verdien noe du kan endre, må du tenke på hvem andre som peker på den. Er den ikke det, kan du la være.

Antall objekter er antall ganger et klassenavn står med parentes — ikke antall variabler, og ikke antall elementer i en liste.

Fire referanser i en liste kan være fire objekter, tre, eller ett.

Spørsmålet «hvor mange objekter er laget?» er et vanlig flervalg i Oppgave 2, og det tar ti sekunder når du vet hva du skal telle.

Metoden som løser hvert eneste referansespørsmål. En boks per objekt, en pil per variabel eller instansvariabel.

- b = a: la b-pilen peke der a-pilen peker.
- b = Klasse(): tegn en ny boks, la b peke på den.
- a.sett_x(5): skriv 5 inn i boksen a peker på. Rør ingen piler.

Bruk to minutter på tegningen før du svarer. Det er raskere enn å lese koden tre ganger.

Fordelen er at modellen holder seg i takt: leser du navnet med
self._eier.hent_navn(), får du alltid det gjeldende navnet.

Alternativet — å lagre self._eier_navn = person.hent_navn() i konstruktøren — gir en verdi som blir foreldet i det øyeblikket personen skifter navn. Det er en av de vanligste modelleringsfeilene i den store oppgaven.

Les det fra venstre: «hent eieren til kontoen, og spør den om navnet». Hvert punktum er ett steg videre.

Formen er ryddig så lenge kjeden er kort, og den er vanlig i fasiten. Blir den lang, sett resultatet i en hjelpevariabel underveis — det er lettere å spore, og det gir like god uttelling.

Når du kaller f(a), får funksjonen sin egen pil til det samme objektet.

Funksjonen kan derfor endre objektet — det sees av kalleren. Men den kan ikke
flytte kallerens pil: en tilordning inne i funksjonen treffer bare det lokale
navnet.

Skal funksjonen gi kalleren noe nytt å peke på, må den return-ere det, og kalleren må tilordne det selv.

Legges det samme objektet i to lister eller under to nøkler, finnes det fortsatt bare ett objekt.

Endring gjennom den ene samlingen sees gjennom den andre. len() teller referanser, ikke objekter.

Er det ønsket, er det en fordel: medlemslista og ventelista holder seg i takt av seg selv. Er det ikke ønsket, må du lage et nytt objekt med klassenavnet og parentes.

Et objekt forsvinner ikke når én variabel slutter å peke på det. Det lever så lenge noe peker på det.

Etter a = Boks(1), b = a, a = Boks(5) finnes to objekter: det nye som a peker på, og det gamle som b fortsatt holder.

Peker ingenting lenger på et objekt, rydder Python det bort av seg selv. Det er ingenting du trenger å gjøre — men det er verdt å vite at det ikke skjedde i eksempelet over.

Det klassiske eksamensspørsmålet: en funksjon som får inn to objekter og skal
«bytte» dem.

Bytter den pilene (hjelp = p; p = q; q = hjelp), skjer ingenting synlig utenfor — pilene er lokale.

Bytter den innholdet (leser begge verdiene og setter dem tilbake i motsatt rekkefølge med mutatorer), virker det, fordi objektene er delt.

Kommer mønsteret på eksamen, er spørsmålet nesten alltid «hva skrives ut etter kallet?», og det riktige svaret på pil-varianten er «ingenting er endret».

Referanse forvekslet med kopi. Den dyreste feilen i Oppgave 2.

Den har to former: å tro at b = a lager en kopi, og å tro at det gamle objektet er borte etter en rebinding.

Begge kureres av den samme tegningen. Tegn en boks du kan skrive i, og en pil du kan flytte — så blir det umulig å blande dem.

Scope-forvirring: å tro at en tilordning inne i en funksjon endrer noe utenfor.

I kap. 2.2 møtte du den for tall. Her er den den samme, bare med objekter: p = Bok("ny") inne i en funksjon flytter bare det lokale navnet.

Grensen går ved punktumet. p = ... er lokalt; p.sett_x(...) treffer objektet og sees utenfor.

Det kunne virket tryggere om Python kopierte alt. Det ville vært både tregt og upraktisk.

Tregt, fordi en kopi av et stort objekt koster tid og plass hver gang det sendes til en funksjon.

Upraktisk, fordi modellen din skal henge sammen: et medlem i ventelista skal
være det samme medlemmet som i medlemslista. Kopier ville gitt to versjoner som straks kom i utakt.

To objekter kan ha nøyaktig like verdier og likevel være to objekter.
Konto("Ada") to ganger gir to kontoer.

Identitet er «er dette det samme objektet?». Likhet er «har de samme
verdier?».

I Oppgave 2 spørres det nesten alltid om identitet. Formuleringene «peker på samme objekt», «er dette det samme» og «hvor mange objekter finnes» handler alle om det.

En ordbok kan ha flere nøkler som peker på det samme objektet, akkurat som en liste kan ha flere plasser.

d["speil"] = sal og d["kopi"] = sal gir to nøkler og ett objekt. Endres salen, sees det gjennom begge.

Omvendt kan ikke én nøkkel peke på to objekter: setter du inn på en nøkkel som finnes, overskrives den forrige referansen uten en advarsel.

En metode kan returnere et helt objekt, ikke bare et tall eller en tekst:
return self._eier.

Den som kaller, får da en referanse til det samme objektet — ingen kopi — og kan kalle metoder på det med en gang.

Standardformen på en søkemetode er return self._d[navn] hvis nøkkelen finnes, og return None ellers. Da kan kalleren teste med if svar != None:.

Et flervalgsspørsmål som står ubesvart, gir null poeng — akkurat som et galt svar. Det er ingen straff for å gjette.

Oppgave 2 er rundt ni poeng fordelt på fire spørsmål, så et blankt felt er to poeng gitt bort gratis.

Klarer du å utelukke to av fire alternativer, er gjetningen mellom de to resterende verdt halvparten av poengene i snitt. Kryss alltid av.

Snutten er felles, og de fire spørsmålene kommer typisk i denne rekkefølgen: hva skrives ut, hva peker en gitt variabel på nå, hvor mange objekter finnes, og et begrepsspørsmål om grensesnitt eller self.

Les hele snutten og tegn før du svarer på det første. Tegningen brukes til alle fire.

Og husk at spørsmålene rettes hver for seg: en bom på det første koster ikke de tre andre.

Rebinding er ikke en feil — den er ofte helt riktig.

Skal en sykkel flyttes til et annet stativ, er self._stativ = nytt_stativ inne i en mutator nettopp rebinding, og den er ønsket: instansvariabelen skal peke et nytt sted.

Feilen oppstår bare når du tror at en rebinding endrer objektet i stedet for pilen. Handlingen er den samme; det er forventningen som avgjør om den er riktig eller gal.