2.2 Gjenbruk, hjelpefunksjoner og meny/`main`-dispatcher

En funksjon du har definert, kan kalles hvor som helst senere i fila — også inne i kroppen til en annen funksjon. Det er ingen ny konstruksjon: det er akkurat det samme kallet som fra toppnivå.

Kravet er bare at funksjonen er definert før kallet kjøres. Siden alle def-ene i et program kjøres før main() kalles, kan funksjonene fritt kalle hverandre uansett rekkefølge i fila.

def snitt(priser):
    total = 0
    for p in priser:
        total = total + p
    return total / len(priser)

def er_dyrt_naa(priser, naa):
    return naa > snitt(priser)

doegn = [0.42, 0.55, 1.20, 0.98]
print(snitt(doegn))
print(er_dyrt_naa(doegn, 1.05))

Utskrift:

0.7875
True

er_dyrt_naa inneholder ingen løkke. Den låner løkka fra snitt — og blir én linje lang.

En hjelpefunksjon er en liten funksjon som ikke svarer på selve oppgaven, men som gjør en bit av arbeidet flere andre funksjoner trenger: snitt, finn_indeks, beregn_verdi.

Kjennetegnet er at den er kort, har et beskrivende navn og ikke skriver ut noe. Den returnerer, slik at den som kaller, bestemmer hva som skal skje med svaret.

Å innføre en hjelpefunksjon som oppgaven ikke ba om, er alltid tillatt og trekker aldri ned. Sensor sidestiller flere korrekte løsninger, og en oppdeling som gjør besvarelsen lettere å lese, er en fordel.

Står den samme kodesnutten to steder, er det en kopi. Kopier er dyre av tre grunner: de tar tid å skrive for hånd, de gir to steder å gjøre feil, og de gir ikke uttelling for gjenbruk.

Kjenn igjen kopien ved at du kan gi de to snuttene det samme navnet. Da er navnet funksjonen din, og de to stedene blir to kall.

Regelen i praksis: skriver du en løkke du har skrevet før i samme besvarelse, stopp og gi den et navn i stedet.

En kjede er en rekke funksjoner der utverdien fra den ene er innverdien til den neste. Kravet er at hvert ledd returnerer noe — et ledd som bare skriver ut, kan ikke ha et neste ledd.

På eksamen ser du kjeden i selve oppgaveteksten: «c) Skriv funksjonen finn_beste(tabell) som bruker les_inn_data fra deloppgave a)». Der er kjeden ikke et forslag, men et krav.

Klarte du ikke a)? Skriv likevel c) som om a) virket, og kall funksjonen. Sensor gir uttelling for riktig struktur i c) selv om a) mangler eller er feil.

Data som flere funksjoner trenger, sendes inn som parameter — ikke hentes på nytt inne i hver funksjon.

Det høres selvsagt ut, men den vanligste strukturfeilen i besvarelser er nettopp at hver funksjon åpner og leser fila på nytt. Da blir programmet tregt, og du har skrevet den samme innlesingskoden fire ganger.

Regelen, som du skal ha med deg til Del 7: main leser dataene én gang og sender dem videre. Alle analysefunksjonene tar dataene som parameter og returnerer et svar.

Den er ikke noe spesielt for Python — det er bare et navn, og du kaller den selv med main() nederst i fila. Boka bruker aldri vaktsetningen if __name__, fordi den ikke gir uttelling på eksamen.

Kjennetegnet på en god main er at den er kort og lesbar: hvert kall er ett ledd i kjeden, og du ser hele programmets gang på skjermen samtidig.

En main som inneholder løkker og regnestykker, har overtatt jobben til funksjonene under. Da er den vanskelig å lese, og deloppgavene kan ikke vurderes hver for seg.

Regelen: main delegerer. Den har data, kall og utskrift — ingen for-løkke som regner ut noe, ingen betingelse som avgjør et faglig spørsmål.

def main():
    priser = [0.42, 0.55, 1.20, 0.98]
    print('Høyeste:', hoyeste(priser))
    print('Snitt:', snitt(priser))

Utskrift: ingen — blokken definerer bare main. Kalles den, skriver den to linjer.

Fire linjer, og du ser hele programmet. Det er malen.

En konstant defineres helt til venstre i fila, utenfor alle funksjoner, og skrives med store bokstaver: GEBYR_PER_BOK = 30, MAKS_LAAN = 28.

Store bokstaver er ikke et krav fra Python — det er et signal til leseren om at verdien ikke endres underveis. Konstanten kan leses fritt inne i funksjonene, akkurat som beskrevet i kap. 2.1.

GEBYR_PER_BOK = 30

def gebyr(antall_forfalte):
    return antall_forfalte * GEBYR_PER_BOK

print(gebyr(3))

Utskrift:

90

Den andre formen er å sende konstanten inn som en parameter med standardverdi: def gebyr(antall, sats=30).

Fordelen er at funksjonen blir uavhengig av resten av fila og kan gjenbrukes med en annen sats. Ulempen er én parameter til å holde styr på.

def gebyr(antall_forfalte, sats=30):
    return antall_forfalte * sats

print(gebyr(3))
print(gebyr(3, 45))

Utskrift:

90
135

Begge former gir full pott. Arkivets løsningsforslag bruker begge — noen ganger en global liste over distrikter, andre ganger den samme lista sendt inn som argument. Velg én og vær konsekvent i besvarelsen.

break avslutter løkka umiddelbart og hopper til første linje etter den. Står break inne i en funksjon, fortsetter funksjonen etter løkka; det er return som avslutter selve funksjonen.

runde = 0
while True:
    runde = runde + 1
    print('Runde', runde)
    if runde == 3:
        break
print('Ferdig etter', runde, 'runder')

Utskrift:

Runde 1
Runde 2
Runde 3
Ferdig etter 3 runder

Her er tellevariabelen der bare for å vise mekanikken. I en ekte meny er det brukerens svar som avgjør når break kjøres.

Derfor testes menyvalg mot strenger: if valg == '1':. Testen if valg == 1: er ikke en feilmelding — den er noe verre, nemlig en test som alltid er usann, slik at menyen bare svarer «ugyldig valg» uansett hva brukeren gjør.

Vil du likevel ha et tall, konverterer du selv med int(valg) — men da må du først være sikker på at teksten faktisk er et tall, ellers krasjer programmet. Det er tema i kap. 1.4.

En dispatcher er koden som ser på valget og sender arbeidet videre til riktig funksjon. Det er en helt vanlig if/elif/else, men rollen er verdt et eget navn: dispatcheren skal bare fordele.

Hver gren består derfor av ett kall, eventuelt med en utskrift rundt. Regner grenene selv, har dispatcheren overtatt jobben til funksjonene — samme feil som en main som regner.

Grenene testes ovenfra og ned, og bare den første sanne kjøres. Rekkefølgen spiller derfor ingen rolle så lenge valgene er ulike.

Menyen trenger ett valg som betyr «ferdig». I dette faget skrives det som 'q' (for quit) eller '0', og det skal stå i menyteksten — brukeren kan ikke gjette.

Verdien som betyr «stopp», kalles en sentinel: en avtalt verdi som ikke er data, men et signal. Den samme ideen brukes når en løkke leser verdier til brukeren skriver tom tekst.

Avslutningsgrenen inneholder break, og gjerne en kort avskjedslinje før den.

Alt brukeren kan finne på å skrive, som ikke er et av valgene, havner i else. Der skriver du en kort beskjed og lar løkka gå en runde til — du skal ikke avslutte programmet fordi noen bommet på tasten.

Uten else skjer det ingenting synlig ved en skrivefeil: menyen dukker bare opp igjen, og brukeren tror programmet hang seg. Det er en av de tingene sensor ser etter i menyoppgaven, og den koster deg én linje.

1. skaff dataene — i Del 4 ved å lese en fil, her ved å ha en ferdig liste,
2. kall menyen eller kjeden, med dataene som argument,
3. la funksjonene gjøre resten.

Nederst i fila står main() alene, uten innrykk. Det er den ene linja som faktisk starter programmet — alt over er definisjoner som venter.