Ce document est relatif à une vieille version de Python qui n'est plus soutenue. Mettez à jour votre version et lisez Bienvenue sur la documentation de la version stable actuelle de Python.

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

Les exceptions natives présentes ci-dessous peuvent être levées par l'interpréteur ou par les fonctions natives. Sauf mention contraire, une "valeur associée" indique la cause de l'erreur. Cela peut être une chaîne ou un tuple contenant plusieurs éléments d'information (e.g., un code d'erreur ou un message explicatif). Cette valeur associée est généralement donnée en argument du constructeur de la classe.

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 sous Exceptions définies par l'utilisateur.

En levant (ou levant à nouveau) une exception dans une clause `except` ou `finally`, `__context__` est automatiquement assigné à la dernière exception capturée ; si la nouvelle exception n'est pas gérée, la trace d'appels affichée inclut la ou les exception(s) d'origine et l'exception finale.

En levant une nouvelle exception (plutôt que d'utiliser un simple `raise` pour lever à nouveau l'exception en cours de traitement), le contexte implicite d'exception peut être complété par une cause explicite en utilisant `from` avec `raise` :

    raise new_exc from original_exc

L'expression suivant `from` doit être une exception ou `None`. Elle sera assignée en tant que `__cause__` dans l'exception levée. Changer `__cause__` change aussi implicitement l'attribut `__suppress_context__` à `True`, de sorte que l'utilisation de `raise new_exc from None` remplace bien l'ancienne exception avec la nouvelle à des fins d'affichage (e.g., convertir `KeyError` en `AttributeError`), tout en laissant l'ancienne exception disponible dans `__context__` pour introspection lors du débogage.

Le code d'affichage par défaut de la trace d'appels montre ces exceptions chaînées en plus de la trace de l'exception elle-même. Une exception chaînée explicitement dans `__cause__` est toujours affichée si présente. Une exception implicitement chaînée dans `__context__` n'est affichée que si `__cause__` est `None` et `__suppress_context__` est faux.

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.

## Classes de base

Les exceptions suivantes sont utilisées principalement en tant que classes de base pour d'autres exceptions.

exception `BaseException`

  La classe de base 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 tuple 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 tuple, 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 définit tb en tant que nouvelle trace d'appels pour l'exception et retourne l'objet exception. Elle est généralement utilisée dans du code de gestion d'exceptions comme ceci :

        try:
            ...
        except SomeException:
            tb = sys.exc_info()[2]
            raise OtherException(...).with_traceback(tb)

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 de base 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 de base 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é.)

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

  Les attributs `name` et `path` peuvent être définis uniquement à l'aide d'arguments mot-clef (kwargs) passés au constructeur. Lorsqu'ils sont définis, ils représentent respectivement le nom du module qui a été tenté d'être importé et le chemin d'accès au fichier qui a déclenché l'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`.

  Nouveau 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 capturée par du code qui capture `Exception` et ainsi empêcher l'interpréteur de quitter.

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

exception `NotImplementedError`

  Cette exception est dérivée de `RuntimeError`. Dans les classes de base 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, laissez soit l'opérateur / la méthode non défini, soit, s'il s'agit d'une sous-classe, assignez-le à `None`.

  Note

  `NotImplementedError` et `NotImplemented` ne sont pas interchangeables, même s'ils ont des noms et des objectifs similaires. Voir `NotImplemented` pour des détails sur la façon de les utiliser.

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 un tuple à deux 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 de l'encodage 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.

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

  L'objet exception a un unique attribut `value`, qui est donné en argument lors de la construction de l'exception, et vaut `None` par défaut.

  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`

  Doit être levée par la méthode `__anext__()` d'un objet asynchronous iterator pour arrêter l'itération.

  Nouveau dans la version 3.5.

exception `SyntaxError`

  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 `exec()` ou `eval()`, ou lors de la lecture du script initial ou de l'entrée standard (également de manière interactive).

  Les instances de cette classe ont des attributs `filename`, `lineno`, `offset` et `text` pour accéder plus facilement aux détails. La représentation `str()` de l'instance de l'exception retourne seulement le message.

exception `IndentationError`

  Classe de base 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 accidentellement capturée par du code qui capture `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`

  Levée lorsqu'une opération bloque sur un objet (par exemple un connecteur) configuré pour une opération non-bloquante. Correspond à `errno` `EAGAIN`, `EALREADY`, `EWOULDBLOCK` et `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`

  Levée lorsqu'une opération sur un processus enfant a échoué. Correspond à `errno` `ECHILD`.

exception `ConnectionError`

  Une classe de base pour les problèmes de connexion.

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

exception `BrokenPipeError`

  Une sous-classe de `ConnectionError`, levé en essayant d'écrire sur un pipe alors que l'autre extrémité a été fermée, ou en essayant d'écrire sur un connecteur (socket en anglais) qui a été fermé pour l'écriture. Correspond à `errno` `EPIPE` et `ESHUTDOWN`.

exception `ConnectionAbortedError`

  Une sous-classe de `ConnectionError`, levée lorsqu'une tentative de connexion est interrompue par le pair. Correspond à `errno` `ECONNABORTED`.

exception `ConnectionRefusedError`

  Une sous-classe de `ConnectionError`, levée lorsqu'une tentative de connexion est refusée par le pair. Correspond à `errno` `ECONNREFUSED`.

exception `ConnectionResetError`

  Une sous-classe de `ConnectionError`, levée lorsqu'une connexion est réinitialisée par le pair. Correspond à `errno` `ECONNRESET`.

exception `FileExistsError`

  Levée en essayant de créer un fichier ou un répertoire qui existe déjà. Correspond à `errno` `EEXIST`.

exception `FileNotFoundError`

  Levée lorsqu'un fichier ou répertoire est demandé mais n'existe pas. Correspond à `errno` `ENOENT`.

exception `InterruptedError`

  Levée lorsqu'un appel système est interrompu par un signal entrant. Correspond à `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`

  Levée lorsqu'une opération sur un fichier (comme `os.remove()`) est demandée sur un répertoire. Correspond à `errno` `EISDIR`.

exception `NotADirectoryError`

  Levée lorsqu'une opération sur un répertoire (comme `os.listdir()`) est demandée sur autre chose qu'un répertoire. Correspond à `errno` `ENOTDIR`.

exception `PermissionError`

  Levée lorsqu'on essaye d'exécuter une opération sans les droits d'accès adéquats — par exemple les permissions du système de fichiers. Correspond à `errno` `EACCES` et `EPERM`.

exception `ProcessLookupError`

  Levée lorsqu'un processus donné n'existe pas. Correspond à `errno` `ESRCH`.

exception `TimeoutError`

  Levée lorsqu'une fonction système a expiré au niveau système. Correspond à `errno` `ETIMEDOUT`.

Nouveau 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 de base pour les catégories d'avertissement.

exception `UserWarning`

  Classe de base pour les avertissements générés par du code utilisateur.

exception `DeprecationWarning`

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

exception `PendingDeprecationWarning`

  Classe de base 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.

exception `SyntaxWarning`

  Classe de base pour les avertissements sur de la syntaxe douteuse.

exception `RuntimeWarning`

  Classe de base pour les avertissements sur les comportements d'exécution douteux.

exception `FutureWarning`

  Classe de base 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 de base pour les avertissements sur des erreurs probables dans les importations de modules.

exception `UnicodeWarning`

  Classe de base pour les avertissements liés à l'Unicode.

exception `BytesWarning`

  Classe de base pour les avertissements liés à `bytes` et `bytearray`.

exception `ResourceWarning`

  Classe de base pour les avertissements liés à l'utilisation de ressources. Ignorée par les filtres d’avertissements par défaut.

  Nouveau dans la version 3.2.

## Hiérarchie des exceptions

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

    BaseException
     +-- SystemExit
     +-- KeyboardInterrupt
     +-- GeneratorExit
     +-- Exception
          +-- StopIteration
          +-- StopAsyncIteration
          +-- ArithmeticError
          |    +-- FloatingPointError
          |    +-- OverflowError
          |    +-- ZeroDivisionError
          +-- AssertionError
          +-- AttributeError
          +-- BufferError
          +-- EOFError
          +-- 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
          +-- SyntaxError
          |    +-- IndentationError
          |         +-- TabError
          +-- SystemError
          +-- TypeError
          +-- ValueError
          |    +-- UnicodeError
          |         +-- UnicodeDecodeError
          |         +-- UnicodeEncodeError
          |         +-- UnicodeTranslateError
          +-- Warning
               +-- DeprecationWarning
               +-- PendingDeprecationWarning
               +-- RuntimeWarning
               +-- SyntaxWarning
               +-- UserWarning
               +-- FutureWarning
               +-- ImportWarning
               +-- UnicodeWarning
               +-- BytesWarning
               +-- ResourceWarning