5.3 `__str__` og pen objektutskrift

Spesialmetoden som returnerer en tekst som beskriver objektet. Python kaller den automatisk når objektet skal skrives ut.

Navnet har to understreker på hver side, som __init__, og du kaller den aldri selv:

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

    def __str__(self):
        return self._tittel + " (" + str(self._aar) + ")"

b = Bok("Sult", 1890)
print(b)

Utskrift:

Sult (1890)

Metoden har self som eneste parameter, og den returnerer — den skriver ikke ut. Bruker du print inni i stedet for return, går det galt på en måte som forklares i advarselen lenger nede.

De to måtene __str__ blir kalt på — begge automatisk, ingen av dem av deg.

print(objekt) kaller __str__ og skriver resultatet. str(objekt) kaller
__str__ og gir deg teksten, slik at du kan bruke den videre:

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

    def __str__(self):
        return "Bok: " + self._tittel

b = Bok("Sult")
linje = str(b)
print(linje + " | " + str(b))

Utskrift:

Bok: Sult | Bok: Sult

Det er dette som gjør __str__ mer verdt enn en skriv-metode: teksten kan brukes til noe. Du kan skjøte den, sammenligne den eller legge den i en liste.

En vanlig metode som skriver ut i stedet for å returnere:

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

    def skriv(self):
        print(self._tittel, self._aar)

b = Bok("Sult", 1890)
b.skriv()

Utskrift:

Sult 1890

Navnet er fritt — skriv, skriv_ut, vis. Metoden returnerer ingenting, og verdien kan derfor ikke brukes videre.

Legg merke til komma i print-kallet. Komma skiller argumentene med ett
mellomrom og konverterer tall automatisk, så du slipper både + og str(...).
Det er den store praktiske forskjellen fra __str__, der du må skrive begge deler selv.

Ber oppgaven om «en metode som skriver ut objektet», er dette svaret. Ber den om
«at objektet kan skrives pent ut med print», er svaret __str__.

Løkka over en ordbok gir deg nøklene. Objektet henter du med et oppslag:

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

    def __str__(self):
        return "Bok: " + self._tittel

boker = {}
boker["sult"] = Bok("Sult")
boker["vaar"] = Bok("Vaar")
for n in boker:
    print(n, "->", boker[n])

Utskrift:

sult -> Bok: Sult vaar -> Bok: Vaar

Rekkefølgen følger den de ble satt inn i. Verdien boker[n] er et helt vanlig objekt, så print kaller dets __str__ som før.

Nøkkelen er ofte navnet, og verdien objektet. Da har du både oppslag og
gjennomløping i samme struktur — derfor er ordboka så vanlig i Oppgave 4.

En metode med to understreker på hver side av navnet, som Python kaller automatisk — du kaller den aldri selv.

I denne boka finnes bare to: __init__, som kjører når objektet lages, og
__str__, som kjører når objektet skal bli tekst.

Blander du dem, er symptomet lett å kjenne igjen: skriver du __str__ der
__init__ skulle stått, får objektet ingen verdier i det hele tatt.

At en klasse ber et underobjekt om å gjøre jobben, i stedet for å gjøre den selv.

I dette kapitlet er jobben utskrift: Bibliotek lar hver Bok vise seg selv med sin egen __str__. Senere delegeres også telling, søk og oppdatering.

Kjennetegnet i koden er en løkke der kroppen er ett kall på et underobjekt, og ingen felt hentes ut. Det motsatte — at ytterklassen graver i underobjektets verdier — er både dårligere kode og dårligere uttelling.

En metode i denne boka kaller aldri en metode med samme navn — verken på seg selv eller på et underobjekt.

Elementet har skriv(), containeren har skriv_alle(). Elementet har
antall_spill(), containeren har totalt_antall_spill().

Regelen har to grunner: navnene beskriver ulike jobber, og en metode som ser ut som om den kaller seg selv, ligner på rekursjon, som er utenfor pensum i dette emnet.

Når en oppgave oppgir hvordan utskriften skal se ut, er formatet en del av oppgaven og rettes deretter.

Skriv formatet av på papir før du koder, og marker hvert mellomrom, hvert skilletegn og hver parentes. Rute 20: Blindern - Toyen (14 passasjerer) inneholder fem slike detaljer.

Er formatet ikke oppgitt, velger du selv — men velg noe som er lett å lese, og hold det likt for alle objektene av samme klasse.

Skillet som avgjør om en metode skal bruke return eller print.

En metode som lager en tekst, returnerer den, og den som kaller, bestemmer hva som skjer videre. En metode som viser noe, skriver ut, og da er saken avgjort.

__str__ er alltid av den første typen. Det er nettopp derfor den er mer verdt enn en skriv-metode: teksten kan legges i en liste, skjøtes med annen tekst eller sammenlignes.

Det Python viser når en klasse mangler __str__: klassenavnet og et sekskantsifret tall, som <__main__.Bok object at 0x104a2f130>.

Tallet er hvor objektet ligger i maskinens minne, og det er forskjellig hver gang programmet kjøres. Derfor kan en slik utskrift aldri være fasit i en sporingsoppgave.

Ser du den i din egen kjøring, betyr det bare at klassen mangler __str__.

Skal __str__ sette sammen mange biter, blir linjen lang. To ryddige måter:

Sett parenteser rundt hele uttrykket og del over flere linjer — Python leser innholdet i en parentes som én sammenhengende linje. Eller bygg teksten i steg med en lokal variabel og returner den til slutt.

Begge er like riktige. Velg den som gjør formatet lettest å kontrollere mot bestillingen.

Pythons ord for «ingen verdi». Skrives ut med stor forbokstav.

Du møter den to steder i dette kapitlet: som returverdi fra en metode som glemte
return, og som ærlig svar fra en søkemetode som ikke fant noe.

Det siste er riktig og ønsket. return None når et søk mislykkes, er bedre enn å returnere en tom tekst — den som kaller, kan da sjekke med if svar != None:.

En klasse hvis viktigste jobb er å holde mange objekter av en annen klasse:
Bibliotek med bøker, Klubb med medlemmer, Senter med saler.

Den kjennes igjen på tre trekk: en samling i konstruktøren ([] eller {}), en
legg_til-metode, og én eller flere metoder som løper gjennom samlingen.

Hver eneste Oppgave 4 inneholder minst én slik klasse. Mønsteret er derfor verdt å kunne i fingrene, og det bygges ferdig i
kap. 6.2.

Valget avgjøres av ett spørsmål: skal du slå opp på et navn eller et nummer?

Er svaret ja, bruk en ordbok med det navnet som nøkkel og objektet som verdi. Er svaret nei — du skal bare gå gjennom alle — er en liste enklere.

En ordbok kan aldri ha to like nøkler. Legger du inn samme navn to ganger,
overskrives det første objektet uten en advarsel. Det er verdt å huske både
når du koder og når du sporer.

Formen containeren bruker når objektet selv vet hva det heter:
self._saler[sal.hent_navn()] = sal.

Containeren spør altså objektet i stedet for å bestemme navnet selv. Alternativet
self._saler[sal._navn] = sal er feilkode #11, direkte tilgang til en instansvariabel utenfra.

Dette er den vanligste formen feilkode #11 tar når to klasser samarbeider — og den vanligste i den store oppgaven.

Uten sjekken stopper programmet på en nøkkel som ikke finnes, og siste linje i feilmeldingen er KeyError med nøkkelen som mangler. Det er feilkode #14.

Standardformen på en søkemetode er derfor tredelt: sjekk, returner objektet hvis det finnes, og returner None ellers.

Derfor endrer utskriften seg av seg selv når objektet endres — du trenger ikke å kalle noe for å «oppdatere» teksten.

Det er også grunnen til at __str__ aldri skal lagre noe i en instansvariabel.
Metoden skal lese og returnere, ingenting annet.

Les verbet i oppgaveteksten.

«Objektet skal kunne skrives pent ut med print» eller «gi klassen en metode som gjør objektet utskrivbart» betyr __str__.

«Skriv en metode som skriver ut opplysningene om …» betyr en vanlig
skriv-metode.

Er du i tvil, skriv __str__ — den kan alltid brukes av en skriv-metode etterpå, mens det ikke går den andre veien.