Exceptions natives
******************

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

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

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

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


Contexte des exceptions
=======================

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

BaseException.__context__
BaseException.__cause__
BaseException.__suppress_context__

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

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

      raise new_exc from original_exc

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

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

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


Hériter des exceptions natives
==============================

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

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


Classes mères
=============

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

exception BaseException

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

   args

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

   with_traceback(tb)

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

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

   __traceback__

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

   add_note(note)

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

      Ajouté dans la version 3.11.

   __notes__

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

      Ajouté dans la version 3.11.

exception Exception

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

exception ArithmeticError

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

exception BufferError

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

exception LookupError

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


Exceptions concrètes
====================

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

exception AssertionError

   Levée lorsqu'une instruction "assert" échoue.

exception AttributeError

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

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

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

exception EOFError

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

exception FloatingPointError

   N’est pas utilisé pour le moment.

exception GeneratorExit

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

exception ImportError

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

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

   name

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

   path

      The path to any file which triggered the exception.

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

exception ModuleNotFoundError

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

   Ajouté dans la version 3.6.

exception IndexError

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

exception KeyError

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

exception KeyboardInterrupt

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

   Note:

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

exception MemoryError

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

exception NameError

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

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

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

exception NotImplementedError

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

   Note:

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

   Note:

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

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

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

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

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

   errno

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

   winerror

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

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

   strerror

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

   filename
   filename2

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

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

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

exception OverflowError

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

exception RecursionError

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

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

exception ReferenceError

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

exception RuntimeError

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

exception StopIteration

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

   value

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

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

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

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

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

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

exception StopAsyncIteration

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

   Ajouté dans la version 3.5.

exception SyntaxError(message, details)

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

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

   filename

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

   lineno

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

   offset

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

   text

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

   end_lineno

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

   end_offset

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

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

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

exception IndentationError

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

exception TabError

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

exception SystemError

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

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

exception SystemExit

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

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

   code

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

exception TypeError

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

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

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

exception UnboundLocalError

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

exception UnicodeError

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

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

   encoding

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

   reason

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

   object

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

   start

      Le premier index des données invalides dans "object".

   end

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

exception UnicodeEncodeError

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

exception UnicodeDecodeError

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

exception UnicodeTranslateError

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

exception ValueError

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

exception ZeroDivisionError

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

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

exception EnvironmentError

exception IOError

exception WindowsError

   Seulement disponible sous Windows.


Exceptions système
------------------

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

exception BlockingIOError

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

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

   characters_written

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

exception ChildProcessError

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

exception ConnectionError

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

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

exception BrokenPipeError

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

exception ConnectionAbortedError

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

exception ConnectionRefusedError

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

exception ConnectionResetError

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

exception FileExistsError

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

exception FileNotFoundError

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

exception InterruptedError

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

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

exception IsADirectoryError

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

exception NotADirectoryError

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

exception PermissionError

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

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

exception ProcessLookupError

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

exception TimeoutError

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

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

Voir aussi:

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


Avertissements
==============

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

exception Warning

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

exception UserWarning

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

exception DeprecationWarning

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

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

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

exception PendingDeprecationWarning

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

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

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

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

exception SyntaxWarning

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

exception RuntimeWarning

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

exception FutureWarning

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

exception ImportWarning

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

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

exception UnicodeWarning

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

exception EncodingWarning

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

   Voir Opt-in EncodingWarning pour plus d'informations.

   Ajouté dans la version 3.10.

exception BytesWarning

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

exception ResourceWarning

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

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

   Ajouté dans la version 3.2.


Exception groups
================

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

exception ExceptionGroup(msg, excs)

exception BaseExceptionGroup(msg, excs)

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

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

   message

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

   exceptions

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

   subgroup(condition)

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

      The condition can be 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".

   Ajouté dans la version 3.11.


Hiérarchie des exceptions
=========================

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

   BaseException
    ├── BaseExceptionGroup
    ├── GeneratorExit
    ├── KeyboardInterrupt
    ├── SystemExit
    └── Exception
         ├── ArithmeticError
         │    ├── FloatingPointError
         │    ├── OverflowError
         │    └── ZeroDivisionError
         ├── AssertionError
         ├── AttributeError
         ├── BufferError
         ├── EOFError
         ├── ExceptionGroup [BaseExceptionGroup]
         ├── ImportError
         │    └── ModuleNotFoundError
         ├── LookupError
         │    ├── IndexError
         │    └── KeyError
         ├── MemoryError
         ├── NameError
         │    └── UnboundLocalError
         ├── OSError
         │    ├── BlockingIOError
         │    ├── ChildProcessError
         │    ├── ConnectionError
         │    │    ├── BrokenPipeError
         │    │    ├── ConnectionAbortedError
         │    │    ├── ConnectionRefusedError
         │    │    └── ConnectionResetError
         │    ├── FileExistsError
         │    ├── FileNotFoundError
         │    ├── InterruptedError
         │    ├── IsADirectoryError
         │    ├── NotADirectoryError
         │    ├── PermissionError
         │    ├── ProcessLookupError
         │    └── TimeoutError
         ├── ReferenceError
         ├── RuntimeError
         │    ├── NotImplementedError
         │    └── 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
