UVT MASTER BADS

Ce document présente la gestion des exceptions en Python, un mécanisme essentiel pour tout étudiant ou développeur souhaitant écrire des programmes robustes et sûrs. Il couvre la détection, la capture, la propagation des erreurs, ainsi que la création et la définition d’exceptions personnalisées, sans oublier les assertions pour valider des conditions en cours d’exécution.

Présentation des exceptions

Python, comme d'autres langages, propose un système de gestion des exceptions via les instructions try-except. Ce mécanisme permet de détecter et gérer les erreurs qui surviennent lors de l'exécution d'un programme afin d'éviter que celui-ci ne plante brutalement.

Il existe deux types d'erreurs :

• Erreur de syntaxe : erreur détectée à la phase d’analyse, lorsque Python ne comprend pas une ligne de code.
• Exception : erreur détectée lors de l'exécution, par exemple ZeroDivisionError ou TypeError.

Une exception est dite levée lorsqu'une erreur survient, et capturée lorsqu'elle est gérée par un bloc except. Le but est d'empêcher l'arrêt brutal du programme et de fournir un traitement adapté.

On distingue deux types d’exceptions en Python :

• Celles prédéfinies dans Python.
• Celles créées par l’utilisateur.

Mécanisme des exceptions

Instruction try-except

La syntaxe générale est :

try:
    # Code à tester
except:
    # Code exécuté en cas d'erreur

Le bloc try contient le code potentiellement dangereux. Si aucune exception ne survient, le bloc except est ignoré. En cas d’exception, le bloc try est interrompu et le bloc except est exécuté.

Une instruction try peut comporter plusieurs clauses except pour gérer différents types d’exceptions.

Exemple

try:
    resultat = numerateur / denominateur
except NameError:
    print("La variable numérateur ou dénominateur n'a pas été définie.")
except TypeError:
    print("Le numérateur ou dénominateur est d'un type incompatible avec une division.")
except ZeroDivisionError:
    print("La variable dénominateur est égale à 0.")

Exemple d'entrée utilisateur avec gestion d'erreur

valid = False
while not valid:
    an = input("Année de naissance ? ")
    try:
        an = int(an)
        if 0 <= an <= 2020:
            valid = True
        else:
            print("L'année doit être comprise entre 0 et 2020.")
    except:
        print("Veuillez entrer un nombre naturel.")
print("Tu as", 2020 - an, "ans.")

Le type Exception

Les exceptions sont des objets, instances de la classe Exception. On peut récupérer cet objet dans un bloc except en lui donnant un nom :

try:
    a = int(input('a : '))
    b = int(input('b : '))
    print(a, '/', b, '=', a / b)
except Exception as e:
    print(type(e))
    print(e)

Exemples d’exécution :

• Entrée non convertible en entier : ValueError
• Division par zéro : ZeroDivisionError

Gestion de plusieurs exceptions dans un même bloc except

try:
    a = int(input('a : '))
    b = int(input('b : '))
    print(a, '/', b, '=', a / b)
except (ValueError, ZeroDivisionError) as e:
    print('Erreur de calcul :', e)
except:
    print('Autre erreur.')

Le premier bloc except capture les erreurs de type ValueError et ZeroDivisionError, et affiche un message d’erreur spécifique.

La clause else

La clause else s’exécute uniquement si aucune exception n’a été levée dans le bloc try.

try:
    # Code à tester
except:
    # Code en cas d'erreur
else:
    # Code exécuté si pas d'erreur

La clause finally

Le bloc finally est toujours exécuté, que l’exception survienne ou non.

try:
    # Code à tester
except Exception as e:
    # Code en cas d'erreur
finally:
    # Code toujours exécuté

Exemple complet

try:
    a = int(input('a : '))
    b = int(input('b : '))
    print(a, '/', b, '=', a / b)
except (ValueError, ZeroDivisionError) as e:
    print('Erreur de calcul :', e)
else:
    print("Calcul réussi sans erreur.")
finally:
    print("Fin du traitement.")

Lever une exception avec raise

Le programmeur peut déclencher une exception manuellement avec raise.

Méthode 1 : Lever une exception avec message

raise exception_type(message)

Méthode 2 : Exemple avec fonction inverse

def inverse(x):
    if x == 0:
        raise ValueError("valeur nulle interdite!!")
    y = 1.0 / x
    return y

try:
    print(inverse(0))
except ValueError as exc:
    print("erreur, message :", exc)

Méthode 3 : Lever une exception sans message

def inverse(x):
    if x == 0:
        raise
    y = 1.0 / x
    return y

Propagation des erreurs

Si une exception n’est pas capturée dans une fonction, elle remonte dans la chaîne d’appels jusqu’à être gérée ou provoquer l’arrêt du programme.

Exemple

def fun():
    print(1 / 0)

def compute():
    fun()

compute()

Cette exécution provoque une erreur ZeroDivisionError dans fun(), qui remonte jusqu’à compute() puis au niveau global.

Gestion avec try-except dans la fonction appelante

def fun():
    print(1 / 0)

def compute():
    try:
        fun()
    except:
        print('Erreur!!!')

compute()

Instructions try-except imbriquées

Il est possible d’imbriquer plusieurs blocs try-except pour gérer différentes erreurs à différents niveaux.

Exemple

def inverse(x):
    y = 1.0 / x
    return y

try:
    try:
        print(inverses(0))  # fonction inexistante --> NameError
        print(inverse(0))   # division par zéro --> ZeroDivisionError
    except NameError:
        print("appel à une fonction non définie")
except ZeroDivisionError as exc:
    print("erreur", exc)

Les classes exception

En Python, toutes les exceptions sont des objets issus d’une hiérarchie de classes :

• BaseException : classe racine de toutes les exceptions.
• Exception : classe de base pour toutes les exceptions non critiques et celles définies par l’utilisateur.

Quelques classes d’exception courantes :

• ArithmeticError : base des erreurs arithmétiques comme OverflowError, ZeroDivisionError, FloatingPointError.
• BufferError : erreur liée aux opérations sur tampons (buffers).
• LookupError : erreurs liées à des clés ou indices invalides dans des séquences ou dictionnaires.
• AttributeError : déclenchée lorsqu’un attribut inexistant est référencé.

Exemple avec ArithmeticError

def division(a, b):
    try:
        d = a // b
    except ArithmeticError:
        print("Erreur")

Exemple avec LookupError

T = [1, 2, 3]
try:
    print(T[4])
except LookupError:
    print("Indice est supérieur à la taille du tableau")

Exemple avec AttributeError

class Personne:
    def __init__(self, nom):
        self.nom = nom

try:
    p = Personne("ahmed")
    print(p.prenom)
except AttributeError:
    print("Erreur d'attribut")

Définir une exception personnalisée

On peut créer une nouvelle classe d’exception en héritant de BaseException ou Exception.

Exemple

class AucunChiffre(Exception):
    """
    chaîne de caractères contenant aussi autre chose que des chiffres
    """
    pass

def conversion(s):
    if not s.isdigit():
        raise AucunChiffre(s)
    return int(s)

try:
    s = "123a"
    print(s, " = ", conversion(s))
except AucunChiffre as exc:
    print(AucunChiffre.__doc__, " : ", exc)

Sortie :

chaîne de caractères contenant aussi autre chose que des chiffres : 123a

Les assertions

Les assertions permettent de vérifier qu’une condition est vraie avant de continuer l’exécution. Si la condition est fausse, une exception AssertionError est levée.

Syntaxe

assert <condition>
assert <condition>, <message d'erreur>

Exemple simple

num = int(input('Entrer un nombre: '))
assert num >= 0
print('vous avez saisi:', num)

Si l’utilisateur entre un nombre négatif, le programme s’arrête avec une AssertionError.

Exemple avec message d'erreur personnalisé

num = int(input('Entrer un nombre: '))
assert num >= 0, "Seuls les nombres positifs sont acceptés."
print('vous avez saisi:', num)

Si la condition est fausse, l’exception affiche le message personnalisé.

Glossaire des termes clés

• Exception : objet représentant une erreur détectée lors de l'exécution.
• Levée d'exception : action de signaler une erreur par Python ou par le programmeur.
• Capture d'exception : gestion d'une erreur par un bloc except.
• try-except : structure de contrôle pour gérer les exceptions.
• raise : instruction pour lever une exception manuellement.
• finally : bloc toujours exécuté après un try-except, qu’il y ait eu erreur ou non.
• else : bloc exécuté uniquement si aucune exception n’a été levée dans le try.
• Assertion : vérification d’une condition, levée d’exception si fausse.
• Propagation : remontée d’une exception non gérée dans la chaîne d’appels.
• Classe d’exception : type d’exception, héritée de BaseException.
• Exception personnalisée : classe d’exception définie par l’utilisateur.

Points clés à retenir

• Les exceptions permettent de gérer les erreurs d’exécution sans arrêter brutalement le programme.
• La structure try-except est la base de la gestion des exceptions en Python.
• On peut capturer plusieurs types d’exceptions dans un même bloc except.
• Les blocs else et finally complètent la gestion des exceptions.
• Le programmeur peut lever ses propres exceptions avec raise.
• Les exceptions non capturées se propagent dans la chaîne d’appels, pouvant provoquer l’arrêt du programme.
• Il est possible d’imbriquer des blocs try-except pour gérer différentes erreurs à différents niveaux.
• Python possède une hiérarchie de classes d’exceptions natives, et il est possible de définir ses propres classes d’exceptions.
• Les assertions sont un outil simple pour vérifier des conditions et interrompre le programme en cas d’erreur.