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
