💻 Bruke assertion

Målet med defensive programming er å prøve å maksimere påliteligheten og den generelle kvaliteten til et stykke programvare. For oss betyr dette at vi bør ta skritt for å håndtere uventede inputverdier i koden vår, og å gi nyttige feilmeldinger som gir meningsfull veiledning til brukeren når et program flagger et unntak. Vi kan ta skritt mot å skrive mer pålitelig programvare ved å bruke en nyttig funksjon i Python: “Assertions”.

Assertions/Påstander

Assertions/Påstander er en måte å hevde, eller sikre, at verdiene som brukes i skriptene dine kommer til å passe til det koden gjør. La oss starte med å vurdere funksjonen convert_kph_ms som konverterer vindhastigheter fra kilometer i timen til meter per sekund. Vi kan definere og bruke funksjonen vår i cellen under.

def convert_kmt_ms(speed):
    """Konverterer hastighet fra km/t til m/s"""
    return speed * 1000 / 3600


wind_speed_km = 9
wind_speed_ms = convert_kmt_ms(wind_speed_km)

print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

En vindhastighet på 9 km/t er 2.5 m/s.

Alt dette virker greit, men du vil kanskje sørge for at verdiene for vindhastigheten ikke er negative tall, siden hastigheten ganske enkelt er størrelsen på vindhastigheten, som alltid skal være positiv eller null. Vi kan håndheve denne betingelsen ved å legge til en påstand til funksjonen vår.

def convert_kmt_ms(speed):
    """Konverterer hastighet fra km/t til m/s"""
    assert speed >= 0.0
    return speed * 1000 / 3600


wind_speed_km = 9
wind_speed_ms = convert_kmt_ms(wind_speed_km)

print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

En vindhastighet på 9 km/t er 2.5 m/s.

OK, så alt fungerer fortsatt ved bruk av en positiv verdi, men hva skjer hvis vi nå gir en negativ verdi for vindhastigheten? La oss sjekke!

wind_speed_km = -27
wind_speed_ms = convert_kmt_ms(wind_speed_km)

print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Cell In[3], line 2
      1 wind_speed_km = -27
----> 2 wind_speed_ms = convert_kmt_ms(wind_speed_km)
      4 print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

Cell In[2], line 3, in convert_kmt_ms(speed)
      1 def convert_kmt_ms(speed):
      2     """Konverterer hastighet fra km/t til m/s"""
----> 3     assert speed >= 0.0
      4     return speed * 1000 / 3600

AssertionError: 

OK, så nå får vi en AssertionError når en negativ verdi er gitt. Denne AssertionError er produsert på grunn av assert-setningen vi skrev inn i funksjonsdefinisjonen. Hvis betingelsen som er oppført etter assert er usann, oppstår en AssertionError.

Dette er en klar forbedring, men det ville være mye bedre å gi brukeren litt informasjon om hvorfor denne påstanden eksisterer. Heldigvis kan vi gjøre dette ganske enkelt ved å legge til litt tekst etter påstandsbetingelsen.

def convert_kmt_ms(speed):
    """Konverterer hastighet fra km/t til m/s"""
    assert speed >= 0.0, "Vindhastighetsverdier må være positive eller null"
    return speed * 1000 / 3600


wind_speed_km = -27
wind_speed_ms = convert_kmt_ms(wind_speed_km)

print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Cell In[4], line 8
      4     return speed * 1000 / 3600
      7 wind_speed_km = -27
----> 8 wind_speed_ms = convert_kmt_ms(wind_speed_km)
     10 print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

Cell In[4], line 3, in convert_kmt_ms(speed)
      1 def convert_kmt_ms(speed):
      2     """Konverterer hastighet fra km/t til m/s"""
----> 3     assert speed >= 0.0, "Vindhastighetsverdier må være positive eller null"
      4     return speed * 1000 / 3600

AssertionError: Vindhastighetsverdier må være positive eller null

Fint! Nå ser vi at når AssertionError blir flagget, informerer meldingen oss om hvorfor det skjedde uten å måtte tolke koden. Meldingen gjør det også enkelt å fikse verdien for wind_speed_km for å fungere med funksjonen convert_kmt_ms.

Mer generelt har påstander følgende form:

assert <some condition>, "Error message to display"

Så vi starter med “assert”-setningen, og gir deretter en logisk test for en tilstand. Hvis testen er sann, skjer ingenting og koden fortsetter. Hvis ikke, stopper koden og en AssertionError vises med teksten skrevet etter kommaet på linjen som inneholder assert-setningen.

Flere påstander

Et dårlig eksempel

Selvfølgelig kan det være lurt å ha flere påstander i en funksjon for å sikre at den fungerer som forventet og gir meningsfulle verdier. I vårt tilfelle vil vi kanskje først sjekke at verdien som er oppgitt som skal konverteres, er et tall. Hvis ikke, ville vi ikke kunne konvertere enhetene. La oss legge til en ny påstand for å sikre at funksjonen vår er “trygg”.

def convert_kmt_ms(speed):
    """Konverterer hastighet fra km/t til m/s"""
    assert (
        type(speed) == int or type(speed) == float
    ), "Vindhastighetsverdier må være tall"
    assert speed >= 0.0, "Vindhastighetsverdier må være positive eller null"
    return speed * 1000 / 3600


wind_speed_km = "hund"
wind_speed_ms = convert_kmt_ms(wind_speed_km)

print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
Cell In[5], line 11
      7     return speed * 1000 / 3600
     10 wind_speed_km = "hund"
---> 11 wind_speed_ms = convert_kmt_ms(wind_speed_km)
     13 print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

Cell In[5], line 4, in convert_kmt_ms(speed)
      1 def convert_kmt_ms(speed):
      2     """Konverterer hastighet fra km/t til m/s"""
      3     assert (
----> 4         type(speed) == int or type(speed) == float
      5     ), "Vindhastighetsverdier må være tall"
      6     assert speed >= 0.0, "Vindhastighetsverdier må være positive eller null"
      7     return speed * 1000 / 3600

AssertionError: Vindhastighetsverdier må være tall

OK, så det fungerer. Nå, hvis brukeren prøver å gi en datatype som ikke er ‘int’ eller ‘float’, vil funksjonen flagge en ‘AssertionError’ som indikerer at et tall forventes for at funksjonen skal fungere. Dette er greit, men som nevnt nedenfor er det grunner til at du kanskje ikke vil inkludere påstander av denne typen i en funksjon.

Warning

Man kan forestille seg at det ville være nyttig å bruke en påstand for å sjekke typen til speed i vår funksjon for å sikre at man ikke får en TypeError som oppstod i forrige seksjon. Det viser seg at dette egentlig ikke er en god idé. Grunnen er at den filosofiske ideen bak en TypeError er å indikere at du har inkompatible datatyper. Med det i tankene, hvorfor skulle du da utløse en AssertionError for å gjøre det samme?

Et bedre eksempel

Så vi ønsker ikke å sjekke datatypekompatibiliteten vår ved å bruke påstander, men vi kan inkludere en påstand for å sikre at maksimum av vindhastigheten er et rimelig tall. I dette tilfellet kan vi anta at vindhastigheten som konverteres ble målt på jorden, og derfor bør være lavere enn den raskeste vindhastigheten somnoensinne har blitt målt, 408 km/t. La oss legge til den betingelsen.

def convert_kmt_ms(speed):
    """Konverterer hastighet fra km/t til m/s"""
    assert speed >= 0.0, "Vindhastighetsverdier må være positive eller null"
    assert speed <= 408.0, "Vindhastigheten er raskere enn noensinne målt tidligere"
    return speed * 1000 / 3600


wind_speed_km = "409"
wind_speed_ms = convert_kmt_ms(wind_speed_km)

print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[6], line 9
      5     return speed * 1000 / 3600
      8 wind_speed_km = "409"
----> 9 wind_speed_ms = convert_kmt_ms(wind_speed_km)
     11 print(f"En vindhastighet på {wind_speed_km} km/t er {wind_speed_ms} m/s.")

Cell In[6], line 3, in convert_kmt_ms(speed)
      1 def convert_kmt_ms(speed):
      2     """Konverterer hastighet fra km/t til m/s"""
----> 3     assert speed >= 0.0, "Vindhastighetsverdier må være positive eller null"
      4     assert speed <= 408.0, "Vindhastigheten er raskere enn noensinne målt tidligere"
      5     return speed * 1000 / 3600

TypeError: '>=' not supported between instances of 'str' and 'float'

Dette er et bedre eksempel av to grunner:

1. Vi tillater nå en TypeError når inkompatible datatyper brukes i funksjonen vår, som er en klar og kjent feilmelding.

2. Vi bruker påstander/assertion for å sjekke at verdiene som brukes i funksjonen gir mening for dens tiltenkte bruk. Hvis vi ønsker å hjelpe brukere med å konvertere vindhastigheter på jorden, gir vi grenser som sikrer at de bruker rimelige inputverdier. Dermed hjelper vi dem å bruke funksjonen vår på riktig måte.

Kombinert sikrer disse påstandene at funksjonen vår håndterer vanlige feil og gir brukeren nyttig tilbakemelding for å kunne bruke funksjonen riktig.

Note

En ting som er viktig å merke seg om påstander er at selv om vi bruker dem her for å sjekke at våre inputverdier er rimelige, er dette generelt sett ikke den anbefalte bruken. I stedet anbefaler mer avanserte programmerere å bruke påstander kun for å teste at koden din fungerer riktig internt. For eksempel ville du bruke påstander for å sjekke ting som ikke skal skje, slik som funksjoner som dupliserer verdier i lister når de ikke skal. Grunnen til at det ikke anbefales å bruke påstander for å teste brukerinputverdier eller eksistensen av filer, er at påstander kan deaktiveres ved bruk av flagg når man kjører et Python-program. Dermed er det mulig at de kan bli ignorert helt. Dette er greit når man feilsøker kode, men åpenbart ikke ønskelig når brukere kjører programmene dine. Hvis du er interessert i flere detaljer, kan du gjerne sjekke ut artikkelen om bruk av påstander i Python-wikien.

Mer informasjon om påstander

Mer informasjon om påstander finner du på Software Carpentry sin nettside.