6.3 Algoritme-metoder i klasser

Du kunne klart deg med én, ved å skrive if e.hent_verdi() > beste.hent_verdi():
— men da må beste allerede peke på noe i første runde, og på en tom samling stopper programmet.

To variabler er dessuten raskere å lese, og de gjør fasiten lettere å rette. Det er formen fagets egne løsningsforslag bruker.

Den vanligste feilen er å oppdatere bare den ene. Glemmer du
beste_verdi = e.hent_verdi(), blir grensen stående på 0, og løkka ender med det
siste elementet over 0 i stedet for det største.

Kan verdiene være negative, er 0 for høyt: et element med verdien -3 ville aldri blitt valgt, og metoden ville returnert None på en samling som ikke er tom.

Da er svaret å la den første runden sette startverdien:

        beste = None for e in self._elementer:
            if beste == None or e.hent_verdi() > beste.hent_verdi():
                beste = e

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

I denne boka er verdiene nesten alltid tellinger, så 0 holder — men det er verdt å nevne valget i en kommentar hvis oppgaven åpner for negative tall.

Idiomet, nå med objekter i stedet for rådata:

class Bok:
    def __init__(self, tittel, forfatter, utlaan):
        self._tittel = tittel self._forfatter = forfatter self._utlaan = utlaan

    def hent_forfatter(self):
        return self._forfatter

    def hent_utlaan(self):
        return self._utlaan

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

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

    def utlaan_per_forfatter(self):
        d = {}
        for b in self._boker:
            f = b.hent_forfatter()
            if f not in d:
                d[f] = 0 d[f] = d[f] + b.hent_utlaan()
        return d

bib = Bibliotek()
bib.legg_til(Bok("Sult", "Hamsun", 3))
bib.legg_til(Bok("Vaar", "Undset", 7))
bib.legg_til(Bok("Markens grode", "Hamsun", 5))
print(bib.utlaan_per_forfatter())

Utskrift:

{'Hamsun': 8, 'Undset': 7}

Tre faste deler: ordboka opprettes før løkka, if f not in d: og
d[f] = 0 før du legger til, og return etter løkka.

Uten if-sjekken stopper programmet med KeyError på den første boka — feilkode
#14.

Varianten der verdien er en liste i stedet for et tall:

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

    def hent_tittel(self):
        return self._tittel

    def hent_forfatter(self):
        return self._forfatter

boker = [Bok("Sult", "Hamsun"), Bok("Vaar", "Undset"), Bok("Pan", "Hamsun")]
d = {}
for b in boker:
    f = b.hent_forfatter()
    if f not in d:
        d[f] = []
    d[f].append(b.hent_tittel())
print(d)

Utskrift:

{'Hamsun': ['Sult', 'Pan'], 'Undset': ['Vaar']}

Forskjellen fra telleren er to tegn: [] i stedet for 0, og .append(...) i stedet for +.

Kjenn det igjen i oppgaveteksten på «lag en ordbok fra … til en liste over …»
eller «grupper etter …».

Mønsteret for «finnes det …?» og «er alle …?»:

class Sal:
    def __init__(self, navn, ledige):
        self._navn = navn self._ledige = ledige

    def hent_ledige(self):
        return self._ledige

class Senter:
    def __init__(self):
        self._saler = []

    def legg_til(self, s):
        self._saler.append(s)

    def finnes_ledig(self):
        for s in self._saler:
            if s.hent_ledige() > 0:
                return True return False

    def alle_fulle(self):
        for s in self._saler:
            if s.hent_ledige() > 0:
                return False return True

sen = Senter()
sen.legg_til(Sal("A", 0))
sen.legg_til(Sal("B", 3))
print(sen.finnes_ledig(), sen.alle_fulle())

Utskrift:

True False

«Finnes det …?» returnerer True inne i løkka og False etter. «Er alle
…?» returnerer False inne i løkka og True etter.

Retur-etter-løkka-linjen er obligatorisk. Glemmer du den, gir metoden None
når løkka går helt gjennom — og None oppfører seg som usant i en if, så feilen er stum.

Å snu de to — returnere True inne i en «er alle»-sjekk — er feilkode #7, for tidlig retur.

Mønsteret for «legg til bare hvis den ikke allerede er der»:

class Klubb:
    def __init__(self):
        self._navn = []

    def meld_inn(self, n):
        if n in self._navn:
            print(n, "er allerede medlem")
        else:
            self._navn.append(n)

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

k = Klubb()
k.meld_inn("Ada")
k.meld_inn("Nora")
k.meld_inn("Ada")
print(k.antall())

Utskrift:

Ada er allerede medlem
2

For en liste brukes if n in self._navn:. For en ordbok er problemet borte av seg selv: en nøkkel kan bare finnes én gang — men da overskrives den gamle verdien uten et pip, så sjekken kan likevel være nødvendig.

Skal du sjekke duplikater blant objekter, sammenlign en verdi de har, ikke objektene selv: if navn in self._navn: der self._navn er en liste av navn, eller en løkke som spør hvert objekt.

Mønsteret for «hvor godt passer disse to sammen?»: tell positive treff, trekk fra negative.

mine = ["sjakk", "kolonier", "ordjakt"]
dine = ["kolonier", "yatzy", "sjakk"]
poeng = 0 for spill in mine:
    if spill in dine:
        poeng = poeng + 1 else:
        poeng = poeng - 1 print(poeng)

Utskrift:

1

To treff og ett bom gir 1. Formen er en akkumulator med to grener, og den er lett å utvide: ulik vekt på treff og bom, eller bare positive poeng.

Kjenn den igjen i oppgaveteksten på «regn ut hvor godt to … passer sammen» eller
«gi ett poeng for hver felles …».

En metode på toppen av modellen som regner ut noe av samlingen: finn den travleste, tell de ulike, avgjør om noe finnes.

Den er ofte den høyest vektede deloppgaven i Oppgave 4, og den er der de vanskelige poengene ligger — resten av modellen er mønstre du kan skrive uten å tenke.

Alle formene er de samme løkkemønstrene fra del 3, flyttet inn i en klasse.

To variabler før løkka, samlet oppdatering inne i den, return etter.

beste holder elementet, beste_verdi holder verdien du sammenligner med.
Oppdaterer du bare den ene, ender løkka med det siste elementet over grensen i stedet for det største.

Det er den vanligste stumme feilen i hele Del 6, fordi metoden fortsatt returnerer noe som ser fornuftig ut.

Fordi løkka må se hele samlingen før den kan svare hvem som er best.

Et return inne i løkka gir det første elementet over grensen. Det er feilkode #7, for tidlig retur, og den kommer igjen i hvert eneste flagg-mønster.

Unntaket er «finnes det …?»-mønsteret, der et tidlig return True er nettopp det riktige — men da må return False stå etter løkka.

Kan verdiene være negative, er 0 for høyt: metoden ville svart None på en samling som ikke er tom. Da lar du første runde sette startverdien, med
if beste == None or ….

Er alle verdiene null, gir > og startverdi 0 også None. Dokumentér valget i en kommentar hvis oppgaven åpner for det.

Da kan den som kaller, spørre videre: travleste_sal().hent_navn() eller
travleste_sal().hent_paameldte(). Returnerer metoden bare navnet, er det et blindspor.

Unntaket er når oppgaveteksten uttrykkelig ber om navnet. Les hva den spør etter.

Nøkkelen og verdien hentes med metodekall på underobjektene: b.hent_forfatter() og b.hent_utlaan().

Uten if-sjekken stopper programmet med KeyError på den første nøkkelen — feilkode #14.

Telleren med to tegn byttet ut: [] i stedet for 0, og .append(...) i stedet for +.

Resultatet er en ordbok fra nøkkel til liste:
{'Hamsun': ['Sult', 'Pan']}.

Kjenn det igjen i oppgaveteksten på «lag en ordbok fra … til en liste over …»
eller «grupper etter …».

Formen den tyngste deloppgaven ofte har: bygg et regnskap i én løkke, og les det i en annen.

Å prøve å gjøre begge deler i samme løkke er både vanskeligere og lettere å bomme på — og det gir ingen ekstra poeng.

Legg gjerne den første løkka i sin egen metode, og kall den med self. foran.
Da kan begge delene brukes hver for seg, og deloppgavene rettes uavhengig.

«Finnes det …?»: return True inne i løkka, return False etter.
«Er alle …?»: return False inne, return True etter.

Å bytte om de to er feilkode #7: en «er alle»-sjekk som returnerer True på det første treffet, svarer ja så snart ett element passer.

Linjen etter løkka er obligatorisk. Glemmer du den, gir metoden None, og
None oppfører seg som usant i en if — så feilen er stum.

Mønsteret for «gjør noe med det første elementet som passer, og si fra hvis ingen gjør det».

ferdig = False før løkka, betingelsen if … and ferdig == False:, og
ferdig = True etter handlingen.

Alternativet er return inne i løkka. Flagget brukes når metoden skal gjøre noe
etter løkka — og det er formen fagets egne løsningsforslag bruker for
prioritert innsetting.

Rekkefølgen elementene ligger i, er prioriteringen. Første ledige i lista blir valgt.

Skal prioriteringen være en annen enn innsettingsrekkefølgen, oppgir oppgaven som regel en egen liste å løpe over.

Kombinert med ferdig-flagget er dette «sett inn i første ledige plass»-mønsteret som går igjen i settene.

For en liste må du sjekke selv. For en ordbok er problemet borte — men da
overskrives den gamle verdien uten et pip, så sjekken kan likevel trengs.

Skal du telle ulike verdier, bygg en liste over dem du har sett, og returner
len(...).

En akkumulator med to grener: + 1 for hvert treff, - 1 for hvert bom.

        poeng = 0 for x in self._mine:
            if annet.liker(x):
                poeng = poeng + 1 else:
                poeng = poeng - 1 return poeng

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

Regnestykket er ikke symmetrisk: det går over dette objektets liste. A mot
B og B mot A kan gi ulike svar. Les oppgaveteksten for å se hvilken vei den ber om.

Uten den blir elementet sammenlignet med seg selv, og det gir alltid full match — så svaret blir alltid «seg selv».

Det er et selvstendig poeng i den typen oppgave, og det er lett å glemme under tidspress.

At metoden ikke tåler en tom eller minimal samling.

Tre spørsmål tar de fleste trekkene: hva svarer metoden på tom samling, på
ett element, og på to like store?

Finn-beste gir None på tom samling — riktig, men den som kaller, må sjekke.
> beholder den første av to like, >= den siste.

Det ærlige svaret når en metode ikke finner noe: en tom samling, eller ingen som oppfyller kravet.

Den som kaller, tester med if svar != None:. Gjør du ikke det, stopper programmet med
AttributeError: 'NoneType' object has no attribute 'hent_navn'.

Den feilmeldingen er verdt å kjenne igjen: den betyr nesten alltid at et søk ga
None og at sjekken manglet.

Én linje ekstra gjør resten mye lettere å lese — og å rette. Det gir ingen ekstra poeng i seg selv, men det reduserer sjansen for skrivefeil betraktelig.

Samme teknikk brukes når en lenket kjede blir lang: del den opp med en variabel underveis.

Gevinsten er at regnskapet bygges ett sted. Endrer du hvordan det regnes, treffer endringen begge metodene.

Navnene må være ulike. En metode som kaller en metode med samme navn, ser ut
som om den kaller seg selv — og det er rekursjon, som er utenfor pensum i dette emnet.

Python har max(..., key=...), sorted(...), sum(...) og ferdige tellere som løser flere av mønstrene på én linje.

Denne boka bruker dem ikke, og det er et bevisst valg. Fagets egne
løsningsforslag skriver den eksplisitte løkka, fordi det er løkka som er ferdigheten kurset måler.

Og fordi den eksplisitte formen er den eneste som virker når oppgaven ber om noe en ferdig funksjon ikke dekker — som å telle poeng med to grener, eller å hoppe over elementet selv.

Nøkkelen eller verdien? Objektet eller navnet? Antallet eller elementet?

Feilen er lett å gjøre i en finn-beste-løkke, der du har begge deler liggende:
return beste gir elementet, return beste_verdi gir tallet.

Les siste setning i oppgaveteksten en gang til før du skriver return. Det tar fem sekunder og redder et helt poeng.