Effektiv feilsøking med Python Assert Statement

Er du en programmerer? I så fall er feilsøking en essensiell ferdighet, uavhengig av språket du koder i. I denne artikkelen vil du lære hvordan du bruker påstandssetningen i Python for effektiv feilsøking.

Når du jobber med et prosjekt, vil du definere flere moduler. Dette inkluderer funksjoner, klassedefinisjoner og mer. Og du vil sannsynligvis støte på feil eller uventede resultater på grunn av en feil i implementeringen. Påstandssetninger er nyttige for å feilsøke slik kode.

I denne opplæringen lærer vi syntaksen for å bruke assert-setningen etterfulgt av kodeeksempler for å se den i aksjon. Vi vil også se hva påstandsfeil er og hvordan vi kan bruke dem til å fikse feilene i kode under utvikling.

La oss begynne!

Slik bruker du påstandserklæringen i Python

Vi lærer syntaksen for å bruke assert-setningen, og fortsetter deretter med å kode noen eksempler.

Syntaks for påstandserklæringen

La oss starte med syntaksen for å bruke assert-setningen i Python:

assert expression, message

Her,

• uttrykk er et hvilket som helst gyldig Python-uttrykk som skal evalueres. Dette kan være en betingelse for verdien av variabel, sannhetsverdi av variabel, returverdi fra en funksjon og mer.
• Så lenge uttrykket evalueres til True, gir ikke påstandssetningen en feil eller returnerer noe. Dette indikerer at programmet fungerer som forventet.
• Hvis uttrykket ikke lenger er sant, oppstår et AssertionError-unntak.
• melding er en valgfri streng. Du kan spesifisere en melding som vises i tilbakesporingen hver gang et AssertionError-unntak oppstår.

Deretter går vi videre til å kode noen eksempler der assert-setningen kan hjelpe oss med å skrive renere og feilfri kode.

Du kan finne kodeeksemplene som brukes i denne opplæringen i denne GitHub-konsernet.

Eksempler på Pythons påstandsuttalelse

Tenk på følgende eksempel. La oss si at du har en rabattvariabel i koden din. Men du vil at verdien alltid skal være mindre enn eller lik max_discount.

For å sjekke at du ved et uhell ikke setter rabattvariabelen til en verdi, kan du legge til en påstand. Uttrykket som skal evalueres er: rabatt <= maks_rabatt.

>>> max_discount = 50
>>> discount = 20
>>> assert discount <= max_discount

Her er rabatt (20) mindre enn max_discount (50). Så påstandssetningen gir ingen feil.

AssertionError-unntaket

Hvis rabattvariabelen er satt til en verdi større enn max_discount, oppstår et AssertionError-unntak.

>>> discount = 75
>>> assert discount <= max_discount
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError

Vi vet at assert-setningen også lar oss spesifisere en valgfri meldingsstreng.

La oss også bruke en meldingsstreng som gir en mer beskrivende diagnostisk informasjon. La oss legge til en Python f-streng som også inneholder verdiene for rabatt og max_discount til påstandssetningen.

>>> assert discount <= max_discount, f"discount should be at most {max_discount}; got discount = {discount}"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AssertionError: discount should be at most 50; got discount = 75

Som vist i utdatacellen ovenfor, inkluderer AssertionError-unntaket nå verdiene til variablene rabatt og max_discount.

Feilsøking og testing av Python-funksjoner med Assert

Når du definerer funksjoner, kan du noen ganger utilsiktet introdusere bugs (logiske feil) som vil hindre funksjonen din i å fungere etter hensikten.

La oss ta et eksempel. Anta at det er en test i en klasse og elevene får en sjanse til å prøve et bonusspørsmål. Enhver student som prøver bonusspørsmålet vil få 10 tilleggskarakterer i testen. 😄

Tenk på følgende funksjon get_final_score:

• Den tar inn en gjeldende poengsum, poengsum og en boolsk bonus.
• Hvis en student har svart på bonusspørsmålet, er den boolske bonusen Sann, og de får 10 poeng mer enn nåværende poengsum.
• Funksjonen returnerer deretter sluttresultatet.

def get_final_score(score,bonus):
    if bonus:
        score += 10
    return score

La oss ringe til funksjonen. Vi ser at for poengsummer på 34 og 40 med bonus satt til True og False, er sluttresultatene henholdsvis 44 og 40.

print(get_final_score(34,True))
# 44
print(get_final_score(40,False))
# 40

Imidlertid er maksimalpoengene på testen for eksempel 50. Så hvis en student scorer 49 og også har svart på bonusspørsmålet, vil funksjonen get_final_score gjerne beregne den endelige poengsummen til 59.

print(get_final_score(49,True))
# 59

Teknisk sett er det mulig. Men la oss anta at en student ikke kan score mer enn maksimalt mulig poeng for prøven. 🙂

Så la oss initialisere en max_score-variabel. Og fange opp den returnerte poengsummen fra funksjonen i final_score-variabelen.

Deretter legger vi til en påstand som sjekker om final_score er mindre enn max_score.

def get_final_score(score,bonus):
    if bonus:
        score += 10
    return score

final_score = get_final_score(47,True)
max_score = 50

assert final_score <= max_score

Vi får nå et AssertionError-unntak for funksjonskallet get_final_score(47,True):

Traceback (most recent call last):
  File "main.py", line 17, in <module>
    assert final_score <= max_score
AssertionError

Nå legger vi til en beskrivende f-streng til Python-påstanden:

assert final_score <= max_score,f"final_score should be at most {max_score}; got {final_score}"

Traceback (most recent call last):
  File "main.py", line 17, in <module>
    assert final_score <= max_score,f"final_score should be at most {max_score}; got {final_score}"
AssertionError: final_score should be at most 50; got 57

Endre funksjonen

La oss gå tilbake og endre definisjonen av get_final_score-funksjonen for å fikse den uventede oppførselen:

• Funksjonen get_final_score tar også max_score som parameter.
• Vi sjekker om bonusen er sann. Hvis det er sant, legger vi til 10 poeng til poengvariabelen.
• Deretter sjekker vi om poengsummen er større enn max_score. I så fall returnerer vi max_score.
• Ellers returnerer vi poengsum.

Vi har nå sørget for at sluttpoengsummen alltid er mindre enn eller lik max_score.

def get_final_score(score,bonus,max_score):
    if bonus:
        score += 10
    if score > max_score:
        return max_score
    return score

Som en rask øvelse, skriv noen påstander for å bekrefte at funksjonen nå fungerer som forventet.

En merknad om AssertionError Unntak

Selv om et AssertionError-unntak oppstår når uttrykket evalueres til False, bør vi huske å ikke håndtere slike feil som unntak. Det betyr at vi ikke bør gjøre noe slikt:

try:
    <doing this>
except AssertionError:
    <do this>

I det forrige eksemplet på get_final_score brukte vi påstanden for å sjekke om final_score er mindre enn max_score. Deretter modifiserte vi funksjonsdefinisjonen slik at det ikke er noen påstandsfeil.

Det er det påstander er til for. De er fornuftssjekker for kode, og hjelper til med å skrive renere kode. Unntakshåndtering er på den annen side å forutse og håndtere uventede feil under kjøring. Disse inkluderer ofte ugyldige inndatatyper og verdier.

For å oppsummere, bør du bruke Python assert-setningen for effektiv feilsøking og ikke håndtere AssertionErrors som unntak.

Konklusjon

Denne opplæringen hjalp deg med å forstå hvordan du bruker assert-setningen i Python. Her er et sammendrag av det du har lært:

• Python assert-utsagn (påstander) har formen assert-uttrykk. Dette sjekker om uttrykket er sant. Hvis det ikke evalueres til True, oppstår et AssertionError-unntak.
• Du kan også bruke assert med syntaks assert uttrykk, melding. Dette vil skrive ut meldingsstrengen hver gang et AssertionError-unntak oppstår.
• Du bør huske å ikke implementere unntakshåndtering for å håndtere påstandsfeil. Og bruk påstander som et nyttig feilsøkingsverktøy for sunnhetssjekker av koden din.

Som utvikler hjelper påstander deg med feilsøking. For å sikre at alle de enkelte komponentene (modulene) i prosjektet fungerer som forventet, kan du lære hvordan du skriver enhetstester i Python.

Deretter kan du sjekke ut denne listen over nybegynnere Python-prosjekter du kan jobbe med.