a = 8
b = 5
snitt = a + b / 2
print(snitt)10.5
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.
Etter å ha arbeidet med kapittelet skal du kunne
try og except, og utløse dem med raise,assert og pytest,Før du kan rette en feil, må du vite hva slags feil det er. Her lærer du å lese det Python forteller deg.
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.
Etter dette delkapittelet skal du kunne
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å.
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:
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:
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?
print("Hei)liste = [1, 2, 3] og print(liste[5])range(1, 10) og gir \(45\).Starter programmet? Krasjer det? Gir det riktig svar?
Syntaksfeil. Anførselstegnet er aldri lukket, så Python kan ikke lese koden og programmet starter ikke.
Kjøretidsfeil (IndexError). Koden er gyldig, men lista har bare indeks \(0\), \(1\) og \(2\), så programmet krasjer på den linja.
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.
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:
ZeroDivisionError: division by zero sier hva som gikk galt: feiltypen og en kort melding.line 2) og selve koden.print(rapport([])) på linje \(9\), så rapport som kalte snitt på linje \(6\), og til slutt divisjonen på linje \(2\).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'
Les siste linje, og se så på linja like over.
KeyError.
På linje \(4\), i funksjonen pris_for. Den ble kalt fra linje \(7\).
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.
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:
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.
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.
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).
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).
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
rapport kalt?
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.
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.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.
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.
Tre typer feil
Les en traceback
Vanlige unntak
NameError TypeError ValueError
IndexError KeyError
ZeroDivisionError
AttributeError
FileNotFoundError
Finne logiske feil
Test med enkle tall der du kjenner svaret, og sammenlign.
Noen feil kan du ikke unngå, som at brukeren skriver noe ugyldig. Her lærer du å fange unntak og å utløse dem selv.
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.
Det der var ikke et tall
Programmet fortsetter
Programmet krasjer ikke. Linja int("abc") feiler, men feilen blir fanget, og programmet fortsetter videre.
Etter dette delkapittelet skal du kunne
try og except til å fange unntak og la programmet fortsette,as,else og finally,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.
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.
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:
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):.
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:
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.
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.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.
Gå gjennom hvert kall for seg. Når x er \(0\), feiler divisjonen, og resten av try-blokken hoppes over.
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.
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:
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:
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.
except: som skjuler skrivefeil og andre uventede feil. Skriv alltid typen.except ValueError hjelper ikke hvis feilen er en TypeError.try-blokken, så du ikke vet hvilken linje som feilet. Hold den kort.except ValueError: pass) uten å tenke over konsekvensen.try der en enkel if er tydeligere.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.
Når int feiler, hoppes resten av try-blokken over.
13
Ferdig
13
Ferdig
"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?
abc der du ventet et tall, og du bruker int.
Se på lista over vanlige unntak i forrige delkapittel.
ValueError
Se på lista over vanlige unntak i forrige delkapittel.
ZeroDivisionError
Se på lista over vanlige unntak i forrige delkapittel.
KeyError
Se på lista over vanlige unntak i forrige delkapittel.
FileNotFoundError
Programmet skal skrive Ikke et tall hvis brukeren ikke skriver et tall, men krasjer for noen inndata.
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.
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.
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.
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.
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.
try-blokken kort.except: skjuler feil du burde oppdage.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.
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.
Etter dette delkapittelet skal du kunne
raise, med en passende type og en tydelig melding,None,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.
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.
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.
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.
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:
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.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.
Skal funksjonen utløse et unntak eller gi None når noe ikke går? En god tommelfingerregel:
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.
finn_navn(liste, navn) leter etter et navn i en liste, og navnet finnes kanskje ikke.sett_alder(alder) får tallet \(-3\).del(a, b) får \(b = 0\).Er «ingen treff» et normalt utfall, eller er kallet ugyldig?
None. At navnet ikke finnes, er et normalt utfall av et søk.
raise ValueError. \(-3\) er ikke en gyldig alder, og kallet bør ikke ignoreres.
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.
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.
raise "feil" gir TypeError: exceptions must derive from BaseException. Skriv raise ValueError("feil").Exception) når en mer presis finnes.assert til å kontrollere brukerens inndata.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.
Hvilken unntakstype passer best?
Er typen feil, eller verdien?
ValueError (typen er riktig, verdien ugyldig).
"hei".
Er typen feil, eller verdien?
TypeError (feil type).
Er typen feil, eller verdien?
FileNotFoundError.
Er typen feil, eller verdien?
KeyError (nøkkelen finnes ikke), eller ValueError med en tydelig melding.
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.
Funksjonen skal utløse en ValueError med meldingen for liten, men krasjer med en annen feil.
Hva må stå etter raise?
TypeError: exceptions must derive from BaseException. Du kan bare utløse unntak, ikke en tekst.
Hva må stå etter raise?
raise ValueError("for liten").
Hva er galt med denne feilmeldingen, og hvordan forbedrer du den?
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.
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(...).
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.
Typer
ValueError TypeError
IndexError KeyError
FileNotFoundError
raise eller None?
raiseNoneassert er for tester, raise er for å avvise ugyldig inndata.Her lærer du en systematisk måte å finne feil på, og å bruke debuggeren i VS Code.
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.
Etter dette delkapittelet skal du kunne
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.
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:
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:
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.
Prøv med storste([-5, -2, -8]). Hva er resultat underveis?
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.
Er programmet stort, hjelper det ikke å lese alt. Du må snevre inn hvor feilen er. Noen triks:
git diff nøyaktig hva som er endret.Se på et program med tre trinn som sammen gir feil svar:
['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.
Mange feil er variasjoner over de samme temaene. Når du står fast, sjekk dem først:
range som er én for mye eller for lite.i i stedet for tall[i], eller en variabel med nesten samme navn."10" er ikke 10. Skriv ut type(x) hvis du er usikker.==: = og == blandet, eller and og or byttet.summen = 0 står inne i løkka.b = a kopierer ikke lista.// og /, eller avrunding.Noen ganger hjelper ikke prosessen, og du har sett på det samme så lenge at du ikke ser det lenger. Da kan disse hjelpe:
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.
Sett trinnene i riktig rekkefølge for å finne og rette en feil:
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.
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\).
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 //.
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.
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.
Prosessen
Avgrense
Sjekk først
off-by-one, feil variabel, feil type, = mot ==, nullstilt variabel, kopi av liste, innrykk.
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.
Etter dette delkapittelet skal du kunne
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:
Kjører du programmet, skriver det 10. Vi finner feilen med debuggeren.
summen += i (linje 4). Det dukker opp en rød prikk. Programmet vil stoppe der. Du kan også trykke F9 på linja.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:
På Mac må du kanskje holde inne fn for å bruke F-tastene.
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:
summen + i eller i % 2 == 0, og debuggeren regner det ut for deg hver gang den stopper.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.
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:
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].
if som ikke er sann. Da stopper aldri programmet.print, og havner i Python sin egen kode. Bruk Step Over, eller Step Out for å komme ut.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.
Hvilken knapp (eller hurtigtast) bruker du til å
Se på lista over knappene tidligere i delkapittelet.
Step Over (F10)
Se på lista over knappene tidligere i delkapittelet.
Step Into (F11)
Se på lista over knappene tidligere i delkapittelet.
Continue (F5)
Se på lista over knappene tidligere i delkapittelet.
Step Out (Shift+F11)
Se på lista over knappene tidligere i delkapittelet.
F9, eller klikk i margen.
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
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.
summer.py med programmet fra delkapittelet, og åpne mappa i VS Code.summen += i og start debuggeren med F5.i og summen ved hvert stopp.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.
snitt og rapport fra delkapittelet.print(rapport(...))), og start debuggeren.snitt. Hva viser Call Stack?sum(tall) i Watch. Hva er verdien?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.
summen += i med betingelsen i == 50.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\)).
Programmet skal telle hvor mange ganger hvert ord forekommer, men gir feil. Bruk debuggeren til å finne feilen.
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.
Starte
Knappene
Panelene
Mer
i == 50Tester lar datamaskinen sjekke at koden din virker, hver gang du endrer den. Her skriver du dem med assert og pytest.
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.
Etter dette delkapittelet skal du kunne
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.
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:
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.
Det er ikke nok å teste at funksjonen virker for ett eksempel. Gode tester dekker tre typer tilfeller:
De fleste feil skjuler seg i grensetilfellene. Se på denne funksjonen:
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:
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.
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 lagres unøyaktig, så 0.1 + 0.2 == 0.3 er False. Når du tester desimaltall, bruker du math.isclose i stedet for ==:
Skal du teste at funksjonen utløser et unntak, kan du bruke dette mønsteret:
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.
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:
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.
== på desimaltall. Bruk math.isclose.assert, og skrive bare er_partall(4) == True, som ikke sjekker noe.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.
Funksjonen er
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).
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).
Du har skrevet disse testene for funksjonen siste(liste), som gir det siste elementet i lista:
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.
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).
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:
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.
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.
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.
Etter dette delkapittelet skal du kunne
pytest.raises, og desimaltall med pytest.approx,parametrize,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:
Så fila med testene, test_regning.py:
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.
test_*.py (eller *_test.py).test_*.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:
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.
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:
..FFFFF viser at de to første testene gikk bra (.) og at fem feilet (F).test_er_partall sier hvilken test som feilet.> viser hvilken linje i testen som feilet: assert er_partall(4) is True.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
Se på linjene som starter med E.
Testen test_dele, på linje \(7\) i test_regning.py.
dele(10, 4) ga 2.5, men testen ventet \(2\).
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.
Desimaltall. For desimaltall bruker du pytest.approx i stedet for ==:
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:
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
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.
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.No module named pytest).== på desimaltall. Bruk pytest.approx.regning.py og regning.py), så importen går feil.assert funksjon(x) == y uten å importere funksjonen.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.
Pytest skriver ut
test_regning.py ..F.F [100%]
Hvilke av disse vil pytest finne og kjøre?
test_dele.py med funksjonen test_dele()
Både filnavnet og funksjonsnavnet må følge reglene.
Ja.
dele_test.py med funksjonen test_dele()
Både filnavnet og funksjonsnavnet må følge reglene.
Ja: pytest godtar også *_test.py.
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.
test_dele.py med funksjonen sjekk_dele()
Både filnavnet og funksjonsnavnet må følge reglene.
Nei: funksjonen må starte med test_.
____________________ 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)
Se på overskriften og linjene som starter med E.
Testen med tall = 0 og forventet = True.
er_partall, og hva forventet testen?
Se på overskriften og linjene som starter med E.
er_partall(0) ga False, men testen forventet True.
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
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.
pip install pytest).regning.py med funksjonene dele og er_partall fra delkapittelet.test_regning.py med testene fra delkapittelet, og kjør python -m pytest.er_partall slik at den har en feil (n % 2 == 1) og kjør testene på nytt. Les feilrapporten.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.
test_statistikk.py med minst to tester per funksjon, inkludert grensetilfeller (ett element, negative tall).pytest.raises til å teste en tom liste, hvis funksjonene utløser unntak.parametrize til å teste median med minst fem ulike lister.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) == forventetKjører du python -m pytest, skal alle testene bestå. Hvis noen feiler, viser rapporten hvilken liste som ga feil svar.
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.
Kjøre
pip install pytest
python -m pytest
python -m pytest -v
Testfil
Filen: test_*.py. Funksjonen: test_*.
. er en test som gikk bra, F en som feilet. Les linjene som starter med E.python -m pytest, eller legg testfila ved siden av modulen.Her snur du rekkefølgen: du skriver testen først, og koden etterpå.
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.
Etter dette delkapittelet skal du kunne
Testdrevet utvikling går i en liten syklus som du gjentar mange ganger:
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:
Runde 1. Vi skriver testen først, for et gyldig passord. Funksjonen finnes ikke ennå:
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:
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:
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:
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").
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:
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:
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.
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:
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.
Testdrevet utvikling passer godt når:
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.
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.
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\).
Per bygger funksjonen er_partall(n) med testdrevet utvikling:
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 2Mange feil gjemmer seg i \(0\), \(1\), \(2\) og negative tall.
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.
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:
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\).
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.
Syklusen
Fra krav til test
Hver del av beskrivelsen blir en test, også grensetilfellene.
Rette en feil
Ingen prosjektsteg bygger bare på dette kapittelet og kapitlene før.
Kapittelet brukes også i
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?
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.
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.
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.
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.
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.
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).median (for eksempel ved å ikke sortere lista), og se at testene dine finner den.[3, 1, 2]: sett et brytepunkt, og følg verdiene.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.
Tre typer feil
Les en traceback
Prosessen
Debuggeren
TDD