Vous pouvez écrire des programmes qui gèrent les exceptions sélectionnées. Regardez l'exemple suivant, qui demande à l'utilisateur d'entrer un entier valide, mais permet à l'utilisateur d'interrompre le programme (avec Ctrl-C ou tout autre paramètre supporté par le système d'exploitation) ; cette interruption générée par l'utilisateur déclenche une exception d'interruption clavier :
>>> Alors que c'est vrai :
... Essayez-le :
... x = int(input("Enter a number : ")))))))
.... interruption
... sauf ValueError :
... imprimer ("Ups ! Ce n'était pas un numéro valide. Essayez encore...")
...
L'instruction de test fonctionne comme suit :
Tout d'abord, le bloc test est exécuté (l'instruction entre les mots-clés try et except).
Si aucune exception ne se produit, le bloc sauf est sauté et l'exécution de l'instruction test est terminée.
Si une exception se produit pendant l'exécution du bloc test, le reste du bloc est ignoré.
Si une exception qui n'est pas la même que l'exception dans le bloc se produit, elle est transmise aux instructions de test externes ; si aucune instruction de test correspondante n'est trouvée, l'exception est une exception non gérée et l'exécution du programme s'arrête avec un message d'erreur comme indiqué ci-dessus.
Une déclaration de test peut contenir plus d'un bloc pour spécifier différentes actions pour différentes exceptions. Au maximum un, sauf que le bloc est exécuté. Un bloc ne peut traiter que les exceptions survenues dans le bloc de test correspondant, et non celles qui surviennent dans un autre bloc sauf celui de la même déclaration de test. Un bloc, sauf qu'il peut aussi gérer plusieurs exceptions à la fois, ceci est spécifié dans un tuple :
... sauf (RuntimeError, TypeError, NameError) : .... pass
Le dernier bloc, sauf qu'il peut être laissé sans exception, agit comme un joker. Utilisez cette option avec précaution, car elle peut cacher de vraies erreurs de programmation ! De cette façon, vous pouvez également recevoir des messages d'erreur et ensuite lever à nouveau l'exception (afin que l'appelant puisse également gérer cette exception) :
importation
Essayez-le :
f = open('monfichier.txt')
s = f.readline()
i = int(s.strip())
sauf pour IOrror, car c'est faux :
print("Erreur E/S : {0}"".format(err))
sauf ValueError :
print("Impossible de convertir les données en entiers.")
sauf que :
print("Erreur inconnue :", sys.exc_info()[0]))
s'élever
Le test ........ à l'exception de l'instruction permet un autre bloc optionnel, qui, s'il est présent, doit être placé après les blocs sauf. Il est utile pour le code qui doit être exécuté si le bloc de test ne soulève pas d'exception. Par exemple :
pour arg dans sys.argv[1 :]:
Essayez-le :
f = ouvert (arg, "r")
sauf IOError :
print('Can', arg,'Can't open')
plus :
print(arg,'hat', len(f.readlines()),'lines')))
f.close()
L'utilisation d'un autre bloc est préférable à l'ajout de code supplémentaire au bloc de test. Il vous empêche de saisir accidentellement des exceptions qui n'ont pas été supprimées du code qui a été supprimé par le test..... sauf que l'instruction doit être protégée.
Lorsqu'une exception se produit, elle peut avoir une valeur associée, appelée argument exception. Le nom de la variable est lié à une instance d'exception et les arguments d'exception sont stockés dans instance.args. Pour une meilleure ergonomie, une instance d'exception définit __str__() pour que les arguments puissent être affichés directement sans se référer au fichier.args. Vous pouvez également instancier une exception avant de l'exécuter pour ajouter d'autres attributs si nécessaire :
>>> Essayez-le :
... faire des exceptions ('spam','oeufs')
.... sauf exception en ce qui concerne inst :
... imprime (tapez (inst)) # l'instance d'exception.
.... print(inst.args) # arguments stockés dans .args
... print(inst) # __str__ permet la sortie directe de .args,
... # Mais il peut être écrasé dans les sous-classes.
... x, y = inst.args # args de déballage
.... print('x =', x)
... imprimer ('y =', y)
...
<classe "Exception'>".
("Spam", "oeufs")
("Spam", "oeufs")
x = spam
y = oeufs
Si une exception a des arguments, ceux-ci sont affichés comme la dernière partie ("détail") du message d'erreur pour les exceptions non gérées.
Les gestionnaires d'exception traitent non seulement les exceptions qui surviennent directement dans le bloc de test, mais également les exceptions qui sont soulevées dans les appels de fonction (même indirectement) dans le bloc de test. Par exemple
>>> def this_fails() :
... x = 1/0
...
Essai >>>>> Essai :
.... this_fails()
... sauf ZeroDivisionError comme erroné :
.... print('Handle runtime error:', incorrectement)
Gestion des erreurs d'exécution : division interne ou module pour zéro
