Sådan håndteres undtagelser i Python

Undtagelseshåndtering er din evne til at tilpasse og vise fejlmeddelelser for dele af dit program, der ikke fungerer.

Uanset om du bygger et websted, laver et API, et modul eller et andet produkt ved hjælp af Python, kan din evne til effektivt at håndtere undtagelser eksplicit angive årsagen til en fejl.

Her ser vi på, hvordan du kan håndtere undtagelser i Python.

Sådan fungerer håndteringen af undtagelser i Python

Når du rejser undtagelser, fortæller du Python at sende en besked, når en kodeblok mislykkes. Undtagelseshåndtering er som at fortælle nogen at prøve at løfte en vægt. Og hvis de ikke kan, skal de give dig besked.

For at hæve en undtagelse i Python vil du dog fortælle Python at prøve at køre en bestemt kodeblok. Hvis denne blok mislykkes, kan du derefter bede Python om at hæve en defineret undtagelse fra den mislykkede kode.

Hvornår skal du bruge undtagelser i Python -programmering?

Ved de fleste lejligheder kan du maskere standard Python -fejl ved hjælp af undtagelser. Men du skal være opmærksom, da dette kan forårsage fejlfindingsproblemer. Derfor kan det være svært for dig at finde ud af årsagen til en eventuel fejl.

Derfor bør du bruge undtagelser, når du har testet din kode tilstrækkeligt, og du er sikker på, at den virker. I sidste ende er det bedste praksis at bruge dem til at håndtere potentielle fejl, der kan opstå fra brugerens ende frem for selve koden.

Med andre ord kan du bruge undtagelser som et advarselsværktøj til at guide brugere til, hvordan du bruger dit program.

Håndtering af Python -undtagelser

For at håndtere undtagelser i Python skal du først pakke din kode ind i en prøv ... undtagen blok. Indimellem skal du muligvis inkludere en endelig erklæring til at håndtere yderligere handlinger, afhængigt af dine behov.

Kodningskonceptet for Python -undtagelser ser generelt sådan ud:

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

Som tidligere nævnt kan du også bruge endelig i en undtagelsesblok. Men koden skriver du inde i et endelig klausul er uafhængig og kører, uanset om der er en undtagelse eller ej.

I det væsentlige er det praktisk, hvis du har en anden kodeblok, som du vil køre løbende, uanset hvad der sker inden for prøv ... undtagen blok.

Her er et eksempel:

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

I ovenstående kode, genstart venligst kører kontinuerligt, uanset om der er en undtagelse eller ej.

An andet tilstand kan også følge en undtagen udmelding:

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

Prøv det igen med 'B' defineret:

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

Ovenstående eksempler er ikke -standardiserede undtagelser. Men du kan have en mere eksplicit undtagelse, når du kombinerer indbyggede (definerede) undtagelser med ustandardiserede:

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

Ovenstående undtagelse kontrollerer først, om der er en Navnefejl i prøve blok. Det udskriver derefter standarden Navnefejl undtagelse først ('navn' B 'er ikke defineret'). Og understøtter det med din skriftlige undtagelse ('B skal defineres, tak').

Relateret: Grundlæggende programmeringsprincipper, som hver programmerer skal vide

hvordan flytter jeg apps til mit sd -kort

Og hvis du vil håndtere en kæde af undtagelser, kan du også ledsage a prøve blokere med mange undtagen udsagn. Dette er ret praktisk, hvis din prøve blok har potentialet til at have mange undtagelser:

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

Hvad hvis opdelingen er gyldig? For eksempel udskiftning F = 7/0 i ovenstående kode med F = 7/5 giver:

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

Brugerdefinerede undtagelser i Python

Du kan også komme med din undtagelse og ringe til dem senere i dit program. Dette lader dig give en specifik beskrivelse af din undtagelse og navngive den som du vil.

Ikke desto mindre kommer alle brugerdefinerede undtagelser (direkte eller indirekte) stadig fra den indbyggede Undtagelse klasse af Python.

Eksempelkoden nedenfor henviser til basen Undtagelse direkte ved at ringe RuntimeError fra 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

Noter det forbindelsesfejl , i dette tilfælde er en brugerdefineret klasse, som du kan hæve når som helst du har brug for det i dit program.

Relaterede: Begynderguiden til regulære udtryk med Python

Du kan foretage en brugerdefineret undtagelse ved at udlede den direkte fra Undtagelse grundklasse. Undtagelsen nedenfor forhindrer imidlertid subtraktion af 5 fra 6 og kalder undtagelsen fra basisklassen direkte:

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 praksis kan du bruge en undtagelse, du tidligere har defineret, ved at kalde den i en anden funktion. For eksempel kan du oprette en floatError der kun tillader tilføjelse af to floats:

# 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')

Fordi du nu har defineret a FloatError klasse, hæver Python det, hvis du forsøger at tilføje to ikke-flydende bogstaver ved hjælp af addtwoFloat fungere.

Du kan udskrive FloatError klasse i den samme Python -fil, hvor du har oprettet den for at se, hvad der sker:

print(FloatError)  
  Output:

FloatError er dog ikke en indbygget Python-undtagelse. Du kan bekræfte dette ved at ringe FloatError i en anden frisk Python -fil, hvor du ikke har oprettet denne klasse:

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

Du får en Navnefejl fordi Python ikke genkender det som en standard undtagelse.

Du kan også prøve at definere andre fejlklasser for at se, hvordan de spiller ud.

Gør dine Python-programmer mere brugervenlige med undtagelser

Der er mange standard undtagelser i Python. Men du kan også definere din. Ikke desto mindre afhænger brugervenligheden af dit program i nogen grad af, hvordan det håndterer forskellige undtagelser (uanset om det er brugerdefineret, ikke-specifikt eller standard).

Undtagelser lader dig dog diktere, hvordan dit program skal fungere, når brugere interagerer med dem. Tydeligt og kortfattet angiver årsagen til en fejl også brugerne et indblik i, hvad de gør forkert, og nogle gange peger det dem i den rigtige retning.

Del Del Tweet E -mail Sådan fejler du din Python -kode

Udstyr dig med knowhow til at squash hver Python-fejl på din vej.

Læs Næste Relaterede emner

Programmering
Python
Kodning Tutorials

Om forfatteren Idisou Omisola(94 artikler udgivet)

Idowu brænder for alt smart teknologi og produktivitet. I fritiden leger han med kodning og skifter til skakbrættet, når han keder sig, men han elsker også at bryde væk fra rutinen en gang imellem. Hans passion for at vise folk vejen rundt om moderne teknologi motiverer ham til at skrive mere.

Mere fra Idowu Omisola

Abonner på vores nyhedsbrev

Tilmeld dig vores nyhedsbrev for at få tekniske tips, anmeldelser, gratis e -bøger og eksklusive tilbud!

Klik her for at abonnere