Comment gérer les exceptions en Python
La gestion des exceptions est votre capacité à personnaliser et à afficher les messages d'erreur pour les parties de votre programme qui ne fonctionnent pas.
Que vous construisiez un site Web, créiez une API, un module ou tout autre produit utilisant Python, votre capacité à gérer efficacement les exceptions vous permet d'indiquer explicitement la cause d'une erreur.
Ici, nous allons voir comment vous pouvez gérer les exceptions en Python.
Comment fonctionne la gestion des exceptions en Python
Lorsque vous déclenchez des exceptions, vous dites à Python d'afficher un message chaque fois qu'un bloc de code échoue. La gestion des exceptions, c'est comme dire à quelqu'un d'essayer de soulever un poids. Et s'ils ne peuvent pas, ils devraient vous le faire savoir.
Pour lever une exception dans Python, cependant, vous direz à Python d'essayer d'exécuter un bloc de code particulier. Si ce bloc échoue, vous pouvez alors demander à Python de lever une exception définie pour le code ayant échoué.
Quand devriez-vous utiliser des exceptions dans la programmation Python ?
Dans la plupart des cas, vous pouvez masquer les erreurs Python standard à l'aide d'exceptions. Mais vous devez rester vigilant, car cela peut entraîner des problèmes de débogage. Par conséquent, vous pourriez avoir du mal à déterminer la cause première d'un éventuel bogue.
Par conséquent, vous devez utiliser des exceptions lorsque vous avez suffisamment testé votre code et que vous êtes sûr qu'il fonctionne. En fin de compte, il est préférable de les utiliser pour gérer les erreurs potentielles pouvant survenir de la part de l'utilisateur plutôt que du code lui-même.
En d'autres termes, vous pouvez utiliser les exceptions comme outil d'avertissement pour guider les utilisateurs sur la façon d'utiliser votre programme.
Gestion des exceptions Python
Pour gérer les exceptions en Python, vous devez d'abord envelopper votre code dans un bloc try…except . De temps en temps, vous devrez peut-être inclure une instruction finally pour gérer d'autres actions, en fonction de vos besoins.
Le concept de codage des exceptions Python ressemble généralement à ceci :
try:
"code to be executed"
except:
"error message"
Comme mentionné précédemment, vous pouvez également utiliser finally dans un bloc d'exception. Mais le code que vous écrivez dans une clause finally est indépendant et s'exécute qu'il y ait une exception ou non.
En substance, cela est pratique si vous avez un autre bloc de code que vous souhaitez exécuter en continu, indépendamment de ce qui se passe dans le bloc try…except .
Voici un exemple :
try:
print(9+6)
except:
print("error message")
finally:
print("please restart")
Output:
15
please restart
Dans le code ci-dessus, veuillez redémarrer les exécutions en continu, qu'il y ait ou non une exception.
Une condition else peut également suivre une instruction except :
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
Maintenant, essayez à nouveau avec "B" défini :
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
Les exemples ci-dessus sont des exceptions non standardisées. Mais vous pouvez avoir une exception plus explicite lorsque vous combinez des exceptions intégrées (définies) avec des exceptions non standardisées :
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
L'exception ci-dessus vérifie d'abord s'il y a une NameError dans le bloc try . Il imprime ensuite d' abord l' exception NameError standard (" le nom 'B' n'est pas défini"). Et le prend en charge avec votre exception écrite ("B doit être défini, s'il vous plaît").
Et si vous souhaitez gérer une chaîne d'exceptions, vous pouvez également accompagner un bloc try avec de nombreuses instructions except . C'est assez pratique si votre bloc try a le potentiel d'avoir de nombreuses exceptions :
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
Et si la division était valide ? Par exemple, remplacer F = 7/0 dans le code ci-dessus par F = 7/5 donne :
Output: Operation successfull! The results are: 7, 6.0, and 1.4
Exceptions définies par l'utilisateur en Python
Vous pouvez également proposer votre exception et les appeler plus tard dans votre programme. Cela vous permet de donner une description spécifique de votre exception et de la nommer comme vous le souhaitez.
Néanmoins, chaque exception définie par l'utilisateur (directement ou indirectement) provient toujours de la classe Exception intégrée de Python.
L'exemple de code ci-dessous fait directement référence à l' exception de base en appelant RuntimeError à partir de celle-ci :
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
Notez que connectionError , dans ce cas, est une classe définie par l'utilisateur, que vous pouvez augmenter chaque fois que vous en avez besoin dans votre programme.
Vous pouvez créer une exception définie par l'utilisateur en la dérivant directement de la classe de base Exception . L'exception ci-dessous, cependant, empêche la soustraction de 5 à 6 et appelle directement l'exception de la classe de base :
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
En pratique, vous pouvez utiliser une exception que vous avez définie précédemment en l'appelant dans une autre fonction. Par exemple, vous pouvez créer une floatError qui n'autorise que l'ajout de deux flottants :
# 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')
Comme vous avez maintenant défini une classe FloatError , Python la déclenche si vous essayez d'ajouter deux littéraux non flottants à l'aide de la fonction addtwoFloat .
Vous pouvez imprimer la classe FloatError dans le même fichier Python où vous l'avez créée pour voir ce qui se passe :
print(FloatError)
Output: <class '__main__.FloatError'>
FloatError , cependant, n'est pas une exception Python intégrée. Vous pouvez le vérifier en appelant FloatError dans un autre nouveau fichier Python où vous n'avez pas créé cette classe :
print(FloatError)
Output: NameError: name 'FloatError' is not defined
Vous obtenez une NameError car Python ne la reconnaît pas comme une exception standard.
Vous pouvez également essayer d'auto-définir d'autres classes d'erreurs pour voir comment elles se produisent.
Rendez vos programmes Python plus conviviaux avec des exceptions
Il existe de nombreuses exceptions standard en Python. Mais vous pouvez également définir le vôtre. Néanmoins, la facilité d'utilisation de votre programme dépend dans une certaine mesure de la façon dont il gère diverses exceptions (qu'elles soient définies par l'utilisateur, non spécifiques ou standard).
Les exceptions, cependant, vous permettent de dicter comment votre programme doit fonctionner lorsque les utilisateurs interagissent avec eux. L'indication claire et concise de la cause d'une erreur donne également aux utilisateurs une idée de ce qu'ils font mal, et parfois, cela les oriente dans la bonne direction.