Prérequis

Avant de vous plonger dans cette leçon, vous devez être familiarisé avec :

• Le travail avec les listes et les dictionnaires

Objectifs pédagogiques

À la fin de cette leçon, vous serez capable de :

• Reconnaître les différents types d'erreurs Python
• Gérer les exceptions avec try/except
• Valider le code en utilisant les assertions

Les erreurs font inévitablement partie de la programmation, mais comprendre comment les gérer efficacement est une compétence cruciale qui peut faire gagner du temps et améliorer la qualité de votre code. En Python, la plupart des erreurs qui se produisent pendant l'exécution du programme sont connues sous le nom d'exceptions. Les exceptions sont des événements qui perturbent le flux normal d'exécution d'un programme et doivent être traitées pour éviter que le programme ne plante.

Les exceptions en Python peuvent être largement classées en trois types principaux : les erreurs de syntaxe, les exceptions d'exécution, et les erreurs sémantiques. Chaque type d'erreur survient dans des circonstances différentes et nécessite une approche différente pour être géré efficacement.

Dans cette leçon, nous explorerons chacun de ces types d'erreurs en détail, en apprenant à les identifier et à mettre en œuvre des stratégies efficaces pour les gérer. Nous couvrirons également les meilleures pratiques pour la gestion des exceptions et la prévention des erreurs, vous équipant ainsi des outils nécessaires pour écrire un code Python plus robuste et plus fiable.

Une erreur de syntaxe (ou erreur d'analyse) se produit lorsque Python rencontre du code qui ne suit pas les règles de syntaxe correctes du langage. Ces erreurs empêchent l'exécution du programme jusqu'à ce qu'elles soient corrigées. Lorsque Python rencontre une erreur de syntaxe, il lève une exception SyntaxError et fournit un traceback — un rapport détaillé qui indique où l'erreur s'est produite, vous aidant à identifier et corriger rapidement l'erreur.

Voici un exemple de code avec une syntaxe Python invalide :

Bien que l'erreur soit à la ligne 4 (où la virgule est manquante), le traceback pointe vers la ligne 5 : Le caret (^) sous 'country': 'USA' à la ligne 5 indique où Python détecte en premier que quelque chose ne va pas. Python s'attend à une autre entrée de dictionnaire ou à l'accolade fermante } après 'New York' mais trouve à la place la clé inattendue 'country': sans virgule de séparation.

Erreurs de syntaxe courantes en Python

Pour vous aider à éviter les erreurs de syntaxe, voici quelques-unes des erreurs les plus courantes :

Parenthèses manquantes ou mal appariées :

Indentation incorrecte :

Guillemets non appariés :

Mauvaise utilisation ou oubli des deux-points (:) :

Les deux-points sont requis après les instructions qui introduisent un bloc indenté, comme les définitions de fonctions, les boucles et les instructions conditionnelles. Oublier un deux-points ou le placer incorrectement conduira à une erreur de syntaxe.

Une erreur d'exécution se produit pendant l'exécution d'un programme, contrairement aux erreurs de syntaxe qui sont détectées avant l'exécution. Ces erreurs surviennent lorsque le code est syntaxiquement correct mais rencontre des conditions inattendues ou des erreurs logiques. Par exemple, une division par zéro ou l'accès à un index de liste hors limites.

Lorsqu'une erreur d'exécution se produit, Python lève une exception. Si elle n'est pas gérée, le programme s'arrête et affiche un traceback. Ce traceback indique le type d'erreur, le numéro de ligne et la pile d'appels.

Erreurs d'exécution courantes en Python

Voici quelques-unes des erreurs d'exécution les plus courantes que vous pouvez rencontrer en Python :

ZeroDivisionError

Générée lorsqu'une opération de division ou de modulo est effectuée avec zéro comme diviseur.

TypeError

Générée lorsqu'une opération ou une fonction est appliquée à un objet d'un type inapproprié.

NameError

Générée lorsque vous essayez d'utiliser un nom de variable ou de fonction qui n'a pas été défini. Cela peut arriver si vous faites une faute d'orthographe, oubliez de déclarer une variable, ou essayez d'utiliser une fonction qui n'a pas été importée ou définie.

IndexError

Générée lorsque vous essayez d'accéder à un élément dans une liste, un tuple ou une autre séquence en utilisant un index hors limites.

KeyError

Générée lorsque vous essayez d'accéder à un dictionnaire avec une clé qui n'existe pas.

Gestion des erreurs d'exécution

Python fournit les blocs try et except pour gérer élégamment les erreurs d'exécution. Ces blocs vous permettent de "capturer" les exceptions qui se produisent pendant l'exécution du programme et de les gérer de manière contrôlée. Cela garantit que votre programme continue de fonctionner correctement même lorsque quelque chose d'inattendu se produit.

Comment fonctionnent try et except :

• Bloc try : Contient le code qui pourrait lever une exception. Python tente d'exécuter ce code.
• Bloc except : Si une exception se produit dans le bloc try, Python passe immédiatement au bloc except. Ce bloc contient le code pour gérer l'erreur, comme afficher un message d'erreur ou prendre une action corrective.

Voici un exemple qui montre comment gérer une ZeroDivisionError en Python :

L'utilisateur saisit 10 pour le numérateur et 0 pour le dénominateur. Python essaie de calculer 10 / 0, provoquant une ZeroDivisionError. Le bloc except capture cette erreur et affiche : Error: You cannot divide by zero!

Les erreurs sémantiques (ou erreurs logiques) se produisent lorsque le code s'exécute sans erreurs de syntaxe ou d'exécution mais produit des résultats incorrects en raison d'erreurs de logique. Ces erreurs sont difficiles à détecter car le code ne plante pas.

Considérons l'exemple suivant :

Comme nous pouvons le voir dans l'image, le code Python s'exécute correctement mais donne un résultat erroné à cause d'une erreur sémantique. Pour identifier de telles erreurs, nous pouvons comparer le résultat réel à la valeur attendue en utilisant le mot-clé assert. Cela génèrera une AssertionError si le résultat est incorrect.

L'instruction assert est utilisée pour valider que la variable average contient la moyenne correcte des trois nombres. S'il y a une erreur dans le calcul, la condition average == sum([num1, num2, num3]) / 3 sera False, déclenchant une AssertionError avec le message "Error: Incorrect average calculation!".

L’exemple donné ci-dessus est volontairement simple pour illustrer comment les erreurs logiques peuvent être détectées. Dans un scénario réel, un développeur écrirait probablement la formule correcte dès le départ (ou utiliserait une bibliothèque comme NumPy pour éviter les erreurs). Cependant, cette méthode est particulièrement utile dans des cas plus complexes où les erreurs sont moins évidentes.

L’utilisation d’assertions permet de tester le code à chaque étape et d’attraper des erreurs au plus tôt. Cela favorise un développement plus sûr, surtout pour les projets complexes, où des erreurs mineures peuvent avoir de grandes conséquences.

Exercice

Pour l'exercice, créez un notebook jupyter et nommez-le debugging.ipynb dans le dossier exercises à l'intérieur de Handling_Exceptions

Scénario

Vous gérez un système de retours clients qui catégorise les entrées utilisateur en trois thèmes principaux : Product Quality, Pricing, et Service. Cependant, votre algorithme de catégorisation comporte plusieurs erreurs qui l'empêchent de traiter correctement les entrées. En tant que responsable métier, vous devez travailler avec votre équipe technique pour résoudre les problèmes afin que le système fonctionne correctement et fournisse des analyses précises.

Voici le code problématique :

feedback = input('Please enter Q, P, or S (for [Q]uality, [P]ricing, and [S]ervice): ')

elif feedback.upper() not in 'QPS':
    print('Invalid input. Please enter Q, P, or S.')

elif feedback.upper() == system_category
    print('Your feedback matches our pre-defined category.')

if feedback.upper() = 'S':
    print('Your feedback is related to "Service".')

system_category = 'P'

Votre tâche

1. Lire le code : Commencez par lire attentivement le code. Recherchez les erreurs de syntaxe ou les erreurs de logique qui pourraient générer une erreur d’exécution du programme ou produire des résultats incorrects.
2. Exécuter le code
3. Appliquer les techniques de débogage :
   • Lire le message d'erreur : Si un message d'erreur s'affiche lors de l'exécution du code, lisez-le attentivement pour comprendre ce qui ne va pas.
   • Ajouter des instructions print : Utilisez des instructions print() pour vérifier les valeurs des variables comme feedback.upper() et system_category à différents points du programme.
   • Rechercher l'erreur sur Stack Overflow : Si vous rencontrez une erreur inconnue, essayez de rechercher le message d’erreur sur Stack Overflow ou d’autres forums pour trouver des solutions potentielles. Vous pouvez également demander à un chatbot comme ChatGPT, qui peut analyser l’erreur et proposer des explications ou des solutions adaptées rapidement.
4. Réorganiser et corriger le code : Apportez les modifications nécessaires au code pour qu'il s'exécute sans erreur et produise les résultats attendus.
5. Tester votre solution : Après avoir effectué les modifications, exécutez le programme plusieurs fois avec différentes entrées (par exemple, "Q", "P", "S", ou une entrée invalide) pour vous assurer qu'il se comporte comme prévu dans tous les scénarios.

Solution

# Get user input for feedback category
feedback = input('Please enter Q, P, or S (for [Q]uality, [P]ricing, and [S]ervice): ')

# Validate the input
if feedback.upper() not in 'QPS':
    print('Invalid input. Please enter Q, P, or S.')
else:
    # Pre-defined system category for comparison
    system_category = 'P'

    # Check if the feedback matches the system category
    if feedback.upper() == system_category:
        print('Your feedback matches our pre-defined category (Pricing).')

    # Check for specific feedback categories
    elif feedback.upper() == 'S':
        print('Your feedback is related to "Service".')
    elif feedback.upper() == 'Q':
        print('Your feedback is related to "Quality".')

Lorsque vous êtes confronté à un bug ou une erreur dans votre code, il est important d'aborder le problème de manière systématique. Le tableau ci-dessous présente plusieurs techniques de débogage efficaces :

Excellent travail ! Dans cette leçon, vous avez exploré comment gérer différents types d'erreurs en Python, une compétence essentielle pour écrire un code robuste et fiable.

Vous savez maintenant que les erreurs de syntaxe se produisent lorsque le code ne respecte pas les règles de Python, empêchant l'exécution du programme. Vous avez également exploré les exceptions d'exécution, qui se produisent pendant l'exécution du programme.

De plus, vous vous êtes entraîné à utiliser des outils comme les blocs try et except pour gérer les exceptions, et l'instruction assert pour valider les hypothèses dans votre code. Vous avez découvert comment des techniques comme la lecture des messages d'erreur, l'ajout d'instructions print, l'utilisation de débogueurs et la consultation de la documentation peuvent vous aider à identifier et corriger les erreurs plus efficacement.

Continuez votre excellent travail !