Exceptions natives

En python, une exception est une instance d'une classe héritée de BaseException. Dans un bloc try, la clause except traite non seulement la classe d'exception qu'elle mentionne, mais aussi toutes les classes dérivées de cette classe (contrairement à ses classes mères). Deux classes qui ne sont pas liées par héritage ne sont jamais équivalentes, même si elles ont le même nom.

The built-in exceptions listed in this chapter can be generated by the interpreter or built-in functions. Except where mentioned, they have an "associated value" indicating the detailed cause of the error. This may be a string or a tuple of several items of information (e.g., an error code and a string explaining the code). The associated value is usually passed as arguments to the exception class's constructor.

Du code utilisateur peut lever des exceptions natives. Cela peut être utilisé pour tester un gestionnaire d'exception ou pour rapporter une condition d'erreur "comme si" c'était l'interpréteur qui levait cette exception ; mais attention car rien n'empêche du code utilisateur de lever une erreur inappropriée.

Les classes d'exception natives peuvent être héritées pour définir de nouvelles exceptions ; les programmeurs sont encouragés à faire dériver les nouvelles exceptions de la classe Exception ou d'une de ses sous-classes, et non de BaseException. Plus d'informations sur la définition des exceptions sont disponibles dans le Tutoriel Python au chapitre Exceptions définies par l'utilisateur.

Contexte des exceptions

Three attributes on exception objects provide information about the context in which the exception was raised:

BaseException.__context__
BaseException.__cause__
BaseException.__suppress_context__

When raising a new exception while another exception is already being handled, the new exception's __context__ attribute is automatically set to the handled exception. An exception may be handled when an except or finally clause, or a with statement, is used.

Ce contexte implicite d'exception peut être complété par une cause explicite en utilisant from avec raise :

raise new_exc from original_exc

The expression following from must be an exception or None. It will be set as __cause__ on the raised exception. Setting __cause__ also implicitly sets the __suppress_context__ attribute to True, so that using raise new_exc from None effectively replaces the old exception with the new one for display purposes (e.g. converting KeyError to AttributeError), while leaving the old exception available in __context__ for introspection when debugging.

The default traceback display code shows these chained exceptions in addition to the traceback for the exception itself. An explicitly chained exception in __cause__ is always shown when present. An implicitly chained exception in __context__ is shown only if __cause__ is None and __suppress_context__ is false.

Dans les deux cas, l'exception elle-même est toujours affichée après toutes les exceptions enchaînées, de sorte que la dernière ligne de la trace d'appels montre toujours la dernière exception qui a été levée.

Hériter des exceptions natives

Le code de l'utilisateur peut créer des sous-classes qui dérivent d'un type d'exception. Il est recommandé de ne dériver que d'un seul type d'exception à la fois pour éviter des conflits possibles dans la façon dont les classes mères traitent l'argument args ainsi que des incompatibilités potentielles avec l'utilisation de la mémoire.

Particularité de l'implémentation CPython : La majorité des exceptions natives sont implémentées en C pour des raisons d'efficacité, voir Objects/exceptions.c. L'architecture interne de certaines est telle que cela rend impossible la création de sous-classes qui dérivent de plusieurs types d'exceptions. L'agencement de la mémoire est un détail d'implémentation qui est sujet à changement d'une version de Python à l'autre, ce qui peut poser conflit dans le futur. Il est donc déconseillé de dériver de plusieurs types d'exceptions.

Classes mères

Les exceptions suivantes sont utilisées principalement en tant que classes mères pour d'autres exceptions.

exception BaseException

La classe mère pour toutes les exceptions natives. Elle n'est pas vouée à être héritée directement par des classes utilisateur (pour cela, utilisez Exception). Si str() est appelée sur une instance de cette classe, la représentation du ou des argument(s) de l'instance est retournée, ou la chaîne vide s'il n'y avait pas d'arguments.

args

Le n-uplet d'arguments donné au constructeur d'exception. Certaines exceptions natives (comme OSError) attendent un certain nombre d'arguments et attribuent une signification spéciale aux éléments de ce n-uplet, alors que d'autres ne sont généralement appelées qu'avec une seule chaîne de caractères rendant un message d'erreur.

with_traceback(tb)

Cette méthode affecte tb comme la nouvelle trace d'appels de l'exception et renvoie l'objet exception. Elle était utilisée de façon plus courante avant que la fonctionnalité de chaînage des exceptions de la PEP 3134 devienne disponible. L'exemple suivant démontre comment convertir une instance de SomeException en une instance de OtherException tout en préservant la pile d'appels. Une fois l'exception levée, le cadre courant est empilé sur la trace d'appels de OtherException, comme cela se serait produit pour la trace d'appels de SomeException si on l'avait laissée se propager jusqu'à l'appelant

try:
    ...
except SomeException:
    tb = sys.exception().__traceback__
    raise OtherException(...).with_traceback(tb)
__traceback__

A writable field that holds the traceback object associated with this exception. See also: L'instruction raise.

add_note(note)

Add the string note to the exception's notes which appear in the standard traceback after the exception string. A TypeError is raised if note is not a string.

Ajouté dans la version 3.11.

__notes__

A list of the notes of this exception, which were added with add_note(). This attribute is created when add_note() is called.

Ajouté dans la version 3.11.

exception Exception

Toutes les exceptions natives, qui n'entraînent pas une sortie du système dérivent de cette classe. Toutes les exceptions définies par l'utilisateur devraient également être dérivées de cette classe.

exception ArithmeticError

La classe mère pour les exceptions natives qui sont levées pour diverses erreurs arithmétiques : OverflowError, ZeroDivisionError, FloatingPointError.

exception BufferError

Levée lorsqu'une opération liée à un tampon ne peut pas être exécutée.

exception LookupError

La classe mère pour les exceptions qui sont levées lorsqu'une clé ou un index utilisé sur un tableau de correspondances ou une séquence est invalide : IndexError, KeyError. Peut être levée directement par codecs.lookup().

Exceptions concrètes

Les exceptions suivantes sont celles qui sont habituellement levées.

exception AssertionError

Levée lorsqu'une instruction assert échoue.

exception AttributeError

Levée lorsqu'une référence ou une assignation d'attribut (voir Références à des attributs) échoue. (Lorsqu'un objet ne supporte pas du tout la référence ou l'assignation d'attribut, TypeError est levé.)

Les attributs name et obj peuvent être définis uniquement à l'aide d'arguments nommés passés au constructeur. Lorsqu'ils sont définis, ils représentent respectivement le nom de l'attribut pour lequel il y a eu une tentative d'accès et l'objet qui a été accédé pour cet attribut.

Modifié dans la version 3.10: Ajout des attributs name et obj.

exception EOFError

Levée lorsque la fonction input() atteint une condition de fin de fichier (EOF) sans lire aucune donnée. (N.B. : les méthodes io.IOBase.read() et io.IOBase.readline() retournent une chaîne vide lorsqu'elles atteignent EOF.)

exception FloatingPointError

N’est pas utilisé pour le moment.

exception GeneratorExit

Levée lorsqu'un generator ou une coroutine est fermé, voir generator.close() et coroutine.close(). Elle hérite directement de BaseException au lieu de Exception puisqu'il ne s'agit pas techniquement d'une erreur.

exception ImportError

Levée lorsque l'instruction import a des problèmes pour essayer de charger un module. Également levée lorsque Python ne trouve pas un nom dans from ... import.

The optional name and path keyword-only arguments set the corresponding attributes:

name

The name of the module that was attempted to be imported.

path

The path to any file which triggered the exception.

Modifié dans la version 3.3: Ajout des attributs name et path.

exception ModuleNotFoundError

Une sous-classe de ImportError qui est levée par import lorsqu'un module n'a pas pu être localisé. Elle est généralement levée quand None est trouvé dans sys.modules.

Ajouté dans la version 3.6.

exception IndexError

Levée lorsqu'un indice de séquence est hors de la plage. (Les indices de tranches (slices) sont tronqués silencieusement pour tomber dans la plage autorisée ; si un indice n'est pas un entier, TypeError est levée.)

exception KeyError

Levée lorsqu'une clef (de dictionnaire) n'est pas trouvée dans l'ensemble des clefs existantes.

exception KeyboardInterrupt

Levée lorsque l'utilisateur appuie sur la touche d'interruption (normalement Control-C or Delete). Pendant l'exécution, un contrôle des interruptions est effectué régulièrement. L'exception hérite de BaseException afin de ne pas être accidentellement interceptée par du code qui intercepte Exception et ainsi empêcher l'interpréteur de quitter.

Note

Attraper une KeyboardInterrupt demande une considération particulière. Comme elle peut être levée à des moments imprévisibles, elle peut dans certains cas laisser le programme en cours d'exécution dans un état incohérent. Il est généralement préférable de laisser KeyboardInterrupt arrêter le programme aussi rapidement que possible ou d'éviter catégoriquement de la lever (voir Note on Signal Handlers and Exceptions).

exception MemoryError

Levée lorsqu'une opération est à court de mémoire mais que la situation peut encore être rattrapée (en supprimant certains objets). La valeur associée est une chaîne de caractères indiquant quel type d'opération (interne) est à court de mémoire. À noter qu'en raison de l'architecture interne de gestion de la mémoire (la fonction malloc() du C), l'interpréteur peut ne pas toujours être capable de rattraper cette situation ; il lève néanmoins une exception pour qu'une pile d'appels puisse être affichée, dans le cas où un programme en cours d'exécution en était la cause.

exception NameError

Levée lorsqu'un nom local ou global n'est pas trouvé. Ceci ne s'applique qu'aux noms non qualifiés. La valeur associée est un message d'erreur qui inclut le nom qui n'a pas pu être trouvé.

L'attribut name doit être défini uniquement à l'aide d'un argument nommé passé au constructeur. Lorsqu'il est défini, il représente le nom de la variable pour laquelle il y a eu une tentative d'accès.

Modifié dans la version 3.10: Ajout de l'attribut name.

exception NotImplementedError

Cette exception est dérivée de RuntimeError. Dans les classes mères définies par l'utilisateur, les méthodes abstraites devraient lever cette exception lorsqu'elles nécessitent des classes dérivées pour remplacer la méthode, ou lorsque la classe est en cours de développement pour indiquer que l'implémentation concrète doit encore être ajoutée.

Note

Elle ne devrait pas être utilisée pour indiquer qu'un opérateur ou qu'une méthode n'est pas destiné à être pris en charge du tout – dans ce cas, évitez de définir l'opérateur ou la méthode, ou s'il s'agit d'une sous-classe, assignez-le à None.

Note

NotImplementedError and NotImplemented are not interchangeable, even though they have similar names and purposes. See NotImplemented for details on when to use it.

exception OSError([arg])
exception OSError(errno, strerror[, filename[, winerror[, filename2]]])

Cette exception est levée lorsqu'une fonction système retourne une erreur liée au système, incluant les erreurs entrées-sorties telles que "fichier non trouvé" ou "disque plein" (pas pour les types d'arguments illégaux ou d'autres erreurs accidentelles).

La deuxième forme du constructeur définit les attributs correspondants, décrits ci-dessous. Les attributs par défaut sont None si non spécifiés. Pour la rétrocompatibilité, si trois arguments sont passés, l'attribut args contient seulement une paire avec les valeurs des deux premiers arguments du constructeur.

Le constructeur retourne souvent une sous-classe d'OSError, comme décrit dans OS exceptions ci-dessous. La sous-classe particulière dépend de la valeur finale d'errno. Ce comportement ne se produit que lors de la construction d'OSError directement ou via un alias, et n'est pas hérité lors du sous-classement.

errno

Code d'erreur numérique de la variable C errno.

winerror

Sous Windows, cela donne le code d'erreur Windows natif. L'attribut errno est alors une traduction approximative, en termes POSIX, de ce code d'erreur natif.

Sous Windows, si l'argument du constructeur winerror est un entier, l'attribut errno est déterminé à partir du code d'erreur Windows, et l'argument errno est ignoré. Sur d'autres plateformes, l'argument winerror est ignoré, et l'attribut winerror n'existe pas.

strerror

Le message d'erreur correspondant, tel que fourni par le système d'exploitation. Il est formaté par les fonctions C perror() sous POSIX, et FormatMessage() sous Windows.

filename
filename2

Pour les exceptions qui font référence à un chemin d'accès au système de fichiers (comme open() ou os.unlink()), filename est le nom du fichier transmis à la fonction. Pour les fonctions qui font référence à deux chemins d'accès au système de fichiers (comme os.rename()), filename2 correspond au deuxième nom de fichier passé à la fonction.

Modifié dans la version 3.3: EnvironmentError, IOError, WindowsError, socket.error, select.error et mmap.error ont fusionnées en OSError, et le constructeur peut renvoyer une sous-classe.

Modifié dans la version 3.4: L'attribut filename est maintenant le nom du fichier originel passé à la fonction, au lieu du nom encodé ou décodé à partir du gestionnaire d'encodage et d'erreur du système de fichiers. De plus, l'argument du constructeur et attribut filename2 a été ajouté.

exception OverflowError

Raised when the result of an arithmetic operation is too large to be represented. This cannot occur for integers (which would rather raise MemoryError than give up). However, for historical reasons, OverflowError is sometimes raised for integers that are outside a required range. Because of the lack of standardization of floating-point exception handling in C, most floating-point operations are not checked.

exception PythonFinalizationError

This exception is derived from RuntimeError. It is raised when an operation is blocked during interpreter shutdown also known as Python finalization.

Examples of operations which can be blocked with a PythonFinalizationError during the Python finalization:

See also the sys.is_finalizing() function.

Ajouté dans la version 3.13: Auparavant, une simple RuntimeError était levée.

exception RecursionError

Cette exception est dérivée de RuntimeError. Elle est levée lorsque l'interpréteur détecte que la profondeur de récursivité maximale (voir sys.getrecursionlimit()) est dépassée.

Ajouté dans la version 3.5: Auparavant, une simple RuntimeError était levée.

exception ReferenceError

Cette exception est levée lorsqu'un pointeur faible d'un objet proxy, créé par la fonction weakref.proxy(), est utilisé pour accéder à un attribut du référent après qu'il ait été récupéré par le ramasse-miettes. Pour plus d'informations sur les pointeurs faibles, voir le module weakref.

exception RuntimeError

Levée lorsqu'une erreur qui n'appartient à aucune des autres catégories est détectée. La valeur associée est une chaîne de caractères indiquant précisément ce qui s'est mal passé.

exception StopIteration

Levée par la fonction native next() et la méthode __next__() d'un iterator (itérateur) pour signaler qu'il n'y a pas d'autres éléments produits par l'itérateur.

value

The exception object has a single attribute value, which is given as an argument when constructing the exception, and defaults to None.

Lorsqu'une fonction de type generator ou coroutine retourne une valeur, une nouvelle instance de StopIteration est levée, et la valeur retournée par la fonction est passée au paramètre value du constructeur de l'exception.

Si le code d'un générateur lève, directement ou indirectement, une StopIteration, elle est convertie en RuntimeError (en conservant StopIteration comme cause de la nouvelle exception).

Modifié dans la version 3.3: Ajout de l'attribut value et de la possibilité pour les fonctions de générateur de l'utiliser pour retourner une valeur.

Modifié dans la version 3.5: Introduit la transformation des erreurs RuntimeError via from __future__ import generator_stop, cf. PEP 479.

Modifié dans la version 3.7: Active PEP 479 pour tout le code par défaut : quand une erreur StopIteration est levée dans un générateur elle est transformée en une RuntimeError.

exception StopAsyncIteration

Must be raised by __anext__() method of an asynchronous iterator object to stop the iteration.

Ajouté dans la version 3.5.

exception SyntaxError(message, details)

Levée lorsque l'analyseur syntaxique rencontre une erreur de syntaxe. Cela peut se produire dans une instruction import, dans un appel aux fonctions natives compile(), exec() ou eval(), ou lors de la lecture du script initial ou de l'entrée standard (également de manière interactive).

La conversion en chaîne avec str() de l'instance de l'exception ne renvoie que le message d'erreur. L'argument details est un n-uplet dont les membres sont disponibles en tant qu'attributs séparés.

filename

Le nom du fichier dans lequel l'erreur de syntaxe a été rencontrée.

lineno

Le numéro de la ligne dans le fichier où l'erreur s'est produite. L'indiçage commence à 1 : lineno vaut 1 pour la première ligne du fichier.

offset

La colonne dans la ligne où l'erreur s'est produite. L'indiçage commence à 1 : offset vaut 1 pour le premier caractère de la ligne.

text

Le texte du code source impliqué dans l'erreur.

end_lineno

Le numéro de la dernière ligne produisant l'erreur. L'indiçage commence à 1 : lineno vaut 1 pour la première ligne du fichier.

end_offset

Le numéro de la dernière colonne (de la dernière ligne) produisant l'erreur. L'indiçage commence à 1 : offset vaut 1 pour le premier caractère de la ligne.

Pour les erreurs dans les chaînes de formatage f-strings, le message commence par « f-string: » et les champs offset sont les décalages dans un texte construit à partir de l’expression de remplacement. Par exemple, compiler f'Bad {a b} field' produit cet attribut args : ('f-string: ...', ('', 1, 2, '(a b)\n', 1, 5)).

Modifié dans la version 3.10: Ajout des attributs end_lineno et end_offset.

exception IndentationError

Classe mère pour les erreurs de syntaxe liées à une indentation incorrecte. C'est une sous-classe de SyntaxError.

exception TabError

Levée lorsqu'une indentation contient une utilisation incohérente des tabulations et des espaces. C'est une sous-classe de IndentationError.

exception SystemError

Levée lorsque l'interpréteur trouve une erreur interne, mais que la situation ne semble pas si grave au point de lui faire abandonner tout espoir. La valeur associée est une chaîne de caractères indiquant l'erreur qui est survenue (en termes bas niveau).

Vous devriez le signaler à l'auteur ou au responsable de votre interpréteur Python. Assurez-vous de signaler la version de l'interpréteur (sys.version ; elle est également affichée au lancement d'une session interactive), le message d'erreur exact (la valeur associée à l'exception) et si possible le code source du programme qui a déclenché l'erreur.

exception SystemExit

Cette exception est levée par la fonction sys.exit(). Elle hérite de BaseException au lieu d'Exception pour ne pas qu'elle soit interceptée accidentellement par du code qui intercepte Exception. Cela permet à l'exception de se propager correctement et de faire quitter l'interpréteur. Lorsqu'elle n'est pas gérée, l'interpréteur Python quitte ; aucune trace d'appels n'est affichée. Le constructeur accepte le même argument optionnel passé à sys.exit(). Si la valeur est un entier, elle spécifie l'état de sortie du système (passé à la fonction C exit()) ; si elle est None, l'état de sortie est zéro ; si elle a un autre type (comme une chaîne de caractères), la valeur de l'objet est affichée et l'état de sortie est un.

Un appel à sys.exit() est traduit en une exception pour que les gestionnaires de nettoyage (les clauses finally des instructions try) puissent être exécutés, et pour qu'un débogueur puisse exécuter un script sans courir le risque de perdre le contrôle. La fonction os._exit() peut être utilisée s'il est absolument nécessaire de sortir immédiatement (par exemple, dans le processus enfant après un appel à os.fork()).

code

L'état de sortie ou le message d'erreur passé au constructeur. (None par défaut.)

exception TypeError

Levée lorsqu'une opération ou fonction est appliquée à un objet d'un type inapproprié. La valeur associée est une chaîne de caractères donnant des détails sur le type d'inadéquation.

Cette exception peut être levée par du code utilisateur pour indiquer qu'une tentative d'opération sur un objet n'est pas prise en charge, et n'est pas censée l'être. Si un objet est destiné à prendre en charge une opération donnée mais n'a pas encore fourni une implémentation, lever NotImplementedError est plus approprié.

Le passage d'arguments du mauvais type (e.g. passer une list quand un int est attendu) devrait résulter en un TypeError, mais le passage d'arguments avec la mauvaise valeur (e.g. un nombre en dehors des limites attendues) devrait résulter en une ValueError.

exception UnboundLocalError

Levée lorsqu'une référence est faite à une variable locale dans une fonction ou une méthode, mais qu'aucune valeur n'a été liée à cette variable. C'est une sous-classe de NameError.

exception UnicodeError

Levée lorsqu'une erreur d'encodage ou de décodage liée à Unicode se produit. C'est une sous-classe de ValueError.

UnicodeError a des attributs qui décrivent l'erreur d'encodage ou de décodage. Par exemple, err.object[err.start:err.end] donne l'entrée particulière invalide sur laquelle le codec a échoué.

encoding

Le nom de l'encodage qui a provoqué l'erreur.

reason

Une chaîne de caractères décrivant l'erreur de codec spécifique.

object

L'objet que le codec essayait d'encoder ou de décoder.

start

Le premier index des données invalides dans object.

end

L'index après la dernière donnée invalide dans object.

exception UnicodeEncodeError

Levée lorsqu'une erreur liée à Unicode se produit durant l'encodage. C'est une sous-classe d'UnicodeError.

exception UnicodeDecodeError

Levée lorsqu'une erreur liée à Unicode se produit durant le décodage. C'est une sous-classe d'UnicodeError.

exception UnicodeTranslateError

Levée lorsqu'une erreur liée à Unicode se produit durant la traduction. C'est une sous-classe d'UnicodeError.

exception ValueError

Levée lorsqu'une opération ou fonction native reçoit un argument qui possède le bon type mais une valeur inappropriée, et que la situation n'est pas décrite par une exception plus précise telle que IndexError.

exception ZeroDivisionError

Levée lorsque le second argument d'une opération de division ou d'un modulo est zéro. La valeur associée est une chaîne indiquant le type des opérandes et de l'opération.

Les exceptions suivantes sont conservées pour la compatibilité avec les anciennes versions ; depuis Python 3.3, ce sont des alias d'OSError.

exception EnvironmentError
exception IOError
exception WindowsError

Seulement disponible sous Windows.

Exceptions système

Les exceptions suivantes sont des sous-classes d'OSError, elles sont levées en fonction du code d'erreur système.

exception BlockingIOError

Raised when an operation would block on an object (e.g. socket) set for non-blocking operation. Corresponds to errno EAGAIN, EALREADY, EWOULDBLOCK and EINPROGRESS.

En plus de ceux de OSError, BlockingIOError peut avoir un attribut de plus :

characters_written

Un nombre entier contenant le nombre de caractères écrits dans le flux avant qu'il ne soit bloqué. Cet attribut est disponible lors de l'utilisation des classes tampon entrées-sorties du module io.

exception ChildProcessError

Raised when an operation on a child process failed. Corresponds to errno ECHILD.

exception ConnectionError

Classe mère pour les problèmes de connexion.

Les sous-classes sont BrokenPipeError, ConnectionAbortedError, ConnectionRefusedError et ConnectionResetError.

exception BrokenPipeError

A subclass of ConnectionError, raised when trying to write on a pipe while the other end has been closed, or trying to write on a socket which has been shutdown for writing. Corresponds to errno EPIPE and ESHUTDOWN.

exception ConnectionAbortedError

A subclass of ConnectionError, raised when a connection attempt is aborted by the peer. Corresponds to errno ECONNABORTED.

exception ConnectionRefusedError

A subclass of ConnectionError, raised when a connection attempt is refused by the peer. Corresponds to errno ECONNREFUSED.

exception ConnectionResetError

A subclass of ConnectionError, raised when a connection is reset by the peer. Corresponds to errno ECONNRESET.

exception FileExistsError

Raised when trying to create a file or directory which already exists. Corresponds to errno EEXIST.

exception FileNotFoundError

Raised when a file or directory is requested but doesn't exist. Corresponds to errno ENOENT.

exception InterruptedError

Raised when a system call is interrupted by an incoming signal. Corresponds to errno EINTR.

Modifié dans la version 3.5: Python relance maintenant les appels système lorsqu'ils sont interrompus par un signal, sauf si le gestionnaire de signal lève une exception (voir PEP 475 pour les raisons), au lieu de lever InterruptedError.

exception IsADirectoryError

Raised when a file operation (such as os.remove()) is requested on a directory. Corresponds to errno EISDIR.

exception NotADirectoryError

Raised when a directory operation (such as os.listdir()) is requested on something which is not a directory. On most POSIX platforms, it may also be raised if an operation attempts to open or traverse a non-directory file as if it were a directory. Corresponds to errno ENOTDIR.

exception PermissionError

Raised when trying to run an operation without the adequate access rights - for example filesystem permissions. Corresponds to errno EACCES, EPERM, and ENOTCAPABLE.

Modifié dans la version 3.11.1: WASI's ENOTCAPABLE is now mapped to PermissionError.

exception ProcessLookupError

Raised when a given process doesn't exist. Corresponds to errno ESRCH.

exception TimeoutError

Raised when a system function timed out at the system level. Corresponds to errno ETIMEDOUT.

Ajouté dans la version 3.3: Toutes les sous-classes d'OSError ci-dessus ont été ajoutées.

Voir aussi

PEP 3151 -- Refonte de la hiérarchie des exceptions système et IO

Avertissements

Les exceptions suivantes sont utilisées comme catégories d'avertissement ; voir warning-categories pour plus d'informations.

exception Warning

Classe mère pour les catégories d'avertissement.

exception UserWarning

Classe mère pour les avertissements générés par du code utilisateur.

exception DeprecationWarning

Classe mère pour les avertissements sur les fonctionnalités obsolètes, lorsque ces avertissements sont destinés aux autres développeurs Python.

Ignoré par les filtres d'avertissements par défaut, sauf dans le module __main__ (PEP 565). Activer le mode de développement de Python affiche cet avertissement.

La politique relative à l'obsolescence est décrite dans la PEP 387.

exception PendingDeprecationWarning

Classe mère pour les avertissements d'obsolescence programmée. Ils indiquent que la fonctionnalité peut encore être utilisée actuellement, mais qu'elle sera supprimée dans le futur.

Cette classe est rarement utilisée car émettre un avertissement à propos d’une obsolescence à venir est inhabituel, et DeprecationWarning est préféré pour les obsolescences actuelles.

Ignoré par les filtres d'avertissements par défaut. Activer le mode de développement de Python affiche cet avertissement.

La politique relative à l'obsolescence est décrite dans la PEP 387.

exception SyntaxWarning

Classe mère pour les avertissements sur de la syntaxe douteuse.

exception RuntimeWarning

Classe mère pour les avertissements sur les comportements d'exécution douteux.

exception FutureWarning

Classe mère pour les avertissements à propos de fonctionnalités qui seront obsolètes dans le futur quand ces avertissements destinés aux utilisateurs finaux des applications écrites en Python.

exception ImportWarning

Classe mère pour les avertissements sur des erreurs probables dans les importations de modules.

Ignoré par les filtres d'avertissements par défaut. Activer le mode de développement de Python affiche cet avertissement.

exception UnicodeWarning

Classe mère pour les avertissements liés à l'Unicode.

exception EncodingWarning

Classe mère pour les avertissements liés à l'encodage des chaînes.

Voir Opt-in EncodingWarning pour plus d'informations.

Ajouté dans la version 3.10.

exception BytesWarning

Classe mère pour les avertissements liés à bytes et bytearray.

exception ResourceWarning

Classe mère pour les avertissements liés à l'utilisation des ressources.

Ignoré par les filtres d'avertissements par défaut. Activer le mode de développement de Python affiche cet avertissement.

Ajouté dans la version 3.2.

Exception groups

The following are used when it is necessary to raise multiple unrelated exceptions. They are part of the exception hierarchy so they can be handled with except like all other exceptions. In addition, they are recognised by except*, which matches their subgroups based on the types of the contained exceptions.

exception ExceptionGroup(msg, excs)
exception BaseExceptionGroup(msg, excs)

Both of these exception types wrap the exceptions in the sequence excs. The msg parameter must be a string. The difference between the two classes is that BaseExceptionGroup extends BaseException and it can wrap any exception, while ExceptionGroup extends Exception and it can only wrap subclasses of Exception. This design is so that except Exception catches an ExceptionGroup but not BaseExceptionGroup.

The BaseExceptionGroup constructor returns an ExceptionGroup rather than a BaseExceptionGroup if all contained exceptions are Exception instances, so it can be used to make the selection automatic. The ExceptionGroup constructor, on the other hand, raises a TypeError if any contained exception is not an Exception subclass.

message

The msg argument to the constructor. This is a read-only attribute.

exceptions

A tuple of the exceptions in the excs sequence given to the constructor. This is a read-only attribute.

subgroup(condition)

Returns an exception group that contains only the exceptions from the current group that match condition, or None if the result is empty.

The condition can be an exception type or tuple of exception types, in which case each exception is checked for a match using the same check that is used in an except clause. The condition can also be a callable (other than a type object) that accepts an exception as its single argument and returns true for the exceptions that should be in the subgroup.

The nesting structure of the current exception is preserved in the result, as are the values of its message, __traceback__, __cause__, __context__ and __notes__ fields. Empty nested groups are omitted from the result.

The condition is checked for all exceptions in the nested exception group, including the top-level and any nested exception groups. If the condition is true for such an exception group, it is included in the result in full.

Ajouté dans la version 3.13: condition can be any callable which is not a type object.

split(condition)

Like subgroup(), but returns the pair (match, rest) where match is subgroup(condition) and rest is the remaining non-matching part.

derive(excs)

Returns an exception group with the same message, but which wraps the exceptions in excs.

This method is used by subgroup() and split(), which are used in various contexts to break up an exception group. A subclass needs to override it in order to make subgroup() and split() return instances of the subclass rather than ExceptionGroup.

subgroup() and split() copy the __traceback__, __cause__, __context__ and __notes__ fields from the original exception group to the one returned by derive(), so these fields do not need to be updated by derive().

>>> class MyGroup(ExceptionGroup):
...     def derive(self, excs):
...         return MyGroup(self.message, excs)
...
>>> e = MyGroup("eg", [ValueError(1), TypeError(2)])
>>> e.add_note("a note")
>>> e.__context__ = Exception("context")
>>> e.__cause__ = Exception("cause")
>>> try:
...    raise e
... except Exception as e:
...    exc = e
...
>>> match, rest = exc.split(ValueError)
>>> exc, exc.__context__, exc.__cause__, exc.__notes__
(MyGroup('eg', [ValueError(1), TypeError(2)]), Exception('context'), Exception('cause'), ['a note'])
>>> match, match.__context__, match.__cause__, match.__notes__
(MyGroup('eg', [ValueError(1)]), Exception('context'), Exception('cause'), ['a note'])
>>> rest, rest.__context__, rest.__cause__, rest.__notes__
(MyGroup('eg', [TypeError(2)]), Exception('context'), Exception('cause'), ['a note'])
>>> exc.__traceback__ is match.__traceback__ is rest.__traceback__
True

Note that BaseExceptionGroup defines __new__(), so subclasses that need a different constructor signature need to override that rather than __init__(). For example, the following defines an exception group subclass which accepts an exit_code and and constructs the group's message from it.

class Errors(ExceptionGroup):
   def __new__(cls, errors, exit_code):
      self = super().__new__(Errors, f"exit code: {exit_code}", errors)
      self.exit_code = exit_code
      return self

   def derive(self, excs):
      return Errors(excs, self.exit_code)

Like ExceptionGroup, any subclass of BaseExceptionGroup which is also a subclass of Exception can only wrap instances of Exception.

Ajouté dans la version 3.11.

Hiérarchie des exceptions

La hiérarchie de classes pour les exceptions natives est la suivante :

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ExceptionGroup [BaseExceptionGroup]
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── BrokenPipeError
      │    │    ├── ConnectionAbortedError
      │    │    ├── ConnectionRefusedError
      │    │    └── ConnectionResetError
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    ├── PythonFinalizationError
      │    └── RecursionError
      ├── StopAsyncIteration
      ├── StopIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── BytesWarning
           ├── DeprecationWarning
           ├── EncodingWarning
           ├── FutureWarning
           ├── ImportWarning
           ├── PendingDeprecationWarning
           ├── ResourceWarning
           ├── RuntimeWarning
           ├── SyntaxWarning
           ├── UnicodeWarning
           └── UserWarning