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