Uitzonderingen afhandelen in Python

Afhandeling van uitzonderingen is uw vermogen om foutmeldingen aan te passen en weer te geven voor delen van uw programma die niet werken.

Of u nu een website bouwt, een API, een module of een ander product maakt met Python, dankzij uw vermogen om effectief met uitzonderingen om te gaan, kunt u expliciet de oorzaak van een fout aangeven.

Hier bekijken we hoe u met uitzonderingen in Python om kunt gaan.

Hoe het afhandelen van uitzonderingen werkt in Python

Wanneer je uitzonderingen maakt, vertel je Python om een ​​bericht naar voren te brengen wanneer een codeblok faalt. Het afhandelen van uitzonderingen is als iemand vertellen dat hij moet proberen een gewicht op te tillen. En als ze dat niet kunnen, moeten ze je dat laten weten.

Om echter een uitzondering in Python op te werpen, vertel je Python om te proberen een bepaald codeblok uit te voeren. Als dat blok faalt, kun je Python vragen om een ​​gedefinieerde uitzondering op de mislukte code te maken.

Wanneer moet u uitzonderingen gebruiken in Python-programmering?

In de meeste gevallen kunt u standaard Python-fouten maskeren met uitzonderingen. Maar je moet waakzaam blijven, omdat dit foutopsporingsproblemen kan veroorzaken. Daarom kan het moeilijk zijn om de hoofdoorzaak van een eventuele bug te achterhalen.

Daarom moet u uitzonderingen gebruiken wanneer u uw code voldoende hebt getest en u zeker weet dat deze werkt. Uiteindelijk is het de beste gewoonte om ze te gebruiken om mogelijke fouten af ​​te handelen die kunnen ontstaan ​​aan de kant van de gebruiker in plaats van aan de code zelf.

Met andere woorden, u kunt uitzonderingen gebruiken als waarschuwingstool om gebruikers te begeleiden bij het gebruik van uw programma.

Python-uitzonderingen afhandelen

Om uitzonderingen in Python af te handelen, moet je eerst je code in een probeer...behalve blok. Af en toe moet u misschien een Tenslotte verklaring om verdere acties af te handelen, afhankelijk van uw behoeften.

Het coderingsconcept van Python-uitzonderingen ziet er over het algemeen als volgt uit:

proberen:
"code die moet worden uitgevoerd"
behalve:
"foutmelding"

Zoals eerder vermeld, kunt u ook gebruik maken van Tenslotte in een uitzonderingsblok. Maar de code die je erin schrijft a Tenslotte clausule is onafhankelijk en wordt uitgevoerd, ongeacht of er een uitzondering is of niet.

In wezen is het handig als je een ander codeblok hebt dat je continu wilt uitvoeren, ongeacht wat er gebeurt binnen de probeer...behalve blok.

Hier is een voorbeeld:

proberen:
afdrukken (9+6)
behalve:
print("foutmelding")
Tenslotte:
print("start opnieuw")
Uitgang:
15
alsjeblieft begin opnieuw 

In de bovenstaande code, alsjeblieft begin opnieuw loopt continu, ongeacht of er een uitzondering is of niet.

Een anders conditie kan ook volgen behalve uitspraak:

proberen:
C = 2 + B
behalve:
print("B moet worden gedefinieerd")
anders:
print (u"Succesvol toegevoegd! Het resultaat is %s"%(C))
Uitgang: B moet worden gedefinieerd

Probeer dat nu opnieuw met "B" gedefinieerd:

proberen:
B = 5
C = 2 + B
behalve:
print("B moet worden gedefinieerd")
anders:
print (u"Succesvol toegevoegd! Het resultaat is %s"%(C))
Uitgang: Succesvol toegevoegd! Het resultaat is 7

Bovenstaande voorbeelden zijn niet-gestandaardiseerde uitzonderingen. Maar u kunt een meer expliciete uitzondering hebben wanneer u ingebouwde (gedefinieerde) uitzonderingen combineert met niet-gestandaardiseerde:

proberen:
C = 2 + B
behalve NameError als err:
print (err, ":", "B moet worden gedefinieerd, alstublieft")
anders:
print (u"Succesvol toegevoegd! Het resultaat is %s"%(C))
Uitgang: naam 'B' is niet gedefinieerd: B moet worden gedefinieerd, alstublieft

De bovenstaande uitzondering controleert eerst of er een Naamfout in de proberen blok. Het drukt vervolgens de standaard af Naamfout uitzondering eerst ("naam 'B' is niet gedefinieerd"). En ondersteunt het met uw schriftelijke uitzondering ("B moet worden gedefinieerd, alstublieft").

Verwant: Basis programmeerprincipes die elke programmeur moet kennen

En als u een reeks uitzonderingen wilt afhandelen, kunt u ook een proberen blok met velen behalve verklaringen. Dit is best handig als je proberen blok heeft het potentieel om veel uitzonderingen te hebben:

proberen:
B = 5
C = 2 + B
D = vlotter (6)
F = 7/0
behalve NameError als err:
print (err,":", "B moet worden gedefinieerd, alstublieft")
behalve ValueError als val:
print (val,":", "U kunt die gegevens niet converteren")
behalve ZeroDivisionError als nulerr:
print (zeroer,":", "Je kunt een getal niet delen door nul")
anders:
print (u"Bewerking succesvol! De resultaten zijn: %s, %s en %s"%(C, D, F))
Uitgang: delen door nul: je kunt een getal niet delen door nul

Wat als de verdeling geldig is? Bijvoorbeeld het vervangen van F = 7/0 in de bovenstaande code met F = 7/5 geeft:

Uitgang: Operatie geslaagd! De resultaten zijn: 7, 6.0 en 1.4

Door de gebruiker gedefinieerde uitzonderingen in Python

U kunt ook uw uitzondering bedenken en deze later in uw programma bellen. Hiermee kunt u een specifieke beschrijving van uw uitzondering geven en deze een naam geven zoals u wilt.

Niettemin komt elke door de gebruiker gedefinieerde uitzondering (direct of indirect) nog steeds van de ingebouwde Uitzondering klasse van Python.

De voorbeeldcode hieronder verwijst naar de basis Uitzondering direct door te bellen RuntimeError daaruit:

klasse connectionError (RuntimeError):
def __init__(zelf, waarde):
zelf.waarde = waarde
proberen:
raise connectionError("Slechte hostnaam")
behalve verbindingsfout als fout:
afdrukken (foutwaarde)
Uitgang: Slechte hostnaam

Let daar op verbindingsfout, in dit geval, is een door de gebruiker gedefinieerde klasse, die u kunt verhogen wanneer u deze in uw programma nodig hebt.

Verwant: De beginnershandleiding voor reguliere expressies met Python

U kunt een door de gebruiker gedefinieerde uitzondering maken door deze rechtstreeks af te leiden van de Uitzondering basis klasse. De onderstaande uitzondering verhindert echter het aftrekken van 5 van 6 en roept de uitzondering rechtstreeks van de basisklasse op:

klasse fouten (uitzondering):
voorbij lopen
klasse sixFiveError (fouten):
def __init__(zelf, waarde, bericht):
zelf.waarde = waarde
zelf.bericht = bericht
proberen:
raise sixFiveError (6-5,"Deze aftrekking is niet toegestaan")
behalve sixFiveError als e:
print("Er is een fout opgetreden:", e.message)
Uitgang: Er is een fout opgetreden: Deze aftrekking is niet toegestaan

In de praktijk kunt u een eerder gedefinieerde uitzondering gebruiken door deze in een andere functie aan te roepen. U kunt bijvoorbeeld een floatError dat alleen de toevoeging van twee drijvers toestaat:

# Roep eerst de basisuitzonderingsklassen aan:
klasse fouten (uitzondering):
voorbij lopen
# Leid vervolgens uw eigen uitzondering af van de basisklasse:
klasse FloatError (fouten):
def __init__(zelf, waarde, bericht):
zelf.waarde = waarde
zelf.bericht = bericht
# Maak een functie om twee floats toe te voegen:
def addTwoFloat (a, b):
if (type (a) en type (b)) != float:
raise FloatError (a+b,"Getallen moeten zwevend zijn om toe te voegen")
anders:
afdrukken (a + b)
addTwoFloat (4, 7)
Uitgang: __main__.FloatError: (11, 'Getallen moeten zwevend zijn om toe te voegen')

Omdat je nu een. hebt gedefinieerd FloatError class, Python verhoogt het als je probeert om twee niet-float letterlijke waarden toe te voegen met behulp van de addtwoFloat functie.

U kunt de. afdrukken FloatError class in hetzelfde Python-bestand waarin je het hebt gemaakt om te zien wat er gebeurt:

afdrukken (FloatError)
Uitgang:

FloatError, is echter geen ingebouwde Python-uitzondering. U kunt dit verifiëren door te bellen met FloatError in een ander vers Python-bestand waarin je deze klasse niet hebt gemaakt:

afdrukken (FloatError)
Uitgang: NameError: naam 'FloatError' is niet gedefinieerd

Je krijgt een Naamfout omdat Python het niet als een standaarduitzondering herkent.

Je kunt ook proberen om andere foutklassen zelf te definiëren om te zien hoe ze uitpakken.

Maak uw Python-programma's gebruiksvriendelijker met uitzonderingen

Er zijn veel standaarduitzonderingen in Python. Maar u kunt de uwe ook definiëren. Desalniettemin hangt het gebruiksgemak van uw programma tot op zekere hoogte af van hoe het omgaat met verschillende uitzonderingen (door de gebruiker gedefinieerd, niet-specifiek of standaard).

Met uitzonderingen kunt u echter dicteren hoe uw programma moet werken wanneer gebruikers ermee omgaan. Het duidelijk en beknopt vermelden van de oorzaak van een fout geeft gebruikers ook een seintje over wat ze verkeerd doen, en soms wijst het hen in de goede richting.

Hoe u uw Python-code kunt debuggen

Rust jezelf uit met de knowhow om elke Python-bug op je pad te pletten.

Lees volgende

Over de auteur