Gestion des erreurs d'entrée | Exercices corrigés

Concepts & Exercices

Gestion = Try + Except + Validation + Exception

Formule de la gestion des erreurs d'entrée

Try/Except

→ Capture

Gestion des exceptions

Validation

→ Vérification

Contrôle des entrées

Exceptions

→ Erreurs

Types d'erreurs

Processus de gestion des erreurs d'entrée

Saisie → Validation → Try/Except → Gestion → Correction

Exercice 1

Gérer les erreurs de conversion de type avec try/except.

Exercice 2

Valider une entrée utilisateur pour un nombre entier positif.

Exercice 3

Gérer les erreurs de division par zéro dans une saisie utilisateur.

Exercice 4

Valider une entrée utilisateur pour accéder à un index dans une liste.

Exercice 5

Gérer les erreurs de lecture de fichiers avec saisie utilisateur.

Corrigé : Exercices 1 à 3

1 Gestion des erreurs de conversion de type

Définition de la gestion des conversions :

Gestion des conversions : Technique permettant de capturer les erreurs lors de la conversion d'une chaîne en un autre type.

Méthodologie d'analyse :

Encapsuler le code sensible dans un bloc try
Capturer l'exception spécifique (ValueError)
Proposer un message d'erreur clair
Demander une nouvelle saisie si nécessaire

Types d'erreurs de conversion

ValueError : Chaîne incorrecte pour conversion
TypeError : Type incompatible
OverflowError : Valeur trop grande
Format incorrect

Étape 1 : Encapsulation dans try

try:
    nombre = int(input("Entrez un nombre : "))
except ValueError:
    print("Erreur : Veuillez entrer un nombre valide")

Étape 2 : Gestion avec boucle

while True:
    try:
        nombre = int(input("Entrez un nombre : "))
        break  # Sortir de la boucle si succès
    except ValueError:
        print("Erreur : Veuillez entrer un nombre valide")

Étape 3 : Gestion complète

def saisir_nombre():
    while True:
        try:
            return int(input("Entrez un nombre : "))
        except ValueError:
            print("Erreur : Veuillez entrer un nombre entier valide")

Utilisation de try/except pour gérer les erreurs de conversion

Réponse finale :

def saisir_nombre():
    while True:
        try:
            nombre = int(input("Entrez un nombre entier : "))
            return nombre
        except ValueError:
            print("Erreur : Ce n'est pas un nombre entier valide.")
            print("Veuillez réessayer.")

# Exemple d'utilisation
nombre = saisir_nombre()
print(f"Vous avez entré : {nombre}")

Lois et principes :

• Principe du bloc try : Encapsuler le code susceptible de générer une exception

• Exception spécifique : Capturer ValueError pour les erreurs de conversion

• Boucle de validation : Répéter jusqu'à obtenir une entrée valide

2 Validation d'entrée pour nombre entier positif

Définition de la validation :

Validation : Processus de vérification que les données d'entrée respectent des critères prédéfinis.

Critères de validation d'un entier positif

Doit être convertible en entier
Doit être supérieur à 0
Doit être un nombre entier
Doit être dans un intervalle valide

Étape 1 : Conversion et vérification

try:
    nombre = int(input("Entrez un nombre positif : "))
    if nombre <= 0:
        raise ValueError("Le nombre doit être positif")
except ValueError as e:
    print(f"Erreur : {e}")

Étape 2 : Validation dans une boucle

while True:
    try:
        nombre = int(input("Entrez un nombre positif : "))
        if nombre > 0:
            break
        else:
            print("Erreur : Le nombre doit être positif")
    except ValueError:
        print("Erreur : Veuillez entrer un nombre entier")

Étape 3 : Fonction de validation

def saisir_entier_positif():
    while True:
        try:
            nombre = int(input("Entrez un nombre positif : "))
            if nombre <= 0:
                raise ValueError
            return nombre
        except ValueError:
            print("Erreur : Entrez un nombre entier positif")

Combinaison de try/except et de conditions de validation

Réponse finale :

def saisir_entier_positif():
    while True:
        try:
            nombre = int(input("Entrez un nombre entier positif : "))
            if nombre <= 0:
                print("Erreur : Le nombre doit être supérieur à 0")
                continue
            return nombre
        except ValueError:
            print("Erreur : Ce n'est pas un nombre entier valide")

# Exemple d'utilisation
nombre = saisir_entier_positif()
print(f"Nombre positif saisi : {nombre}")

Lois et principes :

• Validation combinée : Utiliser try/except avec des conditions

• Continue dans boucle : Passer à l'itération suivante après erreur

• Message clair : Informer l'utilisateur de la cause de l'erreur

3 Gestion des erreurs de division par zéro

Définition de ZeroDivisionError :

ZeroDivisionError : Exception levée lorsqu'on tente de diviser un nombre par zéro.

Scénarios de division par zéro

Division explicite par 0
Division par une variable valant 0
Division par une expression évaluant à 0
Calculs mathématiques complexes

Étape 1 : Gestion simple de division

try:
    numerateur = float(input("Numérateur : "))
    denominateur = float(input("Dénominateur : "))
    resultat = numerateur / denominateur
    print(f"Résultat : {resultat}")
except ZeroDivisionError:
    print("Erreur : Division par zéro impossible")

Étape 2 : Validation préalable

try:
    numerateur = float(input("Numérateur : "))
    denominateur = float(input("Dénominateur : "))
    
    if denominateur == 0:
        raise ZeroDivisionError("Division par zéro")
    
    resultat = numerateur / denominateur
    print(f"Résultat : {resultat}")
except (ValueError, ZeroDivisionError) as e:
    print(f"Erreur : {e}")

Étape 3 : Boucle de saisie sécurisée

def division_securisee():
    while True:
        try:
            numerateur = float(input("Numérateur : "))
            denominateur = float(input("Dénominateur : "))
            
            if denominateur == 0:
                print("Erreur : Le dénominateur ne peut pas être zéro")
                continue
            
            resultat = numerateur / denominateur
            return resultat
        except ValueError:
            print("Erreur : Veuillez entrer des nombres valides")

Gestion de ZeroDivisionError avec validation préventive

Réponse finale :

def calcul_division():
    while True:
        try:
            num = float(input("Entrez le numérateur : "))
            den = float(input("Entrez le dénominateur : "))
            
            if den == 0:
                print("Erreur : Impossible de diviser par zéro")
                continue
            
            resultat = num / den
            print(f"Résultat de {num} / {den} = {resultat}")
            break
            
        except ValueError:
            print("Erreur : Veuillez entrer des nombres valides")
        except ZeroDivisionError:
            print("Erreur : Division par zéro impossible")

# Exemple d'utilisation
calcul_division()

Lois et principes :

• ZeroDivisionError : Exception spécifique pour division par zéro

• Validation préventive : Vérifier avant la division

• Messages pertinents : Informer précisément de l'erreur

Corrigé : Exercices 4 à 5

4 Validation d'index dans une liste

Définition de IndexError :

IndexError : Exception levée lorsqu'on tente d'accéder à un index hors des limites d'une séquence.

Scénarios de IndexError

Index négatif trop grand
Index supérieur à la taille
Accès à une liste vide
Index calculé incorrectement

Étape 1 : Gestion simple d'index

liste = [10, 20, 30, 40, 50]
try:
    index = int(input("Entrez un index : "))
    element = liste[index]
    print(f"Élément à l'index {index} : {element}")
except IndexError:
    print("Erreur : Index hors des limites")
except ValueError:
    print("Erreur : Veuillez entrer un nombre entier")

Étape 2 : Validation avec longueur

liste = [10, 20, 30, 40, 50]
try:
    index = int(input(f"Entrez un index (0-{len(liste)-1}) : "))
    
    if index < 0 or index >= len(liste):
        raise IndexError("Index hors limites")
    
    element = liste[index]
    print(f"Élément à l'index {index} : {element}")
except (ValueError, IndexError) as e:
    print(f"Erreur : {e}")

Étape 3 : Boucle de saisie sécurisée

def acces_liste_securisee(liste):
    while True:
        try:
            index = int(input(f"Index (0-{len(liste)-1}) : "))
            
            if 0 <= index < len(liste):
                return liste[index]
            else:
                print(f"Erreur : Index doit être entre 0 et {len(liste)-1}")
                
        except ValueError:
            print("Erreur : Veuillez entrer un nombre entier")

Gestion de IndexError avec validation de plage

Réponse finale :

def acceder_element():
    liste = [10, 20, 30, 40, 50]
    print(f"Liste : {liste}")
    
    while True:
        try:
            index = int(input(f"Entrez un index (0-{len(liste)-1}) : "))
            
            if index < 0:
                print("Erreur : L'index ne peut pas être négatif")
                continue
            elif index >= len(liste):
                print(f"Erreur : L'index doit être inférieur à {len(liste)}")
                continue
            
            element = liste[index]
            print(f"L'élément à l'index {index} est : {element}")
            break
            
        except ValueError:
            print("Erreur : Veuillez entrer un nombre entier valide")

# Exemple d'utilisation
acceder_element()

Lois et principes :

• IndexError : Levée lors d'accès hors limites

• Validation de plage : Vérifier que l'index est dans les bornes

• Longueur dynamique : Utiliser len() pour la borne supérieure

5 Gestion des erreurs de lecture de fichiers

Définition des erreurs de fichiers :

Erreurs de fichiers : Exceptions levées lors de l'accès à des fichiers (FileNotFoundError, PermissionError, etc.).

Types d'erreurs de fichiers

FileNotFoundError : Fichier inexistant
PermissionError : Droits insuffisants
IOError : Problème d'entrée/sortie
UnicodeDecodeError : Problème d'encodage

Étape 1 : Gestion basique de lecture

try:
    nom_fichier = input("Entrez le nom du fichier : ")
    with open(nom_fichier, 'r') as f:
        contenu = f.read()
        print(contenu)
except FileNotFoundError:
    print("Erreur : Fichier non trouvé")
except PermissionError:
    print("Erreur : Permissions insuffisantes")

Étape 2 : Gestion complète

def lire_fichier_securise():
    while True:
        try:
            nom_fichier = input("Nom du fichier : ")
            with open(nom_fichier, 'r', encoding='utf-8') as f:
                return f.read()
        except FileNotFoundError:
            print("Erreur : Fichier introuvable")
        except PermissionError:
            print("Erreur : Permissions refusées")
        except UnicodeDecodeError:
            print("Erreur : Problème d'encodage")
        except IOError as e:
            print(f"Erreur d'E/S : {e}")

# Utilisation
contenu = lire_fichier_securise()
print(contenu)

Étape 3 : Validation du chemin

import os

def lire_fichier_valide():
    while True:
        nom_fichier = input("Entrez le nom du fichier : ")
        
        if not os.path.exists(nom_fichier):
            print("Erreur : Fichier inexistant")
            continue
            
        if not os.access(nom_fichier, os.R_OK):
            print("Erreur : Fichier non lisible")
            continue
        
        try:
            with open(nom_fichier, 'r', encoding='utf-8') as f:
                return f.read()
        except Exception as e:
            print(f"Erreur lors de la lecture : {e}")

Gestion complète des erreurs de fichiers avec validation

Réponse finale :

import os

def lire_fichier_sans_erreur():
    while True:
        nom_fichier = input("Entrez le nom du fichier à lire : ")
        
        # Vérification de l'existence du fichier
        if not os.path.exists(nom_fichier):
            print(f"Erreur : Le fichier '{nom_fichier}' n'existe pas")
            continue
        
        # Vérification des permissions
        if not os.access(nom_fichier, os.R_OK):
            print(f"Erreur : Vous n'avez pas la permission de lire '{nom_fichier}'")
            continue
        
        try:
            with open(nom_fichier, 'r', encoding='utf-8') as f:
                contenu = f.read()
                print("Contenu du fichier :")
                print(contenu)
                break
        except UnicodeDecodeError:
            print("Erreur : Impossible de lire le fichier (problème d'encodage)")
        except IOError as e:
            print(f"Erreur d'entrée/sortie : {e}")
        except Exception as e:
            print(f"Erreur inattendue : {e}")

# Exemple d'utilisation
lire_fichier_sans_erreur()

Lois et principes :

• FileNotFoundError : Levée quand le fichier n'existe pas

• PermissionError : Levée quand les droits sont insuffisants

• Validation préalable : Vérifier existence et permissions avant ouverture

Cours bien détaillé

Erreur = Try × Except × Finally × Else × Validation

Formule de la gestion des erreurs d'entrée

🎯

Définition : La gestion des erreurs d'entrée consiste à anticiper, capturer et traiter les erreurs pouvant survenir lors de la saisie utilisateur.

📏

Objectifs : Assurer la robustesse du programme, améliorer l'expérience utilisateur, éviter les plantages.

📐

Types : ValueError, TypeError, IndexError, ZeroDivisionError, FileNotFoundError, etc.

📝

Applications : Saisie utilisateur, lectures de fichiers, conversions de types, accès aux structures de données.

💡

Conseil : Toujours encapsuler les saisies dans try/except

🔍

Attention : Capturer les exceptions spécifiques

⚡

Astuce : Valider avant de traiter

📋

Méthode : Utiliser des boucles pour la saisie répétée

✅

Vérification : Tester avec des entrées invalides

Structure de gestion des erreurs :

try : Bloc de code susceptible de lever une exception
except : Gestion spécifique d'une exception
else : Exécuté si aucune exception n'est levée
finally : Exécuté dans tous les cas
raise : Lever manuellement une exception

Concepts clés à retenir :

La gestion des erreurs améliore la robustesse des programmes
Les exceptions doivent être capturées spécifiquement
La validation préalable améliore la sécurité
Les boucles permettent de redemander la saisie
Les messages d'erreur doivent être clairs pour l'utilisateur

Processus de gestion des erreurs d'entrée

Saisie → Validation → Try/Except → Traitement → Correction → Répétition

Gestion des erreurs d'entréeExercices corrigés

Gestion des erreurs d'entrée
Exercices corrigés