Skip to main content

4  Feilsøking og testing

Ingen programmerer skriver et program som virker første gang. Feil er en vanlig del av arbeidet, og det som skiller en god programmerer fra en nybegynner, er hvor raskt og systematisk hen finner dem, og hvor godt hen sørger for at de ikke kommer tilbake. Dette kapittelet handler om akkurat det.

Du lærer å skille mellom ulike typer feil og lese det Python forteller deg, å håndtere feil med try og except og utløse dem med raise, å finne feil systematisk med utskrifter og debuggeren, og å teste koden din med assert og pytest. Til slutt ser du på testdrevet utvikling, der du skriver testen før koden. Dette er kompetansemålet om å vurdere og bruke strategier for feilsøking og testing av programkode.

Debuggeren (4.3.2) og pytest (4.4.2) gjør du i VS Code. De andre delkapitlene kan du gjøre i boka og i notatboka i nettleseren.

Notatboka har flere oppgaver, som rettes med sjekk(). Den kan brukes i nettleseren eller i VS Code.

Læringsmål

Etter å ha arbeidet med kapittelet skal du kunne

  • skille mellom syntaksfeil, kjøretidsfeil og logiske feil, og lese en feilmelding fra Python,
  • fange unntak med try og except, og utløse dem med raise,
  • finne feil systematisk, med utskrifter og med debuggeren i VS Code,
  • skrive tester med assert og pytest,
  • bygge en funksjon i små steg ved å skrive testene først.

4.1 Typer feil

Før du kan rette en feil, må du vite hva slags feil det er. Her lærer du å lese det Python forteller deg.

4.1.1 Syntaksfeil, kjøretidsfeil og logiske feil

Alle som programmerer, gjør feil, og det hele tiden. Forskjellen på en nybegynner og en erfaren programmerer er ikke at den erfarne gjør færre feil, men at hen finner dem fortere. Det første skrittet er å vite hva slags feil det er snakk om, for da vet du også hvor du skal lete. Python hjelper deg: i de fleste tilfeller forteller den nøyaktig hva som gikk galt og hvor. Du må bare lære å lese det den sier.

Læringsmål

Etter dette delkapittelet skal du kunne

  • skille mellom syntaksfeil, kjøretidsfeil og logiske feil,
  • lese en feilmelding fra Python: feiltype, melding, linjenummer og kallekjeden,
  • kjenne igjen de vanligste unntakene og hva som ofte forårsaker dem,
  • finne logiske feil ved å sammenligne det du forventer, med det programmet faktisk gir.

Tre typer feil

Tenk deg at du gir noen en oppskrift. Den kan ha tre slags feil: stavefeil så ingen forstår den, en instruks som er umulig å utføre, eller en oppskrift som lages uten feil, men gir en dårlig kake. Slik er det i programmering også.

RegelDe tre typene feil
  • Syntaksfeil: Python forstår ikke koden, fordi den bryter reglene for språket. Programmet starter aldri.
  • Kjøretidsfeil: Koden er gyldig og programmet starter, men krasjer underveis fordi noe ikke lar seg gjøre. Python gir en feilmelding (et unntak).
  • Logisk feil: Programmet kjører uten feilmelding, men gir feil svar. Python ser ingenting galt, for koden gjør nøyaktig det du ba den om.

Syntaksfeil oppdager Python før den kjører noe. Her mangler det et kolon:

  File "/Users/kari/it2/f1.py", line 2
    if alder >= 18
                  ^
SyntaxError: expected ':'

En annen vanlig syntaksfeil er feil innrykk:

  File "/Users/kari/it2/f2.py", line 2
    print("Hei")
    ^^^^^
IndentationError: expected an indented block after function definition on line 1

Kjøretidsfeil kommer først når koden kjøres. Her er de du kommer til å møte oftest:

DefinisjonVanlige unntak
  • NameError: du bruker et navn som ikke finnes, ofte en skrivefeil eller en variabel du ikke har laget ennå.
  • TypeError: en operasjon passer ikke til typen, for eksempel "17" + 1.
  • ValueError: typen er riktig, men verdien passer ikke, for eksempel int("abc").
  • IndexError: du ber om et element utenfor lista, for eksempel liste[3] når lista har tre elementer.
  • KeyError: du slår opp en nøkkel som ikke finnes i ordboken.
  • ZeroDivisionError: du deler på null.
  • AttributeError: objektet har ikke metoden du prøver å bruke, for eksempel "hei".append("!").
  • FileNotFoundError: filen du prøver å åpne, finnes ikke.

Logiske feil gir ingen melding, så de er vanskeligst å finne. Programmet under skal regne ut gjennomsnittet av to tall:

a = 8
b = 5
snitt = a + b / 2
print(snitt)
10.5

Programmet kjører fint, men svaret er \(10{,}5\) i stedet for \(6{,}5\). Divisjon regnes ut før addisjon, så parentesene mangler. Ingen advarsel, ingen krasj: du oppdager feilen bare fordi du vet hva svaret burde vært.

Hvilken type feil er dette, og hvordan merker du den?

  1. print("Hei)
  2. liste = [1, 2, 3] og print(liste[5])
  3. Et program som skal summere tallene fra \(1\) til \(10\), men bruker range(1, 10) og gir \(45\).

Starter programmet? Krasjer det? Gir det riktig svar?

  1. Syntaksfeil. Anførselstegnet er aldri lukket, så Python kan ikke lese koden og programmet starter ikke.

  2. Kjøretidsfeil (IndexError). Koden er gyldig, men lista har bare indeks \(0\), \(1\) og \(2\), så programmet krasjer på den linja.

  3. Logisk feil. Programmet kjører og gir et svar, men range(1, 10) stopper før \(10\), så summen blir \(45\) i stedet for \(55\). Du merker det bare ved å sammenligne med det du forventet.

Å lese en feilmelding

En feilmelding fra Python kalles en traceback, og den har alltid samme oppbygning. Her deler snitt på lengden av en tom liste, og feilen skjer to funksjoner inne i programmet:

Traceback (most recent call last):
  File "/Users/kari/it2/f10.py", line 9, in <module>
    print(rapport([]))
          ~~~~~~~^^^^
  File "/Users/kari/it2/f10.py", line 6, in rapport
    return f"Snitt: {snitt(data)}"
                     ~~~~~^^^^^^
  File "/Users/kari/it2/f10.py", line 2, in snitt
    return sum(tall) / len(tall)
           ~~~~~~~~~~^~~~~~~~~~~
ZeroDivisionError: division by zero

Slik leser du den:

  1. Les siste linje først. ZeroDivisionError: division by zero sier hva som gikk galt: feiltypen og en kort melding.
  2. Se på linja rett over. Den viser hvor feilen oppstod: fila, linjenummeret (line 2) og selve koden.
  3. Gå oppover for å se hvordan du kom dit. Linjene over viser hvilke funksjoner som kalte hverandre: først print(rapport([])) på linje \(9\), så rapport som kalte snitt på linje \(6\), og til slutt divisjonen på linje \(2\).
RegelLes en traceback

Les nedenfra og opp. Siste linje sier hva, linja over sier hvor, og resten viser veien dit. Pilene (^^^^) peker på delen av linja som feilet.

Merk at Python viser stedet der feilen oppdages, og det er ikke alltid der den skapes. Her oppdages feilen i snitt, men den virkelige årsaken er at rapport ble kalt med en tom liste. Funksjonen snitt er egentlig ikke feil, den kan bare ikke gi et gjennomsnitt av ingenting. Hvor du retter, avhenger av hva som er riktig: skal tom liste gi None, en feilmelding, eller skal den aldri skje?

Traceback (most recent call last):
  File "/Users/kari/it2/prisliste.py", line 7, in <module>
    print(pris_for("melk"))
          ~~~~~~~~^^^^^^^^
  File "/Users/kari/it2/prisliste.py", line 4, in pris_for
    return priser[vare]
           ~~~~~~^^^^^^
KeyError: 'melk'
  1. Hvilken feiltype er det?
  2. På hvilken linje oppstod feilen, og i hvilken funksjon?
  3. Hva er sannsynlig årsak?

Les siste linje, og se så på linja like over.

  1. KeyError.

  2. På linje \(4\), i funksjonen pris_for. Den ble kalt fra linje \(7\).

  3. Ordboken priser har ikke nøkkelen 'melk'. Enten mangler varen i ordboken, eller navnet er skrevet feil. Du kan unngå feilen med priser.get(vare) eller ved å sjekke if vare in priser.

Å finne logiske feil

Siden logiske feil ikke gir noen melding, finner du dem ved å sammenligne. Du må vite hva svaret skal bli. En god vane er å teste med så enkle tall at du kan regne svaret ut i hodet:

def maks_av_to(a, b):
    if a > b:
        return b
    return a

print(maks_av_to(3, 8))
print(maks_av_to(9, 2))
3
2

Funksjonen skal gi det største tallet. Med \(3\) og \(8\) burde svaret vært \(8\), men programmet skriver \(3\). Det er nok til å se at noe er galt: sammenligningen er snudd, så funksjonen gir det minste. Å teste med enkle tall og kjente svar er første steg i å finne en logisk feil, og i resten av kapittelet lærer du å gjøre det systematisk.

AdvarselVanlige feil
  • Å gjette på årsaken i stedet for å lese feilmeldingen. Feilmeldingen forteller som regel det du trenger.
  • Å lese tracebacken fra toppen. Start nederst.
  • Å ignorere linjenummeret. Gå til linja og les nøye, også linja før (en manglende parentes viser seg ofte på neste linje).
  • Å tro at «ingen feilmelding» betyr «riktig». Logiske feil gir ingen melding.
  • Å endre flere ting samtidig. Da vet du ikke hva som hjalp.
  • Å glemme å lagre fila før du kjører programmet på nytt.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Si om hver feil er en syntaksfeil, en kjøretidsfeil eller en logisk feil.

for i in range(5) uten kolon på slutten.

Syntaksfeil hindrer at programmet starter. Kjøretidsfeil krasjer. Logiske feil gir bare feil svar.

Syntaksfeil (SyntaxError).

int("tolv")

Syntaksfeil hindrer at programmet starter. Kjøretidsfeil krasjer. Logiske feil gir bare feil svar.

Kjøretidsfeil (ValueError).

Programmet skal regne ut arealet av en sirkel, men bruker diameteren i stedet for radiusen, og gir et svar som er for stort.

Syntaksfeil hindrer at programmet starter. Kjøretidsfeil krasjer. Logiske feil gir bare feil svar.

Logisk feil. Programmet kjører og gir et svar, bare feil.

print(tall) før variabelen tall er laget.

Syntaksfeil hindrer at programmet starter. Kjøretidsfeil krasjer. Logiske feil gir bare feil svar.

Kjøretidsfeil (NameError).

En if-blokk der innrykket er forskjellig på to linjer.

Syntaksfeil hindrer at programmet starter. Kjøretidsfeil krasjer. Logiske feil gir bare feil svar.

Syntaksfeil (IndentationError).

Tracebacken er

Traceback (most recent call last):
  File "/Users/kari/it2/snitt.py", line 12, in <module>
    print(rapport(karakterer))
  File "/Users/kari/it2/snitt.py", line 8, in rapport
    return gjennomsnitt(liste)
  File "/Users/kari/it2/snitt.py", line 3, in gjennomsnitt
    return sum(liste) / len(liste)
ZeroDivisionError: division by zero
På hvilken linje i fila oppstod selve feilen?
På hvilken linje i fila ble rapport kalt?
Nivå 2

Hva er sannsynlig årsak til hver av disse feilmeldingene, og hvordan retter du den?

NameError: name 'sumen' is not defined

Se på navn, typer og verdier som er nevnt i meldingen.

Navnet er skrevet feil (sumen i stedet for summen), eller variabelen er ikke laget. Rett skrivemåten.

TypeError: can only concatenate str (not "int") to str

Se på navn, typer og verdier som er nevnt i meldingen.

Du prøver å legge et tall til en tekst. Gjør tallet om til tekst med str(), eller teksten om til tall med int().

IndexError: list index out of range

Se på navn, typer og verdier som er nevnt i meldingen.

Du ber om et element som ikke finnes. Sjekk indeksen og lengden på lista: den siste indeksen er len(liste) - 1.

AttributeError: 'str' object has no attribute 'append'

Se på navn, typer og verdier som er nevnt i meldingen.

append finnes bare på lister, men variabelen er en tekst. Sjekk hvilken type variabelen har.

ValueError: invalid literal for int() with base 10: 'abc'

Se på navn, typer og verdier som er nevnt i meldingen.

Teksten "abc" lar seg ikke gjøre om til et heltall. Sjekk at inndataene er tall, eller fang feilen (se neste delkapittel).

Funksjonen gjennomsnitt gir ZeroDivisionError fordi den får en tom liste fra rapport. Gi to ulike måter å rette programmet på, og si hvilken du foretrekker.

Du kan rette i gjennomsnitt eller i koden som kaller den.

  1. Rett i gjennomsnitt: sjekk if len(liste) == 0 og gi None (eller et unntak med en tydelig melding). (2) Rett i rapport eller koden før: sørg for at lista aldri er tom, eller hopp over rapporten når det ikke finnes data. Jeg foretrekker (1) fordi funksjonen da er trygg uansett hvem som kaller den, og så tilpasser kallerne seg svaret. Men hvis en tom liste egentlig er en feil i resten av programmet, er det også viktig å finne ut hvorfor lista ble tom.
Kodeoppgaver

Disse oppgavene rettes automatisk. Hver av dem har en feil du skal finne og rette. Les feilmeldingen eller sammenlign med det programmet skal gi.

Programmet skal skrive Voksen hvis alderen er minst \(18\), men gir en syntaksfeil. Rett det.

En if-linje skal avsluttes med kolon.

Programmet gir NameError. Rett det.

Sammenlign navnene på variablene i øverste og siste linje.

Programmet skal skrive Du er 17 år, men gir en TypeError. Rett det.

Bruk en f-streng, eller gjør tallet om til tekst med str(alder).

Programmet skal skrive ut det siste tallet i lista, men gir IndexError. Rett det.

Indeksene starter på \(0\). Den siste er \(3\), eller bruk \(-1\).

Programmet skal summere tallene fra \(1\) til \(10\), men skriver \(45\). Rett det.

Stoppverdien i range er ikke med.

Utfordringer

Lag funksjonen lag_indeksfeil() som får Python til å kaste en IndexError, og lag_typefeil() som kaster en TypeError. Du skal ikke bruke raise.

[1, 2, 3][5] gir IndexError, og "a" + 1 gir TypeError. Pakk uttrykket inn i en funksjon.

Programmet skal regne ut gjennomsnittet av tre tall og skrive det ut med to desimaler, men har flere feil. Rett dem alle.

Det er to feil. Les først feilmeldingen, og rett den. Sjekk så om svaret er riktig.

Oppsummering

Tre typer feil

  • Syntaksfeil: koden er ugyldig, programmet starter ikke.
  • Kjøretidsfeil: programmet krasjer med et unntak.
  • Logisk feil: feil svar, ingen melding.

Les en traceback

  1. Siste linje: hva
  2. Linja over: hvor
  3. Oppover: hvordan du kom dit

Vanlige unntak

NameError   TypeError   ValueError
IndexError  KeyError
ZeroDivisionError
AttributeError
FileNotFoundError

Finne logiske feil

Test med enkle tall der du kjenner svaret, og sammenlign.

  • Les alltid feilmeldingen først, nedenfra og opp.
  • Python viser der feilen oppdages, ikke alltid der den skapes.
  • Endre én ting om gangen, og kjør på nytt.

4.2 Unntak og unntakshåndtering

Noen feil kan du ikke unngå, som at brukeren skriver noe ugyldig. Her lærer du å fange unntak og å utløse dem selv.

4.2.1 try og except

Programmet spør brukeren om en alder, og brukeren skriver abc. Da krasjer int("abc") med en ValueError, og hele programmet stopper. Det er dårlig opplevelse for brukeren. Heller enn å la programmet krasje kan vi fange feilen og gjøre noe fornuftig: be om et nytt svar, bruke en standardverdi, eller fortelle hva som gikk galt.

tekst = "abc"

try:
    alder = int(tekst)
    print("Alderen er", alder)
except ValueError:
    print("Det der var ikke et tall")

print("Programmet fortsetter")
Det der var ikke et tall
Programmet fortsetter

Programmet krasjer ikke. Linja int("abc") feiler, men feilen blir fanget, og programmet fortsetter videre.

Læringsmål

Etter dette delkapittelet skal du kunne

  • bruke try og except til å fange unntak og la programmet fortsette,
  • fange bestemte typer unntak, og hente ut feilmeldingen med as,
  • bruke else og finally,
  • forklare hvorfor vi ikke fanger alle feil med en tom except.

try og except

Kode som kan feile, legger du i en try-blokk. Hvis det oppstår et unntak der, hopper Python rett til except-blokken. Skjer det ingen feil, hoppes except-blokken over.

Definisjontry og except
try:
    # kode som kan feile
except ValueError:
    # kjøres hvis det oppstår en ValueError

Når en linje i try-blokken feiler, kjøres ikke resten av blokken. Python går rett til except.

Legg merke til at resten av try-blokken hoppes over når feilen oppstår. I eksempelet over ble aldri print("Alderen er", alder) kjørt, siden int(tekst) feilet først.

Lag funksjonen til_heltall(tekst) som gir tallet teksten inneholder, eller None hvis teksten ikke er et heltall.

Prøv int(tekst) i en try-blokk, og fang ValueError.

def til_heltall(tekst):
    """Gir teksten som heltall, eller None."""
    try:
        return int(tekst)
    except ValueError:
        return None

print(til_heltall("42"))
print(til_heltall("abc"))
print(til_heltall("3.5"))
42
None
None

"42" gir \(42\). "abc" og "3.5" kan ikke gjøres om til heltall, så funksjonen gir None.

Fange bestemte unntak

Du bør alltid si hvilket unntak du fanger. Hvert unntak har en type, og du kan ha flere except-blokker for ulike typer. Med as får du tak i selve unntaket, og kan skrive ut meldingen:

def del_trygt(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("Du kan ikke dele på null")
        return None
    except TypeError as f:
        print("Feil type:", f)
        return None

print(del_trygt(10, 2))
print(del_trygt(10, 0))
print(del_trygt(10, "2"))
5.0
Du kan ikke dele på null
None
Feil type: unsupported operand type(s) for /: 'int' and 'str'
None

Første kall virker. Andre kall deler på null og fanges av første except. Tredje kall prøver å dele på en tekst, og fanges av andre except, der f er unntaket. Python sjekker except-blokkene ovenfra og ned og kjører den første som passer.

Vil du fange flere typer på samme måte, kan du skrive dem i en parentes: except (ValueError, TypeError):.

RegelFang bare det du venter

Skriv alltid typen: except ValueError:. En tom except: (eller except Exception:) fanger alle feil, også de du ikke har tenkt på, som en skrivefeil i variabelnavnet. Da skjuler du feil som burde ha blitt oppdaget. Fang de unntakene du vet kan komme og vet hva du skal gjøre med.

Se hva som skjer når du fanger for mye. Her skal funksjonen gi gjennomsnittet, men det er en skrivefeil i koden:

def snitt(tall):
    try:
        return sum(tall) / len(tal)
    except:
        return 0

print(snitt([2, 4, 6]))
0

Svaret er \(0\), og du får ingen feilmelding. Den virkelige feilen er en NameError (tal i stedet for tall), men den tomme except har skjult den. Hadde vi fanget bare ZeroDivisionError, ville skrivefeilen blitt oppdaget med en gang.

else og finally

I tillegg kan en try ha to valgfrie deler:

  • else kjøres bare hvis det ikke oppstod noe unntak.
  • finally kjøres alltid, uansett om det gikk bra eller ikke. Den brukes til å rydde opp, for eksempel lukke en fil.
def prov(tekst):
    try:
        tall = int(tekst)
    except ValueError:
        print("Ikke et tall")
    else:
        print("Tallet er", tall)
    finally:
        print("Ferdig med", tekst)

prov("7")
prov("sju")
Tallet er 7
Ferdig med 7
Ikke et tall
Ferdig med sju

For "7" kjøres else og så finally. For "sju" kjøres except og så finally. Linja i finally kommer begge ganger. Å legge koden som skal kjøres hvis alt gikk bra, i else og ikke i try, gjør at du bare fanger feil fra den koden du faktisk vil beskytte.

def f(x):
    try:
        print("A")
        y = 10 / x
        print("B")
    except ZeroDivisionError:
        print("C")
    else:
        print("D")
    finally:
        print("E")

f(2)
f(0)

Gå gjennom hvert kall for seg. Når x er \(0\), feiler divisjonen, og resten av try-blokken hoppes over.

def f(x):
    try:
        print("A")
        y = 10 / x
        print("B")
    except ZeroDivisionError:
        print("C")
    else:
        print("D")
    finally:
        print("E")

f(2)
f(0)
A
B
D
E
A
C
E

For f(2) går alt bra: A, B, så else (D) og finally (E). For f(0) skrives A, så feiler divisjonen, så B hoppes over. except skriver C, else hoppes over, og finally skriver E.

Unntak i praksis

Det vanligste bruksområdet er å sjekke det brukeren skriver inn. En vanlig mønster er å spørre om og om igjen til svaret er gyldig. Siden input ikke kan kjøres i kodecellene i boka, ser du det som vanlig kode:

while True:
    tekst = input("Hvor gammel er du? ")
    try:
        alder = int(tekst)
        break
    except ValueError:
        print("Skriv et heltall.")

Løkka fortsetter til int(tekst) virker. Da hopper break ut. Hvis brukeren skriver noe annet, fanges ValueError, og hen får en ny sjanse.

Du kan også velge å sjekke på forhånd i stedet for å fange feilen:

if tekst.isdigit():
    alder = int(tekst)

Begge måter fungerer. Å fange unntaket kalles gjerne «lettere å be om tilgivelse enn om lov». Det passer når mange ting kan gå galt, eller når en forhåndssjekk er vanskelig å skrive. Merk at isdigit avviser "-5", som int godtar, så de to måtene er ikke helt like.

AdvarselVanlige feil
  • Tom except: som skjuler skrivefeil og andre uventede feil. Skriv alltid typen.
  • Å fange feil type: except ValueError hjelper ikke hvis feilen er en TypeError.
  • For mye kode i try-blokken, så du ikke vet hvilken linje som feilet. Hold den kort.
  • Å fange et unntak og ikke gjøre noe (except ValueError: pass) uten å tenke over konsekvensen.
  • Å bruke try der en enkel if er tydeligere.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1
try:
    tall = int("12")
    print(tall + 1)
except ValueError:
    print("Feil")
print("Ferdig")
Hva skrives ut?

Når int feiler, hoppes resten av try-blokken over.

13
Ferdig
13
Ferdig
Hva skrives ut hvis "12" er byttet med "tolv"?

Når int feiler, hoppes resten av try-blokken over.

Feil
Ferdig

Setningen print(tall + 1) kjøres ikke, siden int("tolv") feiler først.

Feil
Ferdig

Setningen print(tall + 1) kjøres ikke, siden int("tolv") feiler først.

Hvilket unntak må du fange for å håndtere hver av disse?

Brukeren skriver abc der du ventet et tall, og du bruker int.

Se på lista over vanlige unntak i forrige delkapittel.

ValueError

Du deler på et tall som kan være null.

Se på lista over vanlige unntak i forrige delkapittel.

ZeroDivisionError

Du slår opp en nøkkel i en ordbok som kanskje ikke finnes.

Se på lista over vanlige unntak i forrige delkapittel.

KeyError

Du åpner en fil som kanskje ikke finnes.

Se på lista over vanlige unntak i forrige delkapittel.

FileNotFoundError

Nivå 2

Programmet skal skrive Ikke et tall hvis brukeren ikke skriver et tall, men krasjer for noen inndata.

try:
    tall = int(None)
except ValueError:
    print("Ikke et tall")
Hvilken feilmelding får du?

Hvilken feil gir int(None)?

TypeError: int() argument must be a string, a bytes-like object or a real number, not 'NoneType'. Det er ikke en ValueError, så except ValueError fanger den ikke, og programmet krasjer.

Hvordan retter du det?

Hvilken feil gir int(None)?

Fang begge typene: except (ValueError, TypeError):. Eller bruk to except-blokker hvis du vil gjøre ulike ting.

Funksjonen skal gi det første elementet i lista, men gir alltid None.

def forste(liste):
    try:
        return liste[0]
    except:
        return None

print(forste([5, 6, 7]))
print(forste(5))

Hva skriver programmet ut, og hva er problemet med den tomme except?

Hva skjer når du ber om element \(0\) i tallet \(5\)?

Programmet skriver 5 og None. For forste(5) er det en TypeError (5 er ikke en liste), men den tomme except fanger den og gir None, så feilen skjules. Det er riktig å gi None for en tom liste (IndexError), men en feil type er en programmeringsfeil som du vil oppdage. Fang bare IndexError.

Kodeoppgaver

Disse oppgavene rettes automatisk. Testene kaller funksjonen din med både gyldige og ugyldige verdier.

Lag funksjonen til_heltall(tekst) som gir teksten som heltall, eller None hvis den ikke kan gjøres om.

Prøv int(tekst) i en try-blokk. Fang ValueError, og returner None.

Lag funksjonen del_trygt(a, b) som gir a / b, men None hvis b er \(0\).

Fang ZeroDivisionError i en try-blokk.

Lag funksjonen hent(liste, indeks, standard=None) som gir elementet på plassen indeks, eller standard hvis plassen ikke finnes.

Prøv liste[indeks], og fang IndexError.

Lag funksjonen les_tall(tekster) som gjør hver tekst i lista om til et desimaltall med float, og gir en liste med bare de som lot seg gjøre om. Tekster som ikke er tall, hoppes over.

Gå gjennom lista. For hver tekst prøver du float(tekst) i en try-blokk og legger tallet til i resultatet. Fang ValueError.

Funksjonen skal gi None bare for tom liste, men gir også None når det er en skrivefeil i koden. Rett den slik at skrivefeilen ikke skjules.

Fang bare ZeroDivisionError.

Utfordringer

Lag funksjonen snitt_av_tekster(tekster) som gir gjennomsnittet av alle tekstene som er tall, eller None hvis ingen er det.

Bruk en løkke med try/except til å samle gyldige tall, og regn ut snittet bare hvis lista ikke er tom.

Gi et eksempel på en feil du ikke bør fange med try/except, og forklar hvorfor.

En NameError eller SyntaxError fra en skrivefeil, eller en TypeError fordi du har sendt feil type inn i en funksjon. Det er feil i selve programmet som du må rette, ikke situasjoner programmet skal tåle. Fanger du dem, skjuler du feilen, og får et program som ser ut til å virke men gjør feil. Du bør fange unntak som kan skje selv om koden er riktig: brukeren skriver noe ugyldig, en fil mangler, nettet er nede.

Oppsummering

try og except

try:
    tall = int(tekst)
except ValueError:
    tall = None

Flere unntak

except (ValueError, TypeError):
    ...
except ZeroDivisionError as f:
    print(f)

else og finally

try:
    ...
except ValueError:
    ...
else:
    ...  # hvis ingen feil
finally:
    ...  # alltid
  • Fang bare de unntakene du venter, og skriv alltid typen.
  • Hold try-blokken kort.
  • En tom except: skjuler feil du burde oppdage.

4.2.2 Å utløse unntak med raise

I forrige delkapittel fanget du unntak som Python utløste. Men noen ganger vil du utløse et unntak. Tenk deg en funksjon sett_alder(alder) som får tallet \(-5\). Det er ikke en alder, og funksjonen bør ikke late som alt er i orden. Den bør stoppe og si fra. Da bruker du raise.

def sett_alder(alder):
    if alder < 0:
        raise ValueError("Alder kan ikke være negativ")
    return alder

try:
    sett_alder(-5)
except ValueError as f:
    print("Feil:", f)
Feil: Alder kan ikke være negativ

Funksjonen avviser tallet ved å utløse en ValueError med en tydelig melding. Den som kaller funksjonen, kan fange feilen, eller la den stoppe programmet.

Læringsmål

Etter dette delkapittelet skal du kunne

  • utløse unntak med raise, med en passende type og en tydelig melding,
  • velge riktig unntakstype,
  • bestemme når en funksjon bør utløse et unntak, og når den bør gi None,
  • sjekke inndata i en funksjon (validering).

raise

Med raise utløser du et unntak selv. Du skriver typen, og en melding i parentes. Resten av funksjonen kjøres ikke: kontrollen går rett til den som kalte funksjonen, akkurat som når Python selv utløser et unntak.

Definisjonraise
raise ValueError("Beskjed om hva som er galt")

Unntaket kan fanges med except ValueError, og meldingen hentes med as. Hvis ingen fanger det, stopper programmet med en traceback, og meldingen står på siste linje.

Meldingen er viktig. Den er det den som får feilen, ser, og den bør si hva som er galt og gjerne hva som var forventet. «Feil» sier ingenting, mens «Alder må være mellom 0 og 120, men var -5» sier alt.

def karakter(poeng):
    if poeng < 0 or poeng > 100:
        raise ValueError(
            f"Poeng må være 0-100, men var {poeng}")
    if poeng >= 90:
        return "A"
    return "B eller lavere"

print(karakter(95))
try:
    karakter(120)
except ValueError as f:
    print(f)
A
Poeng må være 0-100, men var 120

Lag funksjonen kvadratrot(x) som gir kvadratroten av x, men utløser en ValueError med meldingen Kan ikke ta kvadratroten av et negativt tall hvis x er negativ.

Sjekk x < 0 først, og utløs unntaket. Ellers regner du ut x ** 0.5.

def kvadratrot(x):
    if x < 0:
        raise ValueError(
            "Kan ikke ta kvadratroten av et negativt tall")
    return x ** 0.5

print(kvadratrot(16))
try:
    kvadratrot(-4)
except ValueError as f:
    print(f)
4.0
Kan ikke ta kvadratroten av et negativt tall

kvadratrot(16) gir 4.0. kvadratrot(-4) utløser unntaket, og meldingen skrives ut av except.

Velge riktig type

Python har mange innebygde unntak, og du bør velge den som passer best, slik at den som fanger det, kan skille feilene fra hverandre:

RegelHvilken type?
  • ValueError: typen er riktig, men verdien er ugyldig (negativ alder, tom tekst der det kreves tekst).
  • TypeError: typen er feil (en tekst der det kreves et tall).
  • IndexError og KeyError: en plass eller nøkkel som ikke finnes.
  • FileNotFoundError: en fil som ikke finnes.
  • Exception: en generell feil, hvis ingen av de andre passer. Prøv å unngå den.
def dobbel(x):
    if not isinstance(x, (int, float)):
        raise TypeError(
            f"Forventet et tall, men fikk {type(x).__name__}")
    return x * 2

print(dobbel(4))
try:
    dobbel("hei")
except TypeError as f:
    print(f)
8
Forventet et tall, men fikk str

Her sjekker vi typen med isinstance, og utløser TypeError hvis den er feil. Merk at Python allerede ville gitt "hei" * 2 (som er "heihei") uten feil, så sjekken fanger noe Python ellers godtar.

raise eller None?

Skal funksjonen utløse et unntak eller gi None når noe ikke går? En god tommelfingerregel:

Regelraise eller return None?
  • raise når den som kalte funksjonen, har gjort noe galt: ugyldig inndata, brudd på forutsetningene. Det er en feil som ikke bør ignoreres.
  • return None (eller en annen standardverdi) når «ingen svar» er en helt normal utgang: å lete etter noe som kanskje ikke finnes.

finn_forste_negative([1, 2, 3]) bør gi None: at det ikke finnes noe negativt, er et vanlig resultat. Derimot bør kvadratrot(-4) utløse et unntak: kallet er ugyldig. Og gjennomsnitt([]) er et grensetilfelle der begge deler kan forsvares, så du må bestemme deg og dokumentere valget i docstringen.

Bestem for hver funksjon om den bør utløse et unntak eller gi None.

  1. finn_navn(liste, navn) leter etter et navn i en liste, og navnet finnes kanskje ikke.
  2. sett_alder(alder) får tallet \(-3\).
  3. del(a, b) får \(b = 0\).

Er «ingen treff» et normalt utfall, eller er kallet ugyldig?

  1. None. At navnet ikke finnes, er et normalt utfall av et søk.

  2. raise ValueError. \(-3\) er ikke en gyldig alder, og kallet bør ikke ignoreres.

  3. raise ZeroDivisionError (som Python gjør av seg selv) er det vanligste, siden deling på null er en feil. Å gi None er også mulig, men det er lett å glemme å sjekke svaret, og da får du en feil lenger fram som er vanskeligere å finne.

assert eller raise?

Du har sett assert, og kommer til å bruke det mye i neste delkapittel til testing. Hva er forskjellen? assert brukes til å kontrollere at programmet ditt er riktig, for eksempel i tester, og kan skrus av. raise brukes til å avvise ugyldig inndata fra brukeren eller andre deler av koden. Sjekker du noe som brukeren kan få feil, skal du bruke raise.

I kapittel 6 lærer du å lage egne unntakstyper med klasser, for eksempel UgyldigAlder. Til det trenger du stoffet om klasser først.

AdvarselVanlige feil
  • Å utløse noe som ikke er et unntak: raise "feil" gir TypeError: exceptions must derive from BaseException. Skriv raise ValueError("feil").
  • Å glemme meldingen, eller skrive en som ikke sier noe («Feil»).
  • Å bruke en for generell type (Exception) når en mer presis finnes.
  • Å utløse unntak for ting som er normale utfall, som at et søk ikke finner noe.
  • Å fange unntaket med en gang, så ingen får vite at noe var galt.
  • Å bruke assert til å kontrollere brukerens inndata.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hvilken unntakstype passer best?

En funksjon som tar en alder, får \(-5\).

Er typen feil, eller verdien?

ValueError (typen er riktig, verdien ugyldig).

En funksjon som venter et tall, får teksten "hei".

Er typen feil, eller verdien?

TypeError (feil type).

En funksjon som skal åpne en konfigurasjonsfil, finner ikke fila.

Er typen feil, eller verdien?

FileNotFoundError.

En funksjon som slår opp en vare i en prisliste, får en vare som ikke er i listen.

Er typen feil, eller verdien?

KeyError (nøkkelen finnes ikke), eller ValueError med en tydelig melding.

def sjekk(x):
    if x < 0:
        raise ValueError("negativ")
    return x

try:
    print(sjekk(5))
    print(sjekk(-1))
    print(sjekk(8))
except ValueError as f:
    print("Feil:", f)

Når raise utløses, hopper Python rett til except. Resten av try-blokken hoppes over.

5
Feil: negativ

sjekk(5) gir \(5\). sjekk(-1) utløser unntaket, og except skriver meldingen. sjekk(8) kjøres aldri, siden try-blokken ble avbrutt.

Nivå 2

Funksjonen skal utløse en ValueError med meldingen for liten, men krasjer med en annen feil.

def minst_ti(x):
    if x < 10:
        raise "for liten"
    return x
Hvilken feil får du?

Hva må stå etter raise?

TypeError: exceptions must derive from BaseException. Du kan bare utløse unntak, ikke en tekst.

Rett funksjonen.

Hva må stå etter raise?

raise ValueError("for liten").

Hva er galt med denne feilmeldingen, og hvordan forbedrer du den?

def sett_alder(alder):
    if alder < 0 or alder > 120:
        raise ValueError("Feil")
    return alder

Hva vil den som får feilen, trenge å vite?

«Feil» sier ikke hva som er galt eller hva som var forventet. En bedre melding: raise ValueError(f"Alder må være mellom 0 og 120, men var {alder}"). Da ser den som får feilen, både regelen og verdien som brøt den.

Kodeoppgaver

Disse oppgavene rettes automatisk. Testene kaller funksjonen din med ugyldige verdier og sjekker at riktig unntak utløses, med riktig melding.

Lag funksjonen sett_alder(alder) som gir alderen hvis den er mellom \(0\) og \(120\) (begge med), og ellers utløser en ValueError med meldingen Ugyldig alder.

Sjekk alder < 0 or alder > 120 og utløs ValueError("Ugyldig alder"). Ellers returnerer du alderen.

Lag funksjonen kvadratrot(x) som gir kvadratroten av x, og utløser ValueError med meldingen x kan ikke være negativ hvis x er negativ.

Sjekk x < 0 først og utløs ValueError. Ellers returnerer du x ** 0.5.

Lag funksjonen karakter(poeng) som gir "A" fra \(90\), "B" fra \(75\), "C" fra \(60\) og ellers "D". Er poengene ikke mellom \(0\) og \(100\), utløser den en ValueError.

Sjekk først om poengene er gyldige og utløs ValueError. Så bruker du en if-elif-kjede.

Lag funksjonen dobbel(x) som gir det doble av et tall. Er x ikke et tall (int eller float), utløser den en TypeError.

isinstance(x, (int, float)) sjekker typen. Utløs TypeError hvis den er False.

Funksjonen skal utløse ValueError for en tom liste, men gir bare None. Rett den.

Bytt return None med raise ValueError(...).

Utfordringer

Lag funksjonen valider_passord(passord) som gir passordet hvis det er gyldig, og ellers utløser en ValueError med riktig melding: For kort hvis det har færre enn \(8\) tegn, og Mangler tall hvis det ikke har noe siffer. Sjekk lengden først.

any(t.isdigit() for t in passord) er True hvis minst ett tegn er et siffer.

Funksjonen snitt(tall) utløser en ValueError for en tom liste. Programmet som bruker den, vil ikke krasje, men bare skrive Ingen data. Hvordan gjør du det, og hvorfor er det bra at funksjonen utløser unntaket i stedet for å bestemme selv hva som skjer?

Programmet kaller snitt i en try-blokk og fanger ValueError: try: print(snitt(data)) og except ValueError: print("Ingen data"). Det er bra at funksjonen utløser unntaket fordi den ikke vet hva programmet vil gjøre: noen vil vise en melding, andre bruke \(0\), andre avbryte. Funksjonen sier bare fra at kallet var ugyldig, og lar den som kaller, bestemme hva som skal skje. Slik kan samme funksjon brukes i mange sammenhenger.

Oppsummering

Utløse unntak

if alder < 0:
    raise ValueError("Ugyldig alder")

Typer

ValueError   TypeError
IndexError   KeyError
FileNotFoundError

Fange og lese melding

try:
    sett_alder(-5)
except ValueError as f:
    print(f)

raise eller None?

  • ugyldig kall: raise
  • normalt «ingen treff»: None
  • Gi alltid en tydelig melding: hva som er galt og hva som var forventet.
  • Velg den mest presise unntakstypen.
  • assert er for tester, raise er for å avvise ugyldig inndata.

4.3 Feilsøkingsstrategier og debugger

Her lærer du en systematisk måte å finne feil på, og å bruke debuggeren i VS Code.

4.3.1 Feilsøkingsstrategier

Når programmet ikke virker, er det fristende å begynne å endre på ting og håpe at det ordner seg. Det fungerer sjelden, og når det gjør det, vet du ikke hvorfor. En god programmerer jobber heller som en detektiv: samle bevis, lag en teori om hva som er galt, test teorien, og ikke gå videre før du har forstått. Dette delkapittelet viser en prosess du kan bruke på nesten alle feil.

Læringsmål

Etter dette delkapittelet skal du kunne

  • følge en systematisk prosess for å finne og rette en feil,
  • bruke utskrifter og en sporingstabell til å følge hva programmet gjør,
  • avgrense hvor feilen er, ved å teste delene hver for seg,
  • kjenne igjen de vanligste feilene og lete etter dem først.

En systematisk prosess

RegelProsessen
  1. Gjør feilen reproduserbar. Finn ut nøyaktig hva som må til for at feilen oppstår. Kan du få den til hver gang?
  2. Les feilmeldingen. Hva, hvor og hvordan du kom dit (se 4.1.1).
  3. Avgrens. Finn ut hvilken del av koden feilen er i. Hvor går det fra riktig til galt?
  4. Lag en hypotese. «Jeg tror feilen er at …»
  5. Test hypotesen. Endre én ting, eller skriv ut verdier, og se om hypotesen stemmer.
  6. Rett og kontroller. Kjør programmet på nytt, med de samme dataene som viste feilen, og med flere.
  7. Sørg for at den ikke kommer tilbake. Skriv en test (se 4.4).

Det viktigste er trinn 4 og 5. Gjetter du tilfeldig, kan du bruke timer. Formulerer du en hypotese og tester den, avgrenser du feilen for hvert forsøk.

Utskrifter og sporingstabell

Den enkleste måten å se hva programmet gjør, er å skrive ut verdier underveis. Funksjonen under skal gi summen av alle partall opp til og med \(n\), men gir feil svar:

def sum_partall(n):
    summen = 0
    for tall in range(1, n):
        if tall % 2 == 0:
            summen += tall
    return summen

print(sum_partall(10))
20

Svaret er \(20\), men det skal være \(2 + 4 + 6 + 8 + 10 = 30\). For å se hva som skjer, skriver vi ut verdiene underveis:

def sum_partall(n):
    summen = 0
    for tall in range(1, n):
        print("tall =", tall, "summen =", summen)
        if tall % 2 == 0:
            summen += tall
    return summen

print(sum_partall(10))
tall = 1 summen = 0
tall = 2 summen = 0
tall = 3 summen = 2
tall = 4 summen = 2
tall = 5 summen = 6
tall = 6 summen = 6
tall = 7 summen = 12
tall = 8 summen = 12
tall = 9 summen = 20
20

Utskriften viser at tall går fra \(1\) til \(9\), men aldri er \(10\). Dermed er hypotesen klar: løkka stopper for tidlig. Stoppverdien i range er ikke med, så det skal være range(1, n + 1).

Utskrifter er det samme som en sporingstabell du lager for hånd: du følger variablene runde for runde og sammenligner med det du forventet. Fordelen med utskrifter er at datamaskinen gjør jobben, og du ser hvor det blir galt.

Funksjonen skal gi det største tallet i lista, men gir feil svar for lister med bare negative tall. Finn feilen ved å skrive ut verdier.

def storste(tall):
    resultat = 0
    for x in tall:
        if x > resultat:
            resultat = x
    return resultat

Prøv med storste([-5, -2, -8]). Hva er resultat underveis?

def storste(tall):
    resultat = 0
    for x in tall:
        print("x =", x, "resultat =", resultat)
        if x > resultat:
            resultat = x
    return resultat

print(storste([-5, -2, -8]))
x = -5 resultat = 0
x = -2 resultat = 0
x = -8 resultat = 0
0

Utskriften viser at resultat starter på \(0\) og aldri endres, siden ingen av tallene er større enn \(0\). Funksjonen gir \(0\), som ikke engang er med i lista. Hypotese: startverdien er feil. Rettelse: resultat = tall[0]. Etterpå fjerner du utskriftene.

Avgrens feilen

Er programmet stort, hjelper det ikke å lese alt. Du må snevre inn hvor feilen er. Noen triks:

  • Test delene hver for seg. Kall hver funksjon med enkle tall der du vet svaret. Den første som gir feil svar, er mistenkt.
  • Halver. Sett en utskrift midt i programmet. Er verdiene riktige der, er feilen i andre halvdel. Er de feil, er den i første halvdel. Gjenta.
  • Lag et minimalt eksempel. Kopier den lille delen som feiler til en egen fil, og fjern alt som ikke trengs. Ofte ser du feilen når du har fjernet alt annet, og skal du spørre noen om hjelp, er et lite eksempel mye lettere å se på.
  • Hva endret jeg sist? Virket programmet før? Da er feilen i det du har gjort siden sist. Bruker du Git (se 1.4.1), viser git diff nøyaktig hva som er endret.

Se på et program med tre trinn som sammen gir feil svar:

def rens(tekst):
    return tekst.strip().lower()

def del_opp(tekst):
    return tekst.split(",")

def tell_ord(ordliste):
    return len(ordliste)

tekst = "  Eple,Pære,,Banan  "
ord_liste = del_opp(rens(tekst))
print(ord_liste)
print(tell_ord(ord_liste))
['eple', 'pære', '', 'banan']
4

Programmet skal telle ordene, men gir \(4\) i stedet for \(3\). Vi tester delene hver for seg: rens gir "eple,pære,,banan" (riktig), del_opp gir ['eple', 'pære', '', 'banan']. Der er feilen: den tomme teksten mellom de to kommaene teller som et «ord». Feilen er i data eller i del_opp, ikke i tell_ord, selv om det er der svaret blir feil.

De vanligste feilene

Mange feil er variasjoner over de samme temaene. Når du står fast, sjekk dem først:

AdvarselVanlige feilkilder
  • Off-by-one: en indeks eller range som er én for mye eller for lite.
  • Feil variabel: du bruker i i stedet for tall[i], eller en variabel med nesten samme navn.
  • Feil type: "10" er ikke 10. Skriv ut type(x) hvis du er usikker.
  • Skal vært ==: = og == blandet, eller and og or byttet.
  • Variabelen nullstilles: summen = 0 står inne i løkka.
  • To navn på samme liste: b = a kopierer ikke lista.
  • Innrykk: en linje er inni løkka, men skulle vært utenfor, eller omvendt.
  • Du endrer en liste mens du går gjennom den.
  • Heltall og desimaltall: // og /, eller avrunding.

Når du står fast

Noen ganger hjelper ikke prosessen, og du har sett på det samme så lenge at du ikke ser det lenger. Da kan disse hjelpe:

  • Forklar koden høyt, linje for linje, til en annen eller til en gummiand («rubber duck debugging»). Når du må si hva hver linje gjør, oppdager du ofte at den ikke gjør det du trodde.
  • Ta en pause. Fersk hjerne finner feil raskere enn trøtt hjerne.
  • Sjekk antakelsene dine. Er det virkelig en liste? Er verdien virkelig \(5\)? Skriv ut og se.
  • Les feilmeldingen en gang til, sakte.
  • Spør noen, med et lite eksempel, hva du forventet og hva som skjedde.
  • Tenk på hva du endret sist.
AdvarselVanlige feil i feilsøkingen
  • Å endre mange ting samtidig, så du ikke vet hva som hjalp.
  • Å gjette i stedet for å teste en hypotese.
  • Å stole på at «den delen er riktig» uten å sjekke.
  • Å glemme å fjerne utskriftene etterpå.
  • Å rette symptomet i stedet for årsaken.
  • Å aldri teste med spesielle verdier: tom liste, null, negative tall.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Sett trinnene i riktig rekkefølge for å finne og rette en feil:

  1. Rett feilen og kjør programmet på nytt.
  2. Lag en hypotese om årsaken.
  3. Få feilen til å skje hver gang.
  4. Test hypotesen, for eksempel med en utskrift.
  5. Les feilmeldingen.

Du må forstå og avgrense før du retter.

Én fornuftig rekkefølge er C, E, B, D, A. Først må feilen kunne gjentas (C). Så leser du hva Python sier (E), lager en hypotese (B), tester den (D), og først når du har forstått, retter du og kontrollerer (A). Hvis hypotesen ikke stemmer, går du tilbake til B.

Hva er summen når løkka er ferdig? Lag en sporingstabell.

summen = 0
for i in range(1, 5):
    if i % 2 == 1:
        summen += i
Nivå 2

Et program renser en tekst, deler den i ord og teller bokstavene i det lengste ordet. Utskriftene underveis er

rens("  Hei Verden  ")   ->  "hei verden"
del_opp("hei verden")    ->  ["hei", "verden"]
lengste(["hei", "verden"]) -> "hei"

Hvilken funksjon har feilen, og hva er den mest sannsynlige årsaken?

Sjekk hver funksjon for seg: stemmer inn og ut?

lengste har feilen. Det lengste ordet i ["hei", "verden"] er "verden", men funksjonen gir "hei". De to første funksjonene gir riktige svar. Sannsynlig årsak: sammenligningen er snudd (< i stedet for >), eller funksjonen gir det første ordet i stedet for å lete etter det lengste.

Funksjonen skal gi gjennomsnittet av en liste, men gir \(2{,}0\) for [1, 2, 3, 4] i stedet for \(2{,}5\).

def snitt(tall):
    summen = 0
    for x in tall:
        summen += x
    return summen // len(tall)

Formuler en hypotese, og forklar hvordan du tester den.

Hvor kommer desimaldelen inn? Se på operatoren.

Hypotese: // er heltallsdivisjon og kutter desimalene, så svaret blir \(10 // 4 = 2\). Test: skriv ut summen (som skal være \(10\)), og 10 / 4 og 10 // 4. Ser du \(2{,}5\) og \(2\), stemmer hypotesen. Rettelse: bruk / i stedet for //.

Kodeoppgaver

Disse oppgavene rettes automatisk. Hver funksjon har en feil. Finn den ved å teste med enkle tall, eller ved å skrive ut verdier.

siste_n(liste, n) skal gi de \(n\) siste elementene i lista, men gir ett for lite.

liste[-2:] gir de to siste. Hva gir liste[-n + 1:] for \(n = 2\)?

med_ekstra(liste, x) skal gi en ny liste med x lagt til, uten å endre den opprinnelige. Men den opprinnelige lista endres også.

ny = liste lager ikke en kopi. Bruk liste.copy().

storst_av(a, b) får to tall som tekster, "10" og "9", og skal gi det største tallet, men gir "9".

Tekster sammenlignes tegn for tegn: "9" > "10". Gjør dem til tall først, og gi tilbake et tall.

Funksjonen skal gi summen av hver rad i en tabell som en liste, men gir bare tallet for siste rad.

Se på innrykket på linja summer.append(summen). Hvor mange ganger kjøres den?

Funksjonen skal gi en liste med tallene som er større enn gjennomsnittet, men hopper over noen.

Hvilken indeks starter løkka på? Det første elementet blir aldri sjekket.

Utfordringer

Funksjonen skal telle hvor mange ganger en bokstav forekommer i en tekst, uten å bry seg om store og små bokstaver. Den har to feil.

Den første feilen ser du med tell("banana", "a"). Den andre ser du når du prøver tell("Banana", "b").

Forklar hvorfor det er bedre å lage en hypotese og teste den enn å endre på koden til det virker.

Når du gjetter, endrer du ofte flere ting, og når det til slutt virker, vet du ikke hvilken endring som hjalp, eller om du har laget nye feil. Det kan også virke «ved et uhell» for akkurat de dataene du prøvde, men feile for andre. Med en hypotese forstår du hvorfor feilen oppstår, tester én ting av gangen og vet at du har rettet årsaken, ikke bare symptomet. Det er også mye raskere når feilen er vanskelig.

Oppsummering

Prosessen

  1. Gjør feilen reproduserbar
  2. Les feilmeldingen
  3. Avgrens
  4. Lag en hypotese
  5. Test én ting
  6. Rett og kontroller
  7. Skriv en test

Utskrift underveis

print("x =", x, "summen =", summen)
print(type(x))

Avgrense

  • test delene hver for seg
  • halver programmet
  • lag et minimalt eksempel
  • hva endret jeg sist?

Sjekk først

off-by-one, feil variabel, feil type, = mot ==, nullstilt variabel, kopi av liste, innrykk.

  • Endre én ting om gangen.
  • Test med enkle tall der du kjenner svaret.
  • Fjern utskriftene når du er ferdig.

4.3.2 Debuggeren i VS Code

Med print kan du se verdier, men du må skrive utskriftene på forhånd, kjøre programmet på nytt, og du ser bare det du valgte å skrive ut. En debugger lar deg stoppe programmet midt i kjøringen, se på alle variablene og gå videre én linje om gangen, som å spille av en film i sakte film. Du bestemmer selv hva du vil se mens programmet kjører. Debuggeren er innebygd i VS Code, og er det viktigste verktøyet du har for å forstå hva programmet ditt faktisk gjør.

Dette delkapittelet gjør du i VS Code.

Læringsmål

Etter dette delkapittelet skal du kunne

  • sette brytepunkter og starte programmet i debuggeren,
  • gå gjennom koden med step over, step into og step out,
  • lese verdiene til variablene, og bruke Watch og kallestakken,
  • bruke betingede brytepunkter,
  • finne en feil ved å følge programmet i debuggeren.

Brytepunkter og start

Her er et program med en feil. Det skal gi summen \(1 + 2 + 3 + 4 + 5 = 15\), men gir noe annet. Lag fila summer.py i en prosjektmappe i VS Code:

def sum_til(n):
    summen = 0
    for i in range(1, n):
        summen += i
    return summen


resultat = sum_til(5)
print(resultat)

Kjører du programmet, skriver det 10. Vi finner feilen med debuggeren.

  1. Sett et brytepunkt. Klikk i margen til venstre for linjenummeret på linja summen += i (linje 4). Det dukker opp en rød prikk. Programmet vil stoppe der. Du kan også trykke F9 på linja.
  2. Start debuggeren. Trykk F5, og velg Python Debugger: Debug Python File hvis du blir spurt. Programmet starter, og stopper på brytepunktet før linja kjøres. Linja er markert med gult.
  3. Se på variablene. I panelet Run and Debug (ikonet med en liten bille og en spilleknapp i venstre marg, eller Ctrl+Shift+D) viser seksjonen Variables verdiene akkurat nå: n er \(5\), summen er \(0\) og i er \(1\).

Øverst på skjermen dukker det opp en liten verktøylinje med knapper for å styre kjøringen:

RegelKnappene i debuggeren
  • Continue (F5): kjør videre til neste brytepunkt, eller til programmet er ferdig.
  • Step Over (F10): kjør denne linja, og stopp på neste. Funksjoner som kalles på linja, kjøres i ett jafs.
  • Step Into (F11): hvis linja kaller en funksjon, gå inn i den og stopp på første linje der.
  • Step Out (Shift+F11): kjør ferdig funksjonen du er inni, og stopp når du er tilbake.
  • Restart (Ctrl+Shift+F5) og Stop (Shift+F5).

På Mac må du kanskje holde inne fn for å bruke F-tastene.

Gå gjennom koden

Trykk Continue (F5) igjen. Programmet kjører én runde i løkka og stopper på samme brytepunkt. Nå er i lik \(2\) og summen er \(1\). Trykker du flere ganger, ser du at i blir \(3\), \(4\), og så er programmet ferdig, uten at i noen gang var \(5\):

Stopp i summen før linja
1 \(1\) \(0\)
2 \(2\) \(1\)
3 \(3\) \(3\)
4 \(4\) \(6\)

Løkka kjører bare fire ganger, og det er tallet \(5\) som mangler. Dermed har du funnet feilen: range(1, n) stopper før n. Retter du til range(1, n + 1), får du \(15\).

Med Step Over (F10) går du ei linje om gangen i stedet for å hoppe til neste brytepunkt. Det er lurt når du vil følge hva hver linje gjør.

Tre andre deler av panelet er nyttige:

  • Watch: her kan du skrive inn et uttrykk, for eksempel summen + i eller i % 2 == 0, og debuggeren regner det ut for deg hver gang den stopper.
  • Call Stack: viser hvilke funksjoner som er i gang, med den innerste øverst. Det er den samme kallekjeden som i en traceback (se 4.1.1), men nå mens programmet kjører. Klikker du på en funksjon i lista, viser Variables verdiene i den.
  • Debug Console: nederst kan du skrive Python-uttrykk og få svar mens programmet er stoppet, for eksempel len(liste).

Du har brytepunkt på linja summen += i, og programmet kjører med sum_til(5). Hva er i og summen når programmet stopper for tredje gang?

Programmet stopper før linja kjøres. Lag tabellen for de to første rundene.

I første stopp er i lik \(1\) og summen lik \(0\). I andre stopp er i lik \(2\) og summen lik \(1\) (\(0 + 1\)). I tredje stopp er i lik \(3\) og summen lik \(3\) (\(0 + 1 + 2\)). Brytepunktet stopper før summen += i kjøres, så summen inneholder bare det som er lagt til før denne runden.

Betingede brytepunkter og mer

Er løkka lang, orker du ikke trykke F5 hundre ganger for å komme til runde \(50\). Da bruker du et betinget brytepunkt: høyreklikk i margen og velg Add Conditional Breakpoint, og skriv et uttrykk, for eksempel i == 50. Da stopper programmet bare når uttrykket er sant.

Du kan også velge Add Logpoint i stedet: den skriver en melding til Debug Console uten å stoppe programmet, som en utskrift du ikke trenger å legge inn i koden.

Et program som krasjer med et unntak, kan også stoppe i debuggeren akkurat der feilen skjedde, så du kan se alle variablene i øyeblikket før krasjen. I panelet Breakpoints nederst i debug-visningen kan du velge hvilke unntak programmet skal stoppe på.

Her er et program med to funksjoner, som du kan bruke til å øve på Step Into og Call Stack:

def snitt(tall):
    return sum(tall) / len(tall)


def rapport(data):
    return f"Snitt: {snitt(data)}"


print(rapport([4, 8, 15]))

Setter du et brytepunkt på print-linja nederst og trykker F11 to ganger, går du først inn i rapport og så inn i snitt. Da viser Call Stack tre linjer (snitt, rapport og hovedprogrammet), og Variables viser tall som [4, 8, 15].

AdvarselVanlige feil
  • Brytepunktet står på en linje som aldri kjøres, for eksempel inne i en if som ikke er sann. Da stopper aldri programmet.
  • Du glemmer at programmet stopper før linja kjøres, og tror verdiene allerede inkluderer den.
  • Du trykker Step Into på en innebygd funksjon som print, og havner i Python sin egen kode. Bruk Step Over, eller Step Out for å komme ut.
  • Du kjører programmet vanlig (Ctrl+F5 eller spilleknappen) i stedet for å debugge. Da ignoreres brytepunktene.
  • Du er ikke i riktig mappe eller har ikke riktig Python-tolk valgt, så programmet starter ikke.
  • Du ser bare på Variables og ikke på Call Stack, og forstår derfor ikke hvordan du kom til funksjonen.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Hvilken knapp (eller hurtigtast) bruker du til å

kjøre denne linja og stoppe på neste?

Se på lista over knappene tidligere i delkapittelet.

Step Over (F10)

gå inn i funksjonen som kalles på linja?

Se på lista over knappene tidligere i delkapittelet.

Step Into (F11)

kjøre videre til neste brytepunkt?

Se på lista over knappene tidligere i delkapittelet.

Continue (F5)

kjøre ferdig funksjonen du er inni?

Se på lista over knappene tidligere i delkapittelet.

Step Out (Shift+F11)

sette et brytepunkt på linja du står på?

Se på lista over knappene tidligere i delkapittelet.

F9, eller klikk i margen.

Programmet er

summen = 0
for tall in [2, 4, 6, 8]:
    summen += tall
print(summen)

Du har brytepunkt på linja summen += tall. Hva er tall og summen når programmet stopper for fjerde gang?

Nivå 2
def a():
    return b()

def b():
    return c()

def c():
    return 42

print(a())

Du har brytepunkt på return 42. Hvilke funksjoner vises i Call Stack, og i hvilken rekkefølge?

Den innerste funksjonen står øverst.

Fra øverst til nederst: c, b, a, og så hovedprogrammet (<module>). Kallestakken viser hvordan du kom til linja: hovedprogrammet kalte a, som kalte b, som kalte c.

Programmet er

for i in range(10):
    if i > 20:
        print("stor")
    print(i)

Du setter et brytepunkt på print("stor"), men programmet stopper aldri der. Hvorfor, og hvordan kan du få programmet til å stoppe i løkka?

Blir betingelsen noen gang sann?

i er aldri større enn \(20\) (den går fra \(0\) til \(9\)), så linja kjøres aldri. For å følge løkka setter du brytepunktet på print(i) i stedet, eller bruker et betinget brytepunkt, for eksempel i == 5.

Gjør det på maskinen
  1. Lag summer.py med programmet fra delkapittelet, og åpne mappa i VS Code.
  2. Sett et brytepunkt på linja summen += i og start debuggeren med F5.
  3. Trykk F5 til programmet er ferdig, og skriv ned i og summen ved hvert stopp.
  4. Forklar hvorfor summen blir \(10\), og rett programmet.
  5. Kjør debuggeren på nytt, og kontroller at du nå får fem stopp og summen \(15\).

Stoppene gir i lik \(1\), \(2\), \(3\) og \(4\), og summen før linja lik \(0\), \(1\), \(3\) og \(6\). Løkka kjører bare fire ganger fordi range(1, n) stopper før n. Rett til range(1, n + 1). Etter rettelsen stopper programmet fem ganger (i fra \(1\) til \(5\)), og siste stopp har summen lik \(10\) før linja, og \(15\) etter. Programmet skriver 15.

  1. Lag programmet med snitt og rapport fra delkapittelet.
  2. Sett et brytepunkt på siste linje (print(rapport(...))), og start debuggeren.
  3. Trykk Step Into (F11) til du står inni snitt. Hva viser Call Stack?
  4. Skriv sum(tall) i Watch. Hva er verdien?
  5. Trykk Step Out (Shift+F11) til du er tilbake i hovedprogrammet. Hva skjer med Call Stack?

Inne i snitt viser Call Stack tre linjer: snitt, rapport og hovedprogrammet. Watch-uttrykket sum(tall) er \(27\) (\(4 + 8 + 15\)). Når du går ut med Step Out, forsvinner funksjonene en etter en fra kallestakken, og til slutt står bare hovedprogrammet igjen.

  1. Lag programmet:
summen = 0
for i in range(1, 101):
    summen += i
print(summen)
  1. Sett et betinget brytepunkt på summen += i med betingelsen i == 50.
  2. Debugg programmet. Hva er summen når det stopper?

Programmet stopper én gang, i runde \(50\). Da er summen lik \(1225\), summen av tallene fra \(1\) til \(49\) (siden linja ikke er kjørt ennå for \(i = 50\)).

Utfordringer

Programmet skal telle hvor mange ganger hvert ord forekommer, men gir feil. Bruk debuggeren til å finne feilen.

tekst = "en to en tre to en"
antall = {}
for ord in tekst.split():
    if ord in antall:
        antall[ord] = 1
    else:
        antall[ord] = 1
print(antall)

Sett et brytepunkt inni løkka og se på antall hver gang.

Programmet skriver {'en': 1, 'to': 1, 'tre': 1}. Med debuggeren ser du at antall aldri får verdier større enn \(1\): når ordet allerede finnes, settes verdien til \(1\) i stedet for å økes. Retting: antall[ord] += 1 i den første grenen. Da blir resultatet {'en': 3, 'to': 2, 'tre': 1}.

Når bruker du heller print enn debuggeren, og når er debuggeren best?

print er raskt og enkelt for små feil, og virker overalt, også der du ikke har en debugger, for eksempel på en server eller i et program som kjører lenge. Debuggeren er best når du vil forstå hvorfor noe skjer: du ser alle variablene, kan gå linje for linje, se kallekjeden og endre hva du ser på uten å skrive om koden og kjøre på nytt. For feil i store programmer og kompliserte løkker sparer debuggeren mye tid.

Oppsummering

Starte

  1. Klikk i margen (eller F9) for brytepunkt
  2. F5 starter debuggeren
  3. Programmet stopper før linja

Knappene

  • F5 Continue
  • F10 Step Over
  • F11 Step Into
  • Shift+F11 Step Out

Panelene

  • Variables: verdiene nå
  • Watch: egne uttrykk
  • Call Stack: hvordan du kom hit
  • Debug Console: skriv Python

Mer

  • Betinget brytepunkt: i == 50
  • Logpoint: melding uten å stoppe
  • Programmet stopper før linja kjøres.
  • Kjør med debugger (F5), ikke vanlig kjøring, for at brytepunktene skal virke.
  • Se på både Variables og Call Stack.

4.4 Testing med assert og pytest

Tester lar datamaskinen sjekke at koden din virker, hver gang du endrer den. Her skriver du dem med assert og pytest.

4.4.1 Testing med assert

Du har laget en funksjon og kjørt den med noen tall, og den ga riktig svar. Er den ferdig? Kanskje, men hvor sikker er du? Hva med en tom liste, negative tall eller null? Og når du endrer funksjonen om en uke, må du huske å teste alt på nytt. Løsningen er å skrive tester: små programmer som kjører funksjonen din med kjente verdier og sjekker at svaret stemmer. Da gjør datamaskinen jobben hver gang, på sekunder.

Læringsmål

Etter dette delkapittelet skal du kunne

  • skrive tester med assert,
  • velge testtilfeller: vanlige verdier, grensetilfeller og feil,
  • samle tester i testfunksjoner og kjøre dem,
  • teste desimaltall og unntak,
  • forklare hva tester kan og ikke kan.

assert

Med assert påstår du at noe er sant. Er det sant, skjer det ingenting. Er det usant, stopper programmet med en AssertionError. Du kan legge til en melding etter komma.

Definisjonassert
assert betingelse
assert betingelse, "melding hvis den er usann"

Er betingelsen True, går programmet videre. Er den False, utløses en AssertionError med meldingen.

def dobbel(x):
    return x * 2

assert dobbel(2) == 4
assert dobbel(0) == 0
print("Alle testene gikk bra")
Alle testene gikk bra

Siden begge påstandene er sanne, skjer det ingenting, og programmet skriver ut meldingen til slutt. Se hva som skjer når en test feiler. Vi bruker en funksjon med en feil, og try for å fange feilen så vi kan se den:

def dobbel_feil(x):
    return x + 2

try:
    assert dobbel_feil(5) == 10, "skulle gitt 10"
except AssertionError as f:
    print("Test feilet:", f)
Test feilet: skulle gitt 10

Her gir dobbel_feil(5) verdien \(7\) i stedet for \(10\). Hadde vi ikke fanget feilen, ville programmet stoppet med en traceback som slutter med AssertionError: skulle gitt 10. Meldingen etter komma gjør at du ser hva som feilet.

Hva skal du teste?

Det er ikke nok å teste at funksjonen virker for ett eksempel. Gode tester dekker tre typer tilfeller:

RegelHva skal du teste?
  1. Vanlige tilfeller: typiske verdier der du vet svaret.
  2. Grensetilfeller: de ytterste verdiene og de spesielle verdiene: \(0\), ett element, tom liste, negative tall, største og minste lovlige verdi.
  3. Feil: ugyldig inndata, der funksjonen skal utløse et unntak.

De fleste feil skjuler seg i grensetilfellene. Se på denne funksjonen:

def storste(tall):
    resultat = 0
    for x in tall:
        if x > resultat:
            resultat = x
    return resultat

En test med [3, 9, 4] ville gått bra, men funksjonen feiler for lister med bare negative tall. Du finner feilen bare hvis du tester det. Gode tester for storste:

assert storste([3, 9, 4]) == 9      # vanlig liste
assert storste([9, 3, 4]) == 9      # størst først
assert storste([7]) == 7            # ett element
assert storste([-5, -2, -8]) == -2  # negative

Den siste testen ville avslørt feilen med startverdien \(0\).

Hvilke tester ville du skrevet for funksjonen er_partall(n)?

Tenk vanlige tall, null og negative tall.

def er_partall(n):
    return n % 2 == 0

assert er_partall(4) is True     # vanlig partall
assert er_partall(7) is False    # vanlig oddetall
assert er_partall(0) is True     # null er partall
assert er_partall(-2) is True    # negativt partall
assert er_partall(-3) is False   # negativt oddetall
print("Alle testene gikk bra")
Alle testene gikk bra

Null og de negative tallene er grensetilfellene. Mange gjør feil der, for eksempel ved å sjekke n > 0 først.

Testfunksjoner

Når du har mange tester, er det lurt å samle dem i testfunksjoner. Hver testfunksjon tester én ting, og navnet starter med test_. Da kan du kjøre alle med én kommando, og se hvilken som feilet. Her er en liten testkjører som kaller hver testfunksjon og skriver ut resultatet:

def kjor(*tester):
    for test in tester:
        try:
            test()
            print("OK  ", test.__name__)
        except AssertionError as f:
            print("FEIL", test.__name__, "-", f)

def test_vanlig():
    assert er_partall(4) is True
    assert er_partall(7) is False

def test_null_og_negative():
    assert er_partall(0) is True
    assert er_partall(-3) is False

kjor(test_vanlig, test_null_og_negative)
OK   test_vanlig
OK   test_null_og_negative

Alle testene går bra. En funksjon kjor er egentlig det de ferdige testverktøyene gjør, bare mer avansert. I neste delkapittel bruker du pytest, som finner og kjører testfunksjonene for deg.

I en vanlig fil legger du gjerne testene nederst, under if __name__ == "__main__": (se 3.2.1), slik at de bare kjører når du kjører fila direkte.

Desimaltall og unntak

Desimaltall lagres unøyaktig, så 0.1 + 0.2 == 0.3 er False. Når du tester desimaltall, bruker du math.isclose i stedet for ==:

import math

assert math.isclose(0.1 + 0.2, 0.3)
print("OK")
OK

Skal du teste at funksjonen utløser et unntak, kan du bruke dette mønsteret:

def kvadratrot(x):
    if x < 0:
        raise ValueError("x kan ikke være negativ")
    return x ** 0.5

def test_kvadratrot_negativ():
    try:
        kvadratrot(-4)
        assert False, "Skulle utløst ValueError"
    except ValueError:
        pass

kjor(test_kvadratrot_negativ)
OK   test_kvadratrot_negativ

Testen kaller funksjonen med et ugyldig tall. Utløses ValueError, fanges den av except, og testen går bra. Utløses det ingenting, kommer assert False, som feiler med meldingen. Merk at AssertionError ikke fanges av except ValueError, så den kommer gjennom og viser at testen feilet.

Hva testing kan og ikke kan

Tester kan vise at det finnes en feil, men ikke bevise at det ikke finnes noen. En funksjon som består tusen tester, kan fortsatt feile på den tusen-og-første verdien. Gode tester gjør det mindre sannsynlig, og de gir deg to store fordeler:

  • Trygghet når du endrer. Endrer du koden, kjører du testene og ser med en gang om noe er ødelagt.
  • Dokumentasjon. Testene viser hvordan funksjonen er ment å brukes.

Gode tester er korte, tester én ting, og tester hva funksjonen gjør, ikke hvordan. Testene dine bør heller ikke avhenge av hverandre: hver av dem skal kunne kjøres alene.

AdvarselVanlige feil
  • Å teste bare ett vanlig tilfelle, og aldri null, tom liste, negative tall og grenser.
  • Å teste med verdier du ikke vet svaret på, slik at du bare kopierer det funksjonen gir.
  • Å bruke == på desimaltall. Bruk math.isclose.
  • Å skrive alle testene i én lang funksjon, så du ikke ser hvilken som feilet.
  • Å glemme assert, og skrive bare er_partall(4) == True, som ikke sjekker noe.
  • Å rette testen i stedet for koden når den feiler, uten å tenke på hvem som har rett.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Funksjonen er

def kvadrat(x):
    return x * x

Hvilke av disse testene består, og hvilke feiler?

assert kvadrat(3) == 9

Regn ut kvadrat for hver verdi, og sammenlign.

Består (\(3 \cdot 3 = 9\)).

assert kvadrat(-4) == -16

Regn ut kvadrat for hver verdi, og sammenlign.

Feiler. \((-4) \cdot (-4) = 16\), ikke \(-16\). Testen er feil, ikke funksjonen: kvadratet av et negativt tall er positivt.

assert kvadrat(0) == 0

Regn ut kvadrat for hver verdi, og sammenlign.

Består.

assert kvadrat(2.5) == 6.25

Regn ut kvadrat for hver verdi, og sammenlign.

Består (\(2{,}5 \cdot 2{,}5 = 6{,}25\), og dette er et tall som kan skrives nøyaktig som desimaltall).

Hvilken type tilfelle (vanlig, grense eller feil) tester hver av disse for funksjonen snitt(tall)?

assert snitt([2, 4, 6]) == 4

Vanlige tilfeller er typiske verdier. Grensetilfeller er spesielle: ett element, negative tall, null.

Vanlig tilfelle.

assert snitt([5]) == 5

Vanlige tilfeller er typiske verdier. Grensetilfeller er spesielle: ett element, negative tall, null.

Grensetilfelle (ett element).

Et kall med en tom liste, der du forventer en ValueError.

Vanlige tilfeller er typiske verdier. Grensetilfeller er spesielle: ett element, negative tall, null.

Feil (ugyldig inndata).

assert snitt([-2, 2]) == 0

Vanlige tilfeller er typiske verdier. Grensetilfeller er spesielle: ett element, negative tall, null.

Grensetilfelle (negative tall som gir null).

Nivå 2

Du har skrevet disse testene for funksjonen siste(liste), som gir det siste elementet i lista:

assert siste([1, 2, 3]) == 3
assert siste([5, 9]) == 9

Hvilke tilfeller mangler, og hva ville du lagt til?

Tenk på grensetilfeller: minst og mest mulig inndata.

Begge testene er vanlige tilfeller. Det mangler: en liste med ett element (siste([7]) == 7), og en tom liste, der du må bestemme hva som skal skje (for eksempel at ValueError utløses). Du kan også teste en liste med tekster eller med like elementer. Tilfellene med ett element og tom liste er de som oftest avslører feil.

Testen skal sjekke at 0.1 + 0.2 er \(0{,}3\), men feiler.

assert 0.1 + 0.2 == 0.3

Forklar hvorfor, og rett testen.

Hvordan lagres desimaltall?

0.1 + 0.2 er 0.30000000000000004 fordi desimaltall lagres unøyaktig som totall. Sammenligningen med == gir derfor False. Rettet test: import math og assert math.isclose(0.1 + 0.2, 0.3).

Kodeoppgaver

Disse oppgavene rettes automatisk. Denne gangen er det testene dine som blir rettet. Du skriver en testfunksjon med assert. Den må bestå mot den riktige funksjonen, og den må feile mot de feilaktige versjonene som rettingen prøver. Da vet du at testene dine fanger feil.

Funksjonen er_partall er laget for deg. Skriv testfunksjonen test_er_partall() med assert-tester som fanger alle slags feil i funksjonen. Rettingen bytter ut funksjonen med feil versjoner, og testene dine skal oppdage hver av dem.

Test et partall, et oddetall, null, og både positive og negative tall. Hver test er en linje med assert er_partall(...) ....

Skriv test_storste() for funksjonen storste(tall), slik at den fanger de feilaktige versjonene.

Test med det største først, sist og midt i lista. Test også ett element og bare negative tall.

Lag funksjonen forkort(tekst, maks) som gir teksten uendret hvis den har høyst maks tegn, og ellers de første maks - 3 tegnene etterfulgt av .... Disse testene er et utgangspunkt:

assert forkort("Hei", 10) == "Hei"
assert forkort("Programmering", 8) == "Progr..."

Er len(tekst) <= maks, returnerer du teksten. Ellers tekst[:maks - 3] + "...".

Funksjonen kvadratrot(x) skal utløse en ValueError for negative tall. Skriv test_kvadratrot() som sjekker både et vanlig tall og at unntaket utløses.

Test assert kvadratrot(16) == 4. For unntaket bruker du try/except ValueError med assert False etter kallet, som i eksempelet.

Utfordringer

Skriv test_snitt() for snitt(tall), som gir gjennomsnittet og utløser ValueError for en tom liste. Testene dine skal fange fire feilaktige versjoner.

Test et snitt som ikke er et helt tall (som [1, 2]), flere tall der første er forskjellig fra resten, og tom liste.

En test feiler. Gi tre mulige årsaker, og forklar hvordan du finner ut hvem som har rett.

Årsaker: (1) Koden har en feil. (2) Testen har en feil, for eksempel at du har regnet ut forventet svar feil (som kvadrat(-4) == -16). (3) Testen og koden bygger på ulike antakelser om hva som skal skje, for eksempel om en tom liste skal gi None eller et unntak. For å finne ut hvem som har rett, regner du ut det riktige svaret for hånd, leser kravene til funksjonen, og sjekker hva docstringen sier. Så retter du den som er feil. Å rette testen bare fordi den feiler, uten å tenke, er farlig.

Oppsummering

assert

assert dobbel(2) == 4
assert x > 0, "x må være positiv"

Testfunksjon

def test_dobbel():
    assert dobbel(2) == 4
    assert dobbel(0) == 0

Desimaltall

import math
assert math.isclose(a, b)

Unntak

try:
    f(-1)
    assert False, "Skulle feile"
except ValueError:
    pass
  • Test vanlige tilfeller, grensetilfeller og feil.
  • De fleste feil gjemmer seg i grensetilfellene: null, én, tom, negativ.
  • Tester viser at feil finnes, men beviser ikke at de ikke finnes.

4.4.2 Testing med pytest

I forrige delkapittel laget du en liten testkjører selv. Det finnes et ferdig verktøy som gjør det mye bedre: pytest. Du skriver testfunksjoner med assert, og pytest finner dem, kjører dem alle og forteller nøyaktig hva som feilet og hvorfor. Det er det mest brukte testverktøyet i Python, og det er verktøyet du bruker i prosjektene (se P2.4).

Dette delkapittelet gjør du i VS Code.

Læringsmål

Etter dette delkapittelet skal du kunne

  • installere pytest og skrive testfiler og testfunksjoner,
  • kjøre pytest fra terminalen og i VS Code, og lese resultatet,
  • teste unntak med pytest.raises, og desimaltall med pytest.approx,
  • teste mange verdier med parametrize,
  • organisere tester i et prosjekt.

Den første testen

Installer pytest i det virtuelle miljøet (se 1.3.1) med pip install pytest. Lag en prosjektmappe med to filer. Først modulen som skal testes, regning.py:

def dele(a, b):
    """Deler a på b."""
    if b == 0:
        raise ValueError("Kan ikke dele på null")
    return a / b


def er_partall(n):
    return n % 2 == 0

Så fila med testene, test_regning.py:

import pytest
from regning import dele, er_partall


def test_dele():
    assert dele(10, 2) == 5


def test_dele_med_null():
    with pytest.raises(ValueError):
        dele(1, 0)


def test_er_partall():
    assert er_partall(4) is True
    assert er_partall(7) is False

Kjør testene fra terminalen, i mappa der filene ligger:

python -m pytest
============================= test session starts ==============================
platform linux -- Python 3.14.4, pytest-9.2.0, pluggy-1.7.0
rootdir: /Users/kari/it2/pytest_demo
collected 3 items

test_regning.py ...                                                      [100%]

============================== 3 passed in 0.02s ===============================

Pytest fant filen test_regning.py og kjørte de tre testene. Hver prikk er en test som gikk bra. Utskriften din kan se litt annerledes ut, for eksempel med andre versjonsnumre.

RegelHvordan pytest finner testene
  • Filene må hete test_*.py (eller *_test.py).
  • Funksjonene må hete test_*.
  • Du trenger ikke lage en testkjører eller kalle funksjonene selv. Pytest gjør det.
  • Skriv python -m pytest (eller bare pytest) i terminalen, i prosjektmappa.

Legg merke til hva som er likt og hva som er nytt fra forrige delkapittel: du bruker fortsatt assert, men slipper å skrive kjor(...). Og testen for unntaket er blitt kortere. Med pytest.raises skriver du:

with pytest.raises(ValueError):
    dele(1, 0)

Testen går bra hvis koden inni blokken utløser en ValueError, og feiler hvis den ikke gjør det, eller hvis den utløser en annen feil. Det erstatter try/except-mønsteret fra forrige delkapittel.

Lag en test for er_partall som sjekker et partall, et oddetall og null, og kjør den.

Lag en funksjon som starter med test_ i test_regning.py, og bruk tre assert.

def test_er_partall_og_null():
    assert er_partall(4) is True
    assert er_partall(7) is False
    assert er_partall(0) is True

Kjør python -m pytest. Alle fire testene (de tre fra før og denne) skal bestå: 4 passed.

Når en test feiler

Pytest er best når noe er galt. La oss si at du ved en feil har skrevet n % 2 == 1 i er_partall. Da viser pytest dette:

..FFFFF                                                                  [100%]
=================================== FAILURES ===================================
_______________________________ test_er_partall ________________________________

    def test_er_partall():
>       assert er_partall(4) is True
E       assert False is True
E        +  where False = er_partall(4)

test_regning.py:15: AssertionError

Slik leser du den:

  1. Øverst: ..FFFFF viser at de to første testene gikk bra (.) og at fem feilet (F).
  2. Overskriften test_er_partall sier hvilken test som feilet.
  3. Linja med > viser hvilken linje i testen som feilet: assert er_partall(4) is True.
  4. Linjene som starter med E viser hvorfor: er_partall(4) ga False, men testen ventet True.

Pytest viser altså verdiene som ble sammenlignet. Det er mye bedre enn en vanlig AssertionError.

Med -v (verbose) får du en linje per test:

python -m pytest -v
test_regning.py::test_dele PASSED                                        [ 14%]
test_regning.py::test_dele_med_null PASSED                               [ 28%]
test_regning.py::test_er_partall PASSED                                  [ 42%]
_______________________________ test_dele ________________________________

    def test_dele():
>       assert dele(10, 4) == 2
E       assert 2.5 == 2
E        +  where 2.5 = dele(10, 4)

test_regning.py:7: AssertionError
  1. Hvilken test feilet, og på hvilken linje?
  2. Hva ga funksjonen, og hva ventet testen?
  3. Hvem tror du har rett: testen eller funksjonen?

Se på linjene som starter med E.

  1. Testen test_dele, på linje \(7\) i test_regning.py.

  2. dele(10, 4) ga 2.5, men testen ventet \(2\).

  3. Funksjonen har rett: \(10 / 4\) er \(2{,}5\). Testen har en feil, for eksempel at den er skrevet med heltallsdivisjon i tankene. Rettet test: assert dele(10, 4) == 2.5.

Flere verktøy

Desimaltall. For desimaltall bruker du pytest.approx i stedet for ==:

assert 0.1 + 0.2 == pytest.approx(0.3)

Mange verdier. Når du vil teste den samme funksjonen med mange verdier, bruker du parametrize. Du lister verdiene, og pytest kjører testen én gang for hver:

@pytest.mark.parametrize("tall, forventet", [
    (0, True), (1, False), (2, True), (-3, False),
])
def test_er_partall_flere(tall, forventet):
    assert er_partall(tall) == forventet

Her blir det fire tester. Med -v ser du dem hver for seg (test_er_partall_flere[0-True], [1-False] og så videre), og en som feiler, vises med verdiene som ga feilen. Linja som starter med @, kalles en dekoratør. Du trenger ikke forstå hvordan den virker, bare hvordan du skriver den.

Mapper. Samler du testene i en egen mappe tests/, må du passe på importene. Pytest finner ikke automatisk modulen i hovedmappa, så en bar pytest gir ModuleNotFoundError: No module named 'regning'. Det er to løsninger: bruk python -m pytest (som legger den nåværende mappa til søkestien), eller lag en tom fil conftest.py i hovedmappa. Den enkleste måten for små prosjekter er å legge testfila ved siden av modulen, slik som over.

prosjekt/
├── regning.py
└── test_regning.py

Pytest i VS Code

VS Code har et eget panel for tester. Åpne kommandopaletten (Ctrl+Shift+P, på Mac Cmd+Shift+P), skriv Python: Configure Tests, og velg pytest og mappa med testene. Da dukker et reagensrør-ikon (Testing) opp i venstre marg. I panelet ser du alle testene i et tre, med grønn hake eller rødt kryss for hver. Du kan kjøre alle, kjøre én og én test, og klikke på en feilet test for å hoppe til den. Du kan også sette et brytepunkt i testen eller i funksjonen og velge Debug Test. Da bruker du debuggeren fra forrige delkapittel på testen.

AdvarselVanlige feil
  • Filen heter ikke test_*.py, eller funksjonen starter ikke med test_. Pytest finner ikke testen, og sier no tests ran.
  • ModuleNotFoundError for modulen du tester. Bruk python -m pytest, eller legg testfila ved siden av modulen.
  • Pytest er ikke installert i miljøet du kjører fra (No module named pytest).
  • Du bruker == på desimaltall. Bruk pytest.approx.
  • Du har en testfil som heter det samme som modulen (regning.py og regning.py), så importen går feil.
  • Du skriver assert funksjon(x) == y uten å importere funksjonen.
  • Du ser bare på siste linje av utskriften. Les hele feilrapporten.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Pytest skriver ut

test_regning.py ..F.F                                                    [100%]
Hvor mange tester ble kjørt?
Hvor mange feilet?

Hvilke av disse vil pytest finne og kjøre?

fila test_dele.py med funksjonen test_dele()

Både filnavnet og funksjonsnavnet må følge reglene.

Ja.

fila dele_test.py med funksjonen test_dele()

Både filnavnet og funksjonsnavnet må følge reglene.

Ja: pytest godtar også *_test.py.

fila testing.py med funksjonen test_dele()

Både filnavnet og funksjonsnavnet må følge reglene.

Nei: filnavnet må være test_*.py eller *_test.py.

fila test_dele.py med funksjonen sjekk_dele()

Både filnavnet og funksjonsnavnet må følge reglene.

Nei: funksjonen må starte med test_.

Nivå 2
____________________ test_er_partall_flere[0-True] _____________________

tall = 0, forventet = True

    @pytest.mark.parametrize("tall, forventet", [(0, True), (1, False)])
    def test_er_partall_flere(tall, forventet):
>       assert er_partall(tall) == forventet
E       assert False == True
E        +  where False = er_partall(0)
Hvilken verdi ga feilen?

Se på overskriften og linjene som starter med E.

Testen med tall = 0 og forventet = True.

Hva gjorde er_partall, og hva forventet testen?

Se på overskriften og linjene som starter med E.

er_partall(0) ga False, men testen forventet True.

Hva tror du er galt med er_partall?

Se på overskriften og linjene som starter med E.

Funksjonen behandler null feil. Kanskje den sjekker n > 0 først, eller feiler på annen måte for \(0\). Null er et partall, så funksjonen må rettes.

Du har lagd tester.py med

def sjekk_dele():
    assert dele(10, 2) == 5

Du kjører python -m pytest og får no tests ran. Hva er galt, og hvordan retter du det?

Se på reglene for hvordan pytest finner testene.

Fila heter tester.py, ikke test_*.py, og funksjonen heter sjekk_dele, ikke test_*. Pytest finner ingen av dem. Gi fila navnet test_dele.py og funksjonen navnet test_dele.

Gjør det på maskinen
  1. Lag en prosjektmappe med et virtuelt miljø, og installer pytest (pip install pytest).
  2. Lag regning.py med funksjonene dele og er_partall fra delkapittelet.
  3. Lag test_regning.py med testene fra delkapittelet, og kjør python -m pytest.
  4. Endre er_partall slik at den har en feil (n % 2 == 1) og kjør testene på nytt. Les feilrapporten.
  5. Rett feilen igjen.
  6. Konfigurer tester i VS Code (Python: Configure Tests), og kjør dem fra Testing-panelet.

Med riktig kode skriver pytest 7 passed (tre vanlige tester pluss fire fra parametrize, hvis du har tatt den med). Med feilen i er_partall feiler de testene som sjekker den, og pytest viser for hver av dem hvilken verdi som ga feil svar. Etter at du har rettet feilen, er alt grønt igjen. I VS Code ser du de samme testene i Testing-panelet med grønne hake eller røde kryss.

Ta biblioteket tallverktoy fra 3.2.2 (eller lag en liten modul statistikk.py med snitt, median og variasjonsbredde) og skriv pytest-tester for det.

  1. Lag test_statistikk.py med minst to tester per funksjon, inkludert grensetilfeller (ett element, negative tall).
  2. Bruk pytest.raises til å teste en tom liste, hvis funksjonene utløser unntak.
  3. Bruk parametrize til å teste median med minst fem ulike lister.
  4. Kjør testene, og sørg for at alle er grønne.

Eksempel på tester:

import pytest
from statistikk import snitt, median


def test_snitt():
    assert snitt([2, 4, 6]) == 4
    assert snitt([5]) == 5


def test_snitt_tom_liste():
    with pytest.raises(ValueError):
        snitt([])


@pytest.mark.parametrize("tall, forventet", [
    ([3, 1, 2], 2),
    ([4, 1, 3, 2], 2.5),
    ([5], 5),
    ([9, 1], 5),
    ([-3, -1, -2], -2),
])
def test_median(tall, forventet):
    assert median(tall) == forventet

Kjører du python -m pytest, skal alle testene bestå. Hvis noen feiler, viser rapporten hvilken liste som ga feil svar.

Utfordringer

Du har fått en modul lister.py med funksjonen siste_n(liste, n) (de \(n\) siste elementene). Skriv testene først, uten å se på koden, og kjør dem mot modulen. Finner testene dine noen feil?

Test vanlige verdier, \(n = 0\), \(n\) lik lengden på lista, \(n\) større enn lengden og tom liste.

Et godt svar har tester for flere tilfeller: siste_n([1, 2, 3], 2) == [2, 3], siste_n([1, 2, 3], 3) == [1, 2, 3], siste_n([1, 2, 3], 5) == [1, 2, 3], siste_n([], 2) == [] og siste_n([1, 2, 3], 0) == []. Spesielt \(n = 0\) er et vanlig sted for feil, for liste[-0:] gir hele lista, ikke en tom liste. Testene som feiler, viser hvilke tilfeller koden ikke håndterer.

Forklar fordelene med pytest framfor å skrive assert og kjøre fila selv.

Pytest finner og kjører alle testene automatisk, så du slipper å skrive en testkjører. Den kjører alle testene selv om en feiler, i stedet for å stoppe ved den første. Den viser en detaljert rapport med verdiene som ble sammenlignet. Den har ferdige verktøy: pytest.raises for unntak, approx for desimaltall og parametrize for mange verdier. Og den er integrert i VS Code, så du kan kjøre og debugge testene med et klikk.

Oppsummering

Kjøre

pip install pytest
python -m pytest
python -m pytest -v

Testfil

from regning import dele

def test_dele():
    assert dele(10, 2) == 5

Filen: test_*.py. Funksjonen: test_*.

Unntak og desimaltall

with pytest.raises(ValueError):
    dele(1, 0)

assert x == pytest.approx(0.3)

Mange verdier

@pytest.mark.parametrize(
    "a, b", [(1, 2), (3, 4)])
def test_x(a, b):
    ...
  • . er en test som gikk bra, F en som feilet. Les linjene som starter med E.
  • Bruk python -m pytest, eller legg testfila ved siden av modulen.
  • I VS Code: Python: Configure Tests, og bruk Testing-panelet.

4.5 Testdrevet utvikling

Her snur du rekkefølgen: du skriver testen først, og koden etterpå.

4.5.1 Skriv testen først

Hittil har du skrevet koden først og testene etterpå. Det går an å gjøre det motsatt: skrive testen først, se at den feiler, og så skrive akkurat nok kode til at den består. Dette kalles testdrevet utvikling, på engelsk test-driven development (TDD). Det høres bakvendt ut, men det har store fordeler. Du må tenke gjennom hva funksjonen skal gjøre før du skriver den, du får tester til alt, og du vet hele tiden hvor langt du har kommet.

Læringsmål

Etter dette delkapittelet skal du kunne

  • forklare syklusen rød, grønn og refaktorer,
  • gjøre om en beskrivelse av en funksjon til tester,
  • bygge en funksjon i små steg, styrt av tester,
  • vurdere når testdrevet utvikling passer, og når det ikke gjør det.

Rød, grønn, refaktorer

Testdrevet utvikling går i en liten syklus som du gjentar mange ganger:

RegelSyklusen
  1. Rød: Skriv en test for noe funksjonen skal gjøre, og kjør den. Den skal feile, fordi du ikke har skrevet koden ennå.
  2. Grønn: Skriv akkurat nok kode til at testen består. Ikke mer.
  3. Refaktorer: Rydd opp i koden uten å endre hva den gjør. Testene viser at du ikke har ødelagt noe.

Så tar du neste test.

Hvorfor skal testen feile først? Fordi en test som aldri har feilet, kan være en test som ikke tester noe. Ser du den feile, og så bestå etter at du har skrevet koden, vet du at den faktisk sjekker det den skal.

La oss bygge funksjonen er_gyldig(passord) på denne måten. Et gyldig passord har minst \(8\) tegn, minst ett siffer og minst én stor bokstav. Vi trenger en liten hjelper som kjører testene og skriver ut om de er røde eller grønne:

def prov(*tester):
    for test in tester:
        try:
            test()
            print("grønn", test.__name__)
        except Exception as f:
            print("RØD  ", test.__name__,
                  type(f).__name__, f)

Runde 1. Vi skriver testen først, for et gyldig passord. Funksjonen finnes ikke ennå:

def test_gyldig():
    assert er_gyldig("Hemmelig1") is True

prov(test_gyldig)
RØD   test_gyldig NameError name 'er_gyldig' is not defined

Testen er rød: NameError, siden er_gyldig ikke finnes. Vi skriver akkurat nok til at den består. Det enkleste er å alltid svare True:

def er_gyldig(passord):
    return True

prov(test_gyldig)
grønn test_gyldig

Testen er grønn. Koden er ikke god ennå, men det er poenget: den eneste testen vi har, passerer.

Runde 2. Nå en test for et passord som er for kort:

def test_for_kort():
    assert er_gyldig("Hei1") is False

prov(test_gyldig, test_for_kort)
grønn test_gyldig
RØD   test_for_kort AssertionError 

Den nye testen er rød, mens den gamle fortsatt er grønn. Vi utvider koden med en lengdesjekk:

def er_gyldig(passord):
    if len(passord) < 8:
        return False
    return True

prov(test_gyldig, test_for_kort)
grønn test_gyldig
grønn test_for_kort

Begge er grønne. De to neste rundene er likedan: først en rød test for passord uten tall ("Hemmeligpassord"), så en for passord uten stor bokstav ("hemmelig123").

def test_uten_tall():
    assert er_gyldig("Hemmeligpassord") is False

def test_uten_stor():
    assert er_gyldig("hemmelig123") is False

prov(test_gyldig, test_for_kort,
     test_uten_tall, test_uten_stor)
grønn test_gyldig
grønn test_for_kort
RØD   test_uten_tall AssertionError 
RØD   test_uten_stor AssertionError 

To nye røde tester. Vi legger til de to sjekkene:

def er_gyldig(passord):
    if len(passord) < 8:
        return False
    if not any(t.isdigit() for t in passord):
        return False
    if not any(t.isupper() for t in passord):
        return False
    return True

prov(test_gyldig, test_for_kort,
     test_uten_tall, test_uten_stor)
grønn test_gyldig
grønn test_for_kort
grønn test_uten_tall
grønn test_uten_stor

Alle fire er grønne. Refaktorering: koden kan skrives kortere, og testene sier om vi ødelegger noe:

def er_gyldig(passord):
    return (len(passord) >= 8
            and any(t.isdigit() for t in passord)
            and any(t.isupper() for t in passord))

prov(test_gyldig, test_for_kort,
     test_uten_tall, test_uten_stor)
grønn test_gyldig
grønn test_for_kort
grønn test_uten_tall
grønn test_uten_stor

Fortsatt alt grønt, så den kortere versjonen virker likt. Resultatet er en ferdig funksjon og fire tester som viser at den virker, og som du kan kjøre hver gang du endrer koden.

Du bygger er_gyldig og har tester for lengde, tall og stor bokstav. Nå får du et nytt krav: passordet kan ikke inneholde mellomrom. Hva gjør du først?

Test først, kode etterpå.

Skriv en test først, for eksempel assert er_gyldig("Hemmelig 123") is False. Kjør den og se at den er rød, siden funksjonen ennå ikke sjekker mellomrom. Legg så til and " " not in passord og se at testen blir grønn, og at de gamle testene fortsatt er grønne.

Fra beskrivelse til tester

Når du får en beskrivelse av hva en funksjon skal gjøre, kan du gjøre den om til tester før du skriver noe. Se på denne beskrivelsen: Funksjonen skuddaar(aar) gir True hvis året er et skuddår. Et år er skuddår hvis det er delelig med \(4\), men ikke med \(100\), med mindre det er delelig med \(400\).

Hver del av beskrivelsen blir en test:

assert skuddaar(2024) is True    # delelig med 4
assert skuddaar(2023) is False   # ikke 4
assert skuddaar(1900) is False   # 100, ikke 400
assert skuddaar(2000) is True    # delelig med 400

Merk at du må tenke gjennom beskrivelsen for å finne eksemplene, og da oppdager du ofte uklarheter før du har skrevet kode. Gjelder regelen for negative år? Hva med år \(0\)? Kravene blir til tester som alle kan se.

Når passer det?

Testdrevet utvikling passer godt når:

  • du vet hva funksjonen skal gjøre, men ikke helt hvordan,
  • funksjonen har klare regler og mange grensetilfeller (valideringer, beregninger, tekstbehandling),
  • du skal rette en feil: skriv først en test som viser feilen, og rett så koden til testen er grønn. Da er du sikker på at feilen ikke kommer tilbake.

Det passer dårligere når du utforsker og ikke vet hva du vil ha ennå (prøve ut en idé, tegne grafikk, lage et brukergrensesnitt). Da er det greit å skrive koden først, og legge til tester når du vet hva som skal bli. Det viktigste er ikke rekkefølgen, men at du har tester.

AdvarselVanlige feil
  • Å skrive all koden først, og så testene så de passer. Da tester du det koden gjør, ikke det den skal gjøre.
  • Å ikke kjøre testen og se at den er rød, så du ikke vet om den tester noe.
  • Å skrive mer kode enn testen krever. Skriv bare det som trengs for å bli grønn.
  • Å hoppe over refaktoreringen, så koden blir rotete.
  • Å skrive for mange tester om gangen. Ta én om gangen.
  • Å glemme grensetilfellene: tom liste, null, negative tall.

Oppgaver

Start på nivå 1. Når du får til de fleste oppgavene på et nivå, går du videre til neste. Utfordringene til slutt er for deg som vil prøve deg på noe vanskeligere.

Nivå 1

Forklar med egne ord hva som skjer i hver fase av syklusen, og hvorfor testen skal være rød først.

Tenk på hva en test som aldri har feilet, kan fortelle deg.

I den røde fasen skriver du en test for noe funksjonen skal gjøre, og ser at den feiler. I den grønne fasen skriver du akkurat nok kode til at testen består. I refaktoreringsfasen rydder du opp i koden uten å endre hva den gjør, og testene sikrer at du ikke ødelegger noe. Testen skal være rød først fordi du da vet at den faktisk sjekker noe: en test som aldri har feilet, kan være feil og passere uansett hva koden gjør.

Funksjonen rabatt(belop) skal gi \(10\) % rabatt på beløp på \(500\) kroner eller mer, og ellers ingen rabatt. Skriv fire assert-tester som tester funksjonen, inkludert grensen.

Test et lite beløp, et stort beløp og nøyaktig \(500\).

assert rabatt(100) == 0      # for lite
assert rabatt(1000) == 100   # 10 prosent av 1000
assert rabatt(500) == 50     # grensen er med
assert rabatt(499) == 0      # like under grensen

Grensetilfellene er \(500\) og \(499\): de avgjør om funksjonen bruker >= eller >.

Nivå 2

Per bygger funksjonen er_partall(n) med testdrevet utvikling:

def test_partall():
    assert er_partall(4) is True

def er_partall(n):
    return n % 2 == 0

Han skriver funksjonen først og så testen, og testen er grønn med en gang. Hva er det som gjør dette til dårlig testdrevet utvikling, og hva burde han gjort?

Hvilken farge hadde testen første gang?

Han har aldri sett testen feile, så han vet ikke om den tester noe. Han burde skrevet testen først, kjørt den (rød fordi er_partall ikke fantes), og så skrevet funksjonen til testen ble grønn. Han bør også legge til flere tester, for eksempel for oddetall, null og negative tall.

Skriv tester for funksjonen er_primtall(n) (et primtall er et helt tall større enn \(1\) som bare er delelig med \(1\) og seg selv) før du skriver funksjonen. Ta med minst fem tester som dekker vanlige tilfeller og grensetilfeller.

Tenk på små tall som \(0\), \(1\) og \(2\), et oddetall som ikke er et primtall, og et stort primtall.

assert er_primtall(2) is True    # det minste primtallet
assert er_primtall(17) is True   # et vanlig primtall
assert er_primtall(15) is False  # delelig med 3 og 5
assert er_primtall(1) is False   # 1 er ikke et primtall
assert er_primtall(0) is False   # 0 er ikke et primtall
assert er_primtall(-7) is False  # negative tall er ikke primtall
assert er_primtall(4) is False   # partall over 2

Mange feil gjemmer seg i \(0\), \(1\), \(2\) og negative tall.

Kodeoppgaver

Disse oppgavene rettes automatisk. Noen ber deg skrive testene først (de rettes mot en riktig funksjon og feilaktige versjoner), og noen ber deg skrive funksjonen etter at testene er gitt.

Beskrivelsen: er_skuddaar(aar) gir True hvis året er delelig med \(4\), men ikke med \(100\), med mindre det er delelig med \(400\). Skriv testfunksjonen test_skuddaar() før du skriver funksjonen. Rettingen bytter ut funksjonen med både riktige og feilaktige versjoner.

Lag én test per del av beskrivelsen: delelig med \(4\) (2024), ikke delelig med \(4\) (2023), delelig med \(100\) (1900) og delelig med \(400\) (2000).

Nå skal du skrive funksjonen er_skuddaar(aar) slik at testene fra forrige oppgave består.

(aar % 4 == 0 and aar % 100 != 0) or aar % 400 == 0.

Beskrivelsen: snu_ord(tekst) gir en tekst der ordene står i motsatt rekkefølge. "en to tre" blir "tre to en". Skriv test_snu_ord() før du skriver funksjonen.

Test en tekst med flere ord der rekkefølgen ikke er alfabetisk (som "en to tre"), én tekst med ett ord, og en tom tekst.

Skriv snu_ord(tekst) slik at disse testene består:

assert snu_ord("en to tre") == "tre to en"
assert snu_ord("hei") == "hei"
assert snu_ord("") == ""

tekst.split() gir lista med ord. Snu den og sett den sammen med " ".join(...).

Lag fizzbuzz(n) som gir "Fizz" hvis n er delelig med \(3\), "Buzz" hvis den er delelig med \(5\), "FizzBuzz" hvis begge, og ellers tallet som tekst. Disse testene er gitt, men rettingen har flere:

assert fizzbuzz(3) == "Fizz"
assert fizzbuzz(5) == "Buzz"
assert fizzbuzz(7) == "7"

Sjekk tilfellet med begge først (delelig med \(15\)). Gir du "Fizz" før du har sjekket \(15\), får du feil svar for \(15\).

Utfordringer

Beskrivelsen: er_gyldig(passord) gir True for passord med minst \(8\) tegn, minst ett siffer og minst én stor bokstav. Skriv test_gyldig() og funksjonen er_gyldig. Testene dine rettes mot riktige og feilaktige versjoner, og funksjonen din rettes mot en fasit.

Start med testene, ett tilfelle per regel: gyldig, for kort, uten tall, uten stor bokstav, og nøyaktig \(8\) tegn. Skriv så funksjonen.

Funksjonen siste_n(liste, n) skal gi de \(n\) siste elementene, men siste_n([1, 2, 3], 0) gir [1, 2, 3] i stedet for en tom liste. Forklar hvordan du retter feilen med testdrevet utvikling, og hvorfor det er bedre enn å rette koden direkte.

Først skriver du en test som viser feilen: assert siste_n([1, 2, 3], 0) == []. Den er rød (viser at du har funnet feilen). Så retter du koden, for eksempel return liste[len(liste) - n:] if n > 0 else [], til testen er grønn. Til slutt kjører du alle testene og ser at du ikke har ødelagt noe. Det er bedre enn å rette direkte fordi du vet at du har rettet den feilen, og fordi testen blir værende og sørger for at feilen aldri kommer tilbake uten at du merker det.

Oppsummering

Syklusen

  1. Rød: skriv en test, se at den feiler
  2. Grønn: skriv akkurat nok kode
  3. Refaktorer: rydd, og kjør testene

Fra krav til test

Hver del av beskrivelsen blir en test, også grensetilfellene.

Rette en feil

  1. Skriv en test som viser feilen
  2. Rett koden til testen er grønn
  3. Behold testen
  • Se alltid testen feile før du skriver koden.
  • Skriv bare så mye kode at testen blir grønn.
  • Den viktigste fordelen: du må tenke gjennom kravene først.

4.6 Bruk det i prosjektene

ProsjektIngen nye prosjektsteg

Ingen prosjektsteg bygger bare på dette kapittelet og kapitlene før.

Kapittelet brukes også i

4.7 Oppgaver

Disse oppgavene blander temaene fra hele kapittelet. Flere oppgaver finner du i notatboka (lenkene øverst i kapittelet).

Hvilket verktøy fra kapittelet passer best i hver situasjon: print, debuggeren, en test, try/except eller raise?

Brukeren skriver abc der programmet ber om en alder.

Tenk på om feilen kommer fra brukeren eller fra koden, og om du vil forstå eller forhindre.

try/except: brukerens inndata er noe programmet må tåle.

Du vil forsikre deg om at en funksjon fortsatt virker etter at du har endret den.

Tenk på om feilen kommer fra brukeren eller fra koden, og om du vil forstå eller forhindre.

En test (assert/pytest): kjør den hver gang du endrer koden.

En løkke gir feil svar i runde \(37\), og du skjønner ikke hvorfor.

Tenk på om feilen kommer fra brukeren eller fra koden, og om du vil forstå eller forhindre.

Debuggeren, med et betinget brytepunkt (i == 37), slik at du ser alle variablene akkurat der det blir galt.

En funksjon får tallet \(-5\) som alder, og dette skal aldri skje.

Tenk på om feilen kommer fra brukeren eller fra koden, og om du vil forstå eller forhindre.

raise ValueError(...): funksjonen avviser ugyldig inndata med en tydelig melding.

Du vil raskt se hva en variabel er, midt i et lite program.

Tenk på om feilen kommer fra brukeren eller fra koden, og om du vil forstå eller forhindre.

print: raskt og enkelt for små ting.

Funksjonen skal gi minste tall, største tall og gjennomsnitt som en ordbok, eller None for en tom liste. Den har to feil.

Test med [2, 4, 6]. Er summen riktig før du deler? Hvilken operator deler du med?

Lag funksjonen les_alder(tekst) som gjør teksten om til en alder. Er teksten ikke et heltall, utløser den ValueError("Alderen må være et heltall"). Er tallet ikke mellom \(0\) og \(120\), utløser den ValueError("Alderen må være mellom 0 og 120").

Prøv int(tekst) i en try-blokk, og utløs ValueError med riktig melding i except. Sjekk grensene etterpå.

Beskrivelsen: er_palindrom(ord) gir True hvis ordet er det samme forfra og bakfra, uten å bry seg om store og små bokstaver. Skriv test_palindrom() og funksjonen er_palindrom.

Test et palindrom, et som ikke er det, en med store bokstaver, tom tekst og et ord der første og siste bokstav er like, men midten ikke stemmer.

Bruk det du har lært på biblioteket du lagde i 3.2.2.

  1. Skriv pytest-tester for snitt, median og variasjonsbredde, med grensetilfeller og pytest.raises for tom liste (utløs ValueError for tom liste hvis den ikke gjør det allerede).
  2. Legg inn en feil med vilje i median (for eksempel ved å ikke sortere lista), og se at testene dine finner den.
  3. Bruk debuggeren til å finne ut hvorfor funksjonen gir feil svar for [3, 1, 2]: sett et brytepunkt, og følg verdiene.
  4. Rett feilen, og kjør testene på nytt.
  5. Lag en commit med meldingen «Test og rett median».

Testene feiler for median([3, 1, 2]), siden uten sortering blir det midterste elementet \(1\) i stedet for \(2\). I debuggeren ser du at lista ikke er sortert før indeksen brukes. Etter at du har rettet med sorted(tall), er alle testene grønne. Rekkefølgen er den du bruker i virkelige prosjekter: test finner feilen, debugger forklarer den, test bekrefter rettelsen, og Git tar vare på den.

4.8 Oppsummering

Feil og unntak

Tre typer feil

  • Syntaks: koden er ugyldig
  • Kjøretid: krasjer med unntak
  • Logisk: feil svar uten melding

Les en traceback

  1. Siste linje: hva
  2. Linja over: hvor
  3. Oppover: hvordan du kom dit

try og except

try:
    tall = int(tekst)
except ValueError:
    tall = None
else:
    ...
finally:
    ...

raise

if alder < 0:
    raise ValueError("Ugyldig alder")

Feilsøking

Prosessen

  1. Gjør feilen reproduserbar
  2. Les feilmeldingen
  3. Avgrens
  4. Lag en hypotese
  5. Test én ting
  6. Rett og kontroller
  7. Skriv en test

Debuggeren

  • F9 brytepunkt, F5 start
  • F10 Step Over, F11 Step Into
  • Variables, Watch, Call Stack

Testing

assert

def test_dobbel():
    assert dobbel(2) == 4
    assert dobbel(0) == 0

pytest

python -m pytest
with pytest.raises(ValueError):
    f(-1)

TDD

  1. Rød: skriv en test som feiler
  2. Grønn: akkurat nok kode
  3. Refaktorer
  • Fang bare unntakene du venter. Utløs unntak med tydelige meldinger.
  • Test vanlige tilfeller, grensetilfeller og feil.
  • Endre én ting om gangen når du feilsøker.