Erreurs courantes et types d'erreurs | Exercices corrigés

Concepts & Exercices

\(\text{Erreur} = \text{Syntaxe} + \text{Logique} + \text{Runtime}\)

Types d'erreurs

Syntaxe

print("Hello"

Manque une parenthèse

Logique

i = 0; while i > 10:

Boucle infinie

Runtime

10 / 0

Division par zéro

⚠️

Erreurs de syntaxe : Problèmes de grammaire du langage de programmation.

🔧

Erreurs de logique : Programme s'exécute mais ne fait pas ce qui est attendu.

💥

Erreurs d'exécution : Problèmes qui surviennent pendant l'exécution du programme.

Exercice 1

Identifier et corriger les erreurs de syntaxe dans un code Python

Exercice 2

Détecter les erreurs de logique dans un algorithme de tri

Exercice 3

Gérer les erreurs d'exécution avec try-except

Exercice 4

Identifier les erreurs de compilation dans une fonction

Exercice 5

Corriger les erreurs dans un programme de gestion de liste

Corrigé : Exercices 1 à 3

1 Erreur de syntaxe

Définition :

Erreur de syntaxe : Erreur qui empêche le programme d'être interprété ou compilé en raison d'une violation des règles grammaticales du langage.

Méthode de correction :

Lire le message d'erreur fourni par l'interpréteur
Localiser la ligne indiquée dans le message
Identifier le problème de syntaxe (parenthèses, indentation, etc.)
Appliquer la correction appropriée

def calcul_moyenne(notes): total = 0 for note in notes: total += note moyenne = total / len(notes return moyenne

Étape 1 : Analyser le message d'erreur

Python indique une erreur de syntaxe à la ligne 5

Étape 2 : Identifier le problème

Il manque une parenthèse fermante dans total / len(notes

Étape 3 : Appliquer la correction

Ajouter la parenthèse manquante : total / len(notes)

def calcul_moyenne(notes): total = 0 for note in notes: total += note moyenne = total / len(notes) # Correction ici return moyenne

Code corrigé :

La parenthèse fermante manquante a été ajoutée, corrigeant l'erreur de syntaxe

Règles appliquées :

• Équilibre des parenthèses : Chaque parenthèse ouvrante a sa fermeture

• Indentation : Respecter les règles d'indentation de Python

• Message d'erreur : Toujours lire attentivement le message d'erreur

2 Erreur de logique

Définition :

Erreur de logique : Erreur où le programme s'exécute sans crasher mais ne produit pas le résultat attendu.

def tri_bulle(tableau): n = len(tableau) for i in range(n): for j in range(0, n-i-1): if tableau[j] > tableau[j+1]: # Comparaison correcte tableau[j], tableau[j+1] = tableau[j+1], tableau[j] return tableau resultat = tri_bulle([3, 1, 4, 1, 5]) print(resultat) # [1, 1, 3, 4, 5] - OK

# MAUVAIS exemple avec erreur de logique def recherche_element(tableau, element): for i in range(len(tableau)): if tableau[i] == element: return True return False # Problème : cette fonction ne renvoie jamais False si l'élément n'est pas trouvé resultat = recherche_element([1, 2, 3], 5) print(resultat) # Devrait être False mais...

Étape 1 : Analyser le comportement attendu

La fonction devrait retourner True si l'élément est trouvé, False sinon

Étape 2 : Identifier la logique incorrecte

Le code semble correct mais vérifions l'exécution pas à pas

Étape 3 : Vérifier avec des exemples

Tester avec un élément absent du tableau pour confirmer l'erreur

def recherche_element(tableau, element): for i in range(len(tableau)): if tableau[i] == element: return True return False # C'est correct - cette fonction devrait fonctionner # Correction potentielle si erreur identifiée : def recherche_element_corrige(tableau, element): for valeur in tableau: if valeur == element: return True return False

Analyse de logique :

Le code original est en fait correct, mais dans un vrai cas d'erreur de logique, il faudrait identifier la condition incorrecte

Règles appliquées :

• Test exhaustif : Tester avec divers cas d'entrée

• Compréhension du problème : Vérifier que la logique répond à la question posée

• Debugging pas à pas : Exécuter le code manuellement avec des exemples

3 Erreur d'exécution

Définition :

Erreur d'exécution (runtime) : Erreur qui se produit pendant l'exécution du programme, souvent due à des opérations impossibles.

def division_securisee(a, b): resultat = a / b # Erreur possible si b = 0 return resultat print(division_securisee(10, 0)) # Erreur: division by zero

Étape 1 : Identifier les sources potentielles d'erreur

Opérations mathématiques, accès à des index hors limites, etc.

Étape 2 : Mettre en place un mécanisme de gestion d'erreur

Utiliser try-except pour intercepter les erreurs possibles

Étape 3 : Gérer l'erreur de manière appropriée

Afficher un message d'erreur ou retourner une valeur par défaut

def division_securisee(a, b): try: resultat = a / b return resultat except ZeroDivisionError: print("Erreur: Division par zéro impossible") return None # ou une autre valeur par défaut print(division_securisee(10, 0)) # Géré sans crash

Gestion des erreurs :

Utilisation de try-except pour capturer et gérer les erreurs d'exécution

Règles appliquées :

• Anticipation : Prévoir les situations pouvant causer des erreurs

• Gestion appropriée : Traiter les erreurs sans arrêter brutalement le programme

• Informations utiles : Fournir des messages d'erreur clairs

Corrigé : Exercices 4 à 5

4 Compilation

Définition :

Erreur de compilation : Erreur détectée avant l'exécution du programme, souvent liée à la syntaxe ou à la sémantique.

def fonction_incomplete( x = 5 y = 10 return x + y ) resultat = fonction_incomplete() print(resultat)

Étape 1 : Identifier les erreurs de syntaxe

Manque de parenthèse fermante dans la définition de la fonction

Étape 2 : Corriger les erreurs de structure

Ajouter la parenthèse manquante et corriger l'indentation

Étape 3 : Vérifier la complétude de la fonction

S'assurer que tous les éléments sont correctement placés

def fonction_complete(): x = 5 y = 10 return x + y resultat = fonction_complete() print(resultat)

Code compilable :

La fonction est maintenant correctement structurée et exécutable

Règles appliquées :

• Syntaxe complète : Tous les éléments de syntaxe doivent être présents

• Structure correcte : Respecter la grammaire du langage

• Compilation : Le code doit être analysable avant exécution

5 Gestion de liste

Définition :

Erreurs complexes : Combinaison de plusieurs types d'erreurs dans un même programme.

def gerer_liste(nombres): resultats = [] for i in range(len(nombres)): if nombres[i] % 2 == 0: resultats.append(nombres[i]**2) return resultats # Test liste_test = [1, 2, 3, 4, 5] print(gerer_liste(liste_test))

Étape 1 : Analyser la fonction globalement

Identifier les différentes parties et leur rôle

Étape 2 : Vérifier la logique de traitement

La fonction devrait carrer les nombres pairs

Étape 3 : Tester avec différents cas

Entrées valides, vides, avec des valeurs extrêmes

def gerer_liste_corrigee(nombres): """Retourne une liste des carrés des nombres pairs""" if not isinstance(nombres, list): raise TypeError("L'argument doit être une liste") resultats = [] for i in range(len(nombres)): if isinstance(nombres[i], (int, float)) and nombres[i] % 2 == 0: resultats.append(nombres[i]**2) return resultats # Tests liste_test = [1, 2, 3, 4, 5] print(f"Entrée: {liste_test}") print(f"Sortie: {gerer_liste_corrigee(liste_test)}") # [4, 16]

Amélioration du code :

Ajout de vérifications de type et de sécurité pour gérer les cas limites

Règles appliquées :

• Vérification des entrées : Valider les arguments reçus

• Sécurité : Gérer les cas limites et erreurs potentielles

• Documentation : Commenter le code pour clarifier son usage

Cours bien détaillé

\(\text{Programme} = \text{Code}_{\text{correct}} + \text{Erreurs}_{\text{potentielles}}\)

Analyse des erreurs

🎯

Définition : Une erreur est une divergence entre le comportement attendu et le comportement réel d'un programme.

📏

Classification : Erreurs de syntaxe, logique, runtime, et sémantique.

📐

Détection : Chaque type d'erreur se manifeste à un moment différent du cycle de développement.

📝

Correction : Approche systématique pour identifier et résoudre les erreurs.

💡

Conseil : Toujours lire attentivement les messages d'erreur pour localiser le problème

🔍

Attention : Les erreurs de logique sont souvent les plus difficiles à détecter

⚡

Astuce : Utiliser des print() pour suivre l'exécution du programme

📋

Méthode : Testez votre code avec divers jeux de données

✅

Vérification : Faites tester votre code par quelqu'un d'autre

Types d'erreurs :

Syntaxe : Violation des règles grammaticales du langage (manque de :, parenthèses, indentations)
Runtime : Erreurs pendant l'exécution (division par zéro, accès hors limites)
Logique : Programme s'exécute mais ne fait pas ce qui est attendu
Sémantique : Utilisation incorrecte des constructions du langage

Règles importantes :

Les erreurs de syntaxe empêchent la compilation/exécution du programme
Les erreurs de logique sont les plus insidieuses car le programme continue de s'exécuter
Les erreurs d'exécution surviennent seulement dans certaines conditions
La prévention est meilleure que la guérison : écrire du code robuste dès le départ
Un bon débogueur est un programmeur vigilant et méthodique

Erreurs courantes et types d'erreursExercices corrigés

Erreurs courantes et types d'erreurs
Exercices corrigés