Effektiv felsökning med Python Assert Statement

Är du en programmerare? Om så är fallet är felsökning en viktig färdighet, oavsett vilket språk du kodar i. I den här artikeln kommer du att lära dig hur du använder assert-satsen i Python för effektiv felsökning.

När du arbetar med ett projekt kommer du att definiera flera moduler. Detta inkluderar funktioner, klassdefinitioner och mer. Och du kommer sannolikt att stöta på fel eller oväntade resultat på grund av en bugg i implementeringen. Assert-satser är användbara vid felsökning av sådan kod.

I den här handledningen lär vi oss syntaxen för att använda assert-satsen följt av kodexempel för att se den i aktion. Vi kommer också att se vad påståendefel är och hur vi kan använda dem för att fixa felen i koden under utveckling.

Låt oss börja!

Hur man använder Assert Statement i Python

Vi lär oss syntaxen för att använda assert-satsen och fortsätter sedan med att koda några exempel.

Syntax för Assert Statement

Låt oss börja med syntaxen för att använda assert-satsen i Python:

assert expression, message

Här,

  • expression är vilket giltigt Python-uttryck som helst som ska utvärderas. Detta kan vara ett villkor för variabelns värde, sanningsvärdet för variabeln, returvärde från en funktion och mer.
  • Så länge uttrycket evalueras till True, ger inte assert-satsen ett fel eller returnerar något. Detta indikerar att programmet fungerar som förväntat.
  • Om uttrycket inte längre är True, uppstår ett AssertionError-undantag.
  • meddelande är en valfri sträng. Du kan ange ett meddelande som visas i spåret tillbaka när ett AssertionError-undantag uppstår.

Låt oss sedan fortsätta med att koda några exempel där assert-satsen kan hjälpa oss att skriva renare och felfri kod.

Du kan hitta kodexemplen som används i den här handledningen i denna GitHub-uppgift.

Pythons påstående uttalande exempel

Betrakta följande exempel. Säg att du har en rabattvariabel i din kod. Men du vill att dess värde alltid ska vara mindre än eller lika med max_discount.

För att kontrollera att du av misstag inte ställer in rabattvariabeln till ett värde kan du lägga till ett påstående. Uttrycket att utvärdera är: rabatt <= max_rabatt.

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

Här är rabatt (20) mindre än max_rabatt (50). Så assert-satsen ger inget fel.

Undantaget AssertionError

Om rabattvariabeln sätts till ett värde som är större än max_discount, uppstår ett AssertionError-undantag.

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

Vi vet att assert-satsen också tillåter oss att ange en valfri meddelandesträng.

Låt oss också använda en meddelandesträng som ger en mer beskrivande diagnostisk information. Till påstående uttalandet, låt oss lägga till en Python f-sträng som också innehåller värdena rabatt och max_rabatt.

>>> 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 framgår av utdatacellen ovan inkluderar AssertionError-undantaget nu värdena för variablerna rabatt och max_rabatt.

Felsökning och testning av Python-funktioner med Assert

När du definierar funktioner kan du ibland oavsiktligt introducera buggar (logiska fel) som hindrar din funktion från att fungera som avsett.

Låt oss ta ett exempel. Anta att det är ett prov i en klass och eleverna får en chans att prova en bonusfråga. Varje student som försöker bonusfrågan får ytterligare 10 poäng i provet. 😄

Tänk på följande funktion get_final_score:

  • Det tar in en aktuell poäng, poäng och en boolesk bonus.
  • Om en elev har svarat på bonusfrågan är den booleska bonusen Sann, och de får 10 poäng mer än sin nuvarande poäng.
  • Funktionen returnerar sedan slutresultatet.
def get_final_score(score,bonus):
    if bonus:
        score += 10
    return score

Låt oss ringa några anrop till funktionen. Vi ser att för poäng på 34 och 40 med bonus satt till Sant och Falskt är slutresultatet 44 respektive 40.

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

Men maxpoängen på testet är, säg, 50. Så om en elev får 49 poäng och även har svarat på bonusfrågan kommer funktionen get_final_score gärna att beräkna slutpoängen till 59.

print(get_final_score(49,True))
# 59

Tekniskt sett är det möjligt. Men låt oss anta att en elev inte kan få mer än högsta möjliga poäng för provet. 🙂

Så låt oss initiera en max_score-variabel. Och fånga den returnerade poängen från funktionen i variabeln final_score.

Därefter lägger vi till ett påstående som kontrollerar om final_score är mindre än 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 nu ett AssertionError-undantag för funktionsanropet get_final_score(47,True):

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

Nu lägger vi till en beskrivande f-sträng till Python assert-satsen:

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

Ändra funktionen

Låt oss gå tillbaka och ändra definitionen av funktionen get_final_score för att fixa det oväntade beteendet:

  • Funktionen get_final_score tar också max_score som parameter.
  • Vi kontrollerar om bonusen är sann. Om det är sant lägger vi till 10 poäng till poängvariabeln.
  • Sedan kontrollerar vi om poängen är större än max_score. Om så är fallet returnerar vi max_score.
  • Annars returnerar vi poäng.

Vi har nu sett till att slutresultatet alltid är mindre än eller lika med 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 snabb övning, skriv några påståenden för att bekräfta att funktionen nu fungerar som förväntat.

En anmärkning om undantag för AssertionError

Även om ett AssertionError-undantag uppstår när uttrycket evalueras till False, bör vi komma ihåg att inte hantera sådana fel som undantag. Det betyder att vi inte ska göra något så här:

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

I det föregående exemplet på get_final_score använde vi påståendet för att kontrollera om final_score är mindre än max_score. Sedan modifierade vi funktionsdefinitionen så att det inte finns några påståendefel.

Det är vad påståenden är till för. De är förnuftskontroller för kod och hjälper till att skriva renare kod. Undantagshantering, å andra sidan, är att förutse och hantera oväntade fel vid körning. Dessa inkluderar ofta ogiltiga indatatyper och värden.

Sammanfattningsvis bör du använda Python assert-satsen för effektiv felsökning och inte hantera AssertionErrors som undantag.

Slutsats

Den här handledningen hjälpte dig att förstå hur du använder assert-satsen i Python. Här är en sammanfattning av vad du har lärt dig:

  • Python assert-satser (påståenden) har formen assert-uttryck. Detta kontrollerar om uttrycket är sant. Om det inte utvärderas till True, uppstår ett AssertionError-undantag.
  • Du kan också använda assert med syntaxen assert uttryck, meddelande. Detta kommer att skriva ut meddelandesträngen närhelst ett AssertionError-undantag inträffar.
  • Du bör komma ihåg att inte implementera undantagshantering för att hantera påståendefel. Och använd påståenden som ett användbart felsökningsverktyg för förnuftskontroller av din kod.

Som utvecklare hjälper påståenden dig med felsökning. För att säkerställa att alla enskilda komponenter (moduler) i projektet fungerar som förväntat kan du lära dig hur du skriver enhetstester i Python.

Kolla sedan in den här listan över Python-projekt för nybörjare som du kan arbeta med.