5.2 Spesialmetoder: `__str__`, `__add__`, `__mul__`

Spesialmetoden som sier hvordan instansen skal se ut når den skrives ut. Den tar ingen argumenter utenom self, og den skal returnere en streng — nesten alltid en f-streng.

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

    def __str__(self):
        return f'({self.x}, {self.y})'

Nå gir print(u) teksten (3, 4). Merk return: metoden skriver ikke ut noe selv. Det er print som skriver ut; __str__ bare leverer teksten.

En vanlig eksamensvariant er at teksten skal ha et bestemt format — to desimaler, enheter, eller polynomform. Da er __str__ stedet der formateringen hører.

Begge formene utløser samme metode. print(u) gjør først str(u) for å få tekst, og str(u) kaller u.__str__().

Det betyr at __str__ også virker inne i en f-streng, siden f-strenger gjør om verdiene til tekst: print(f'vektoren er {u}') gir «vektoren er (3, 4)».

Det finnes én form som ikke bruker __str__, og den overrasker alle første gang: skriver du ut en liste av objekter, får du den tekniske utskriften tilbake. Grunnen er at lister ber om __repr__, ikke __str__, for hvert element.

Søskenmetoden til __str__. Der __str__ er den pene teksten til mennesker, er __repr__ den tekniske utskriften Python bruker når ingen har spurt om noe pent — for eksempel for elementene i en liste.

Definerer du ikke __repr__, får du standardformen med klassenavn og minneadresse. Derfor ser en liste av objekter slik ut, selv når klassen har en fin __str__:

[<__main__.Vec2D object at 0x10907dfd0>, <__main__.Vec2D object at 0x10907df70>]

Adressene varierer fra kjøring til kjøring. På eksamen er __repr__ ikke pensum å skrive — men du bør kjenne igjen utskriften og vite at den betyr «her ble __str__ ikke brukt». Vil du skrive ut en liste med pen tekst, løkker du over den og skriver ut ett objekt av gangen.

Spesialmetoden som utløses av plusstegnet. u + v betyr u.__add__(v): venstre operand er self, høyre er other.

Metoden skal returnere resultatet av addisjonen — den skal ikke endre self. Etter w = u + v er u og v uendret, og w er noe nytt.

def __add__(self, other):
    return Vec2D(self.x + other.x, self.y + other.y)

Legg merke til at metoden lager en instans av sin egen klasse ved å skrive klassenavnet med parentes. Det er lovlig inne i klassen, og det er nettopp det som gjør resultatet til en fullverdig vektor.

Navnet man bruker på høyre operand i en aritmetisk spesialmetode. Det er ingen magi i navnet — def __add__(self, v): virker like godt — men other er konvensjonen, og sensor kjenner den igjen.

Inne i metoden har du tilgang til begge objektenes attributter: self.x er venstre operands x, og other.x er høyre operands. Det er hele grunnen til at du kan regne komponentvis.

En liten, men viktig detalj: other er antatt å være av samme klasse. Er den ikke det, får du en feilmelding fra innsiden av metoden, og det er ofte den feilmeldingen som avslører at du har blandet typer.

Regelen som gjør hele Løkke 2 og 3 forståelig: hver operator har en spesialmetode, og Python oversetter operatoren til et metodekall på venstre operand.

Spesialmetoden som utløses av gangetegnet: u * v betyr u.__mul__(v). Som for __add__ er venstre operand self.

Returtypen avhenger av hva oppgaven ber om, og det er den ene plassen i faget der «ny instans»-regelen har et unntak:

- Skalarmultiplikasjon (u * 3) skal gi en ny instans.
- Indreprodukt (u * v) skal gi et tall.

def __mul__(self, other):
    return self.x*other.x + self.y*other.y

Les oppgaveteksten nøye her. Står det «returner indreproduktet», skal det ut et tall; står det «returner produktet av vektoren og et tall», skal det ut en vektor.

Tallet du får ved å gange komponentvis og summere: $\mathbf{u}\cdot\mathbf{v} = u_xv_x + u_yv_y$ i planet, og med ett ledd mer i rommet.

At resultatet er et tall og ikke en vektor, er hele grunnen til at indreproduktet er unntaket fra «ny instans»-regelen. Navnet «skalarprodukt» sier det samme: produktet er en skalar.

Indreproduktet brukes til å måle vinkel og til å projisere. I eksamenssammenheng er det først og fremst en presis liten formel som er lett å implementere feil: pass på at du summerer produktene, og ikke ganger summene.

Funksjonen som svarer på «er dette objektet av denne klassen?». isinstance(other, Vec2D) er True hvis other er en Vec2D-instans, ellers False.

I __mul__ er den nøkkelen til å håndtere begge betydningene av gangetegnet:

def __mul__(self, other):
    if isinstance(other, Vec2D):
        return self.x*other.x + self.y*other.y
    else:
        return Vec2D(other*self.x, other*self.y)

Nå gir u * v et tall, og u * 3 en ny vektor. Merk at rekkefølgen u * 3 er den som virker: 3 * u treffer heltallets eget gangetegn, ikke din __mul__, og gir en feilmelding.

isinstance kommer igjen i kap. 5.3, der den brukes til å svare på om et objekt hører til en klasse eller en subklasse av den.

Måten boka lagrer polynomer: en liste der element $i$ er koeffisienten til $x^i$. Konstantleddet står først.

[2, 0, -1] er altså $2 - x^2$, og len(koeff) - 1 er graden.

Rekkefølgen er den viktige detaljen, og den er lett å snu feil vei. Kontrollen tar du i __call__: løkker du med enumerate over koeffisientene og summerer c*x**i, må konstantleddet ligge på indeks 0 for at regnestykket skal stemme.

Når de to objektene har forskjellig antall tall, må __add__ bygge et resultat som er like langt som den lengste. Mønsteret er tre steg:

1. Finn ut hvilken av de to listene som er lengst.
2. Lag en kopi av den, med lang[:] — ikke bare ny = lang, som ville gitt to navn på samme liste.
3. Løkk over den korteste og legg den oppå: ny[i] = ny[i] + kort[i].

Punkt 2 er feil #23 i bokas feilkatalog: to navn på samme liste. Uten kopien ville du endret koeffisientene i det ene av polynomene du la sammen, og det er en feil som er nesten umulig å finne etterpå.

Kjernekravet i sjanger G: en aritmetisk spesialmetode lager et nytt objekt og returnerer det. Formen er return Klassenavn(...) inne i klassen selv.

Grunnen er ikke pynt. Returtypen bestemmer hva du kan gjøre med resultatet etterpå — skrive det ut pent, gange det, legge det til noe mer, sende det inn i en funksjon som venter et slikt objekt.

Det ene unntaket i faget er indreproduktet, som skal gi et tall. Da er tallet det matematisk riktige svaret, og en instans ville vært galt.

Uttrykket regnes fra venstre: først u + v, så resultatet pluss w. Det andre plusstegnet kaller __add__ på resultatet av det første.

Derfor er kjeding den beste egensjekken på returtypen din. Virker u + v + w, returnerte du en instans; feiler det med «unsupported operand type(s)», returnerte du noe annet.

Samme resonnement gjelder alle kombinasjoner: (u + v) * 2, (p + q)(2), print(u + v). Alle krever at det første leddet har levert et fullverdig objekt.

Formateringsverktøyet du bruker inne i __str__. Prefikset f foran anførselstegnet gjør at alt i krøllparentes regnes ut og settes inn.

def __str__(self):
    return f'({self.x:.2f}, {self.y:.2f})'

Etter kolonet står formatspesifikasjonen: .2f gir to desimaler, 8.3f gir bredde 8 og tre desimaler, 3d gir et heltall i bredde 3.

Ber oppgaveteksten om et bestemt format — «skriv ut vektoren med to desimaler» — er det her det hører, ikke i print-kallet. Da får alle utskrifter av objektet samme form.

Returnerer __str__ noe annet — et tuppel, en liste, et tall — får du TypeError: __str__ returned non-string, og feilen kommer først i det du skriver ut objektet.

Nabofeilen er å bruke print inne i __str__ i stedet for return. Da skriver metoden ut teksten selv, returnerer None, og print(obj) skriver None etterpå.

Vil du bygge teksten i flere steg, er det helt greit: lag en lokal streng, bygg den opp med +=, og returner den til slutt.

De to betydningene av gangetegnet, og de skilles på typen til høyre operand:

- u * 3 — høyre operand er et tall. Resultatet er en ny vektor med alle komponenter ganget med 3.
- u * v — høyre operand er en vektor. Resultatet er ett tall, indreproduktet.

Skal klassen støtte begge, tester du med isinstance og har to grener i __mul__. Ber oppgaven bare om én av dem, skriver du bare den — sensor forventer kort kode, ikke maksimal fleksibilitet.

Python spør alltid venstre operand først når den møter en operator. u * 3 blir u.__mul__(3); 3 * u blir et spørsmål til heltallet 3, som ikke vet hva en Vec2D er.

Følgen i praksis: u * 3 virker, 3 * u gir TypeError: unsupported operand type(s) for *: 'int' and 'Vec2D'.

Regelen gjelder også for pluss. u + v bruker us __add__. Er u et tall og v et objekt, får du samme type feilmelding.

Fellen ligger i lister: skriver du ny = self.koeff og deretter endrer ny, endrer du samtidig self.koeff, fordi de to navnene peker på samme liste. Kopien self.koeff[:] er det som holder dem fra hverandre.

En rask kontroll når du har skrevet __add__: skriv ut operandene etterpå. Er de uendret, er du trygg.

Grunnen er at listen selv gjøres om til tekst, og listen ber om __repr__ for hvert element — ikke __str__.

Vil du skrive ut en liste av objekter pent, løkker du over den og skriver ut ett objekt av gangen:

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

    def __str__(self):
        return f'({self.x}, {self.y})'

for e in [Vec2D(1, 2), Vec2D(3, 4)]:
    print(e)

Utskrift:

(1, 2)
(3, 4)

Da er det __str__ som brukes, én gang per objekt.

Feilmeldingen når operatoren mangler en spesialmetode. Den er blant de mest lesbare i Python, fordi den navngir både operatoren og de to typene: «for +: 'Vec2D' and 'Vec2D'» betyr at klassen mangler __add__.

Bruk meldingen som en diagnose:

- Navngir den din klasse på begge sider, mangler spesialmetoden.
- Navngir den 'tuple' eller 'list' på én side, har en tidligere metode returnert feil type — nesten alltid feil #4.
- Navngir den 'int' først, står tallet på feil side av operatoren.

Mønsteret for å skrive 1 + 2*x + 5*x**2 fra en koeffisientliste, med tre valg som må tas bevisst:

1. Hopp over nuller — if c == 0: continue. Ellers får du 0*x med i teksten.
2. Skilletegn før neste ledd, ikke etter — legg til + bare hvis strengen ikke er tom. Da slipper du et hengende plusstegn til slutt.
3. Tre former for eksponenten — indeks 0 gir bare tallet, indeks 1 gir c*x, resten gir c*x**i.

Oppgaveteksten avgjør det eksakte formatet. Blir det ikke helt likt fasitens, koster det lite — det er strukturen i __str__ som gir uttellingen.