Hur man hanterar undantag i Python

Hur man hanterar undantag i Python

Undantagshantering är din förmåga att anpassa och visa felmeddelanden för delar av ditt program som inte fungerar.





Oavsett om du bygger en webbplats, skapar ett API, en modul eller någon annan produkt som använder Python, kan din förmåga att effektivt hantera undantag uttryckligen ange orsaken till ett fel.





Här tar vi en titt på hur du kan hantera undantag i Python.





Hur undantagshantering fungerar i Python

När du tar upp undantag säger du till Python att ta fram ett meddelande när ett kodblock misslyckas. Undantagshantering är som att säga till någon att försöka lyfta en vikt. Och om de inte kan, bör de meddela dig.

För att göra ett undantag i Python säger du dock till Python att försöka köra ett särskilt kodblock. Om blocket misslyckas kan du sedan be Python att höja ett definierat undantag från den misslyckade koden.



När ska du använda undantag i Python -programmering?

Vid de flesta tillfällen kan du maskera standard Python -fel med undantag. Men du måste vara vaksam, eftersom detta kan orsaka felsökningsproblem. Därför kan du ha svårt att ta reda på orsaken till en eventuell bugg.

Därför bör du använda undantag när du har testat koden tillräckligt och du är säker på att den fungerar. I slutändan är det bästa praxis att använda dem för att hantera potentiella fel som kan uppstå från användarens slut snarare än själva koden.





Med andra ord kan du använda undantag som ett varningsverktyg för att vägleda användare om hur du använder ditt program.

Hantering av Python -undantag

För att hantera undantag i Python måste du först slå in din kod i en försök ... utom blockera. Ibland kan du behöva inkludera en till sist uttalande för att hantera ytterligare åtgärder, beroende på dina behov.





Kodningskonceptet för Python -undantag ser i allmänhet ut så här:

try:
'code to be executed'
except:
'error message'

Som nämnts tidigare kan du också använda till sist i ett undantagsblock. Men koden skriver du inuti ett till sist klausul är oberoende och kör om det finns ett undantag eller inte.

I huvudsak är det praktiskt om du har ett annat kodblock som du vill köra kontinuerligt oavsett vad som händer inom försök ... utom blockera.

Här är ett exempel:

try:
print(9+6)
except:
print('error message')
finally:
print('please restart')
Output:
15
please restart

I koden ovan, snälla starta om körs kontinuerligt, oavsett om det finns ett undantag eller inte.

Ett annan tillstånd kan också följa en bortsett från påstående:

try:
C = 2 + B
except:
print('B needs to be defined')
else:
print(u'Added successfully! The result is %s'%(C))
Output: B needs to be defined

Försök nu igen med 'B' definierat:

try:
B = 5
C = 2 + B
except:
print('B needs to be defined')
else:
print(u'Added successfully! The result is %s'%(C))
Output: Added successfully! The result is 7

Ovanstående exempel är ostandardiserade undantag. Men du kan ha ett mer tydligt undantag när du kombinerar inbyggda (definierade) undantag med ostandardiserade:

try:
C = 2 + B
except NameError as err:
print(err, ':', 'B needs to be defined, please')
else:
print(u'Added successfully! The result is %s'%(C))
Output: name 'B' is not defined : B needs to be defined, please

Ovanstående undantag kontrollerar först om det finns ett NameError i Prova blockera. Det skriver sedan ut standarden NameError undantag först ('namn' B 'är inte definierat'). Och stöder det med ditt skriftliga undantag ('B måste definieras, tack').

Relaterat: Grundläggande programmeringsprinciper som alla programmerare måste veta

kan inte ladda ner appar från play store

Och om du vill hantera en kedja av undantag kan du också följa med a Prova blockera med många bortsett från uttalanden. Detta är ganska praktiskt om din Prova block har potential att ha många undantag:

try:
B = 5
C = 2 + B
D = float(6)
F = 7/0
except NameError as err:
print(err,':', 'B needs to be defined, please')
except ValueError as val:
print(val,':', 'You can't convert that data')
except ZeroDivisionError as zeroerr:
print(zeroerr,':', 'You can't divide a number by zero')
else:
print(u'Operation successfull! The results are: %s, %s, and %s'%(C, D, F))
Output: division by zero : You can't divide a number by zero

Vad händer om uppdelningen är giltig? Till exempel byta ut F = 7/0 i koden ovan med F = 7/5 ger:

Output: Operation successfull! The results are: 7, 6.0, and 1.4

Användardefinierade undantag i Python

Du kan också komma med ditt undantag och ringa dem senare i ditt program. Detta låter dig ge en specifik beskrivning av ditt undantag och namnge det som du vill.

Ändå kommer alla användardefinierade undantag (direkt eller indirekt) fortfarande från det inbyggda Undantag klass av Python.

Exempelkoden nedan hänvisar till basen Undantag direkt genom att ringa RuntimeError från det:

class connectionError(RuntimeError):
def __init__(self, value):
self.value = value
try:
raise connectionError('Bad hostname')
except connectionError as err:
print(err.value)
Output: Bad hostname

Anteckna det Anslutningsfel , i det här fallet, är en användardefinierad klass, som du kan höja när du behöver den i ditt program.

Relaterad: Nybörjarguiden för reguljära uttryck med Python

Du kan göra ett användardefinierat undantag genom att härleda det direkt från Undantag basklass. Undantaget nedan förhindrar dock subtraktion av 5 från 6 och kallar undantaget från basklassen direkt:

class errors(Exception):
pass
class sixFiveError(errors):
def __init__(self, value, message):
self.value = value
self.message = message
try:
raise sixFiveError(6-5,'This substraction is not allowed')
except sixFiveError as e:
print('There was an error:', e.message)
Output: There was an error: This substraction is not allowed

I praktiken kan du använda ett undantag som du definierade tidigare genom att anropa det i en annan funktion. Till exempel kan du skapa en floatError som bara tillåter tillägg av två flottörer:

# First call the base exception classes:
class errors(Exception):
pass
# Next, derive your own exception from the base class:
class FloatError(errors):
def __init__(self, value, message):
self.value = value
self.message = message
# Create a function to add two floats:
def addTwoFloat(a, b):
if (type(a) and type(b)) != float:
raise FloatError(a+b,'Numbers must be float to add')
else:
print(a + b)
addTwoFloat(4, 7)
Output: __main__.FloatError: (11, 'Numbers must be float to add')

Eftersom du nu har definierat a FloatError klass, höjer Python det om du försöker lägga till två icke-flytande bokstäver med addtwoFloat fungera.

Du kan skriva ut FloatError klass i samma Python -fil som du har skapat den för att se vad som händer:

print(FloatError)
Output:

FloatError är dock inte ett inbyggt Python-undantag. Du kan verifiera detta genom att ringa FloatError i en annan färsk Python -fil där du inte har skapat den här klassen:

print(FloatError)
Output: NameError: name 'FloatError' is not defined

Du får en NameError eftersom Python inte känner igen det som ett standardundantag.

Du kan också försöka självdefiniera andra felklasser för att se hur de fungerar.

Gör dina Python-program mer användarvänliga med undantag

Det finns många standardundantag i Python. Men du kan också definiera din. Det enkla att använda ditt program beror dock till viss del på hur det hanterar olika undantag (oavsett om det är användardefinierat, ospecifikt eller standard).

Med undantag kan du dock diktera hur ditt program ska fungera när användare interagerar med dem. Att tydligt och koncist ange orsaken till ett fel ger också användarna en uppfattning om vad de gör fel, och ibland pekar det dem i rätt riktning.

Dela med sig Dela med sig Tweet E-post Hur felsöker du din Python -kod

Utrusta dig själv med kunskapen för att krossa varje Python-bugg på din väg.

Läs Nästa
Relaterade ämnen
  • Programmering
  • Pytonorm
  • Handledning för kodning
Om författaren Idisou Omisola(94 artiklar publicerade)

Idowu brinner för allt smart teknik och produktivitet. På fritiden leker han med kodning och byter till schackbrädet när han har tråkigt, men han älskar också att bryta sig från rutinen då och då. Hans passion för att visa människor vägen kring modern teknik motiverar honom att skriva mer.

Mer från Idowu Omisola

Prenumerera på vårt nyhetsbrev

Gå med i vårt nyhetsbrev för tekniska tips, recensioner, gratis e -böcker och exklusiva erbjudanden!

Klicka här för att prenumerera