# 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.

    Added in 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.

    Added in 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`.

  Added in 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

  Levée lorsque le résultat d'une opération arithmétique est trop grand pour être représenté. Cela ne peut pas se produire pour les entiers (qui préfèrent lever `MemoryError` plutôt que d'abandonner). Cependant, pour des raisons historiques, `OverflowError` est parfois levée pour des entiers qui sont en dehors d'une plage requise. En raison de l'absence de normalisation de la gestion des exceptions de virgule flottante en C, la plupart des opérations en virgule flottante ne sont pas vérifiées.

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.

  Added in 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.

  Added in 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`.

Added in 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.

  Added in 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.

  Added in 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 either a function that accepts an exception and returns true for those that should be in the subgroup, or it can be an exception type or a tuple of exception types, which is used to check for a match using the same check that is used in an `except` clause.

    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.

  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`.

  Added in 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
          │    └── 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