Gestion des erreurs en Python : meilleures pratiques. Découvrez comment gérer efficacement les exceptions

Résumé :

Les erreurs de programme sont irrécupérables ; lorsqu'un programme rencontre une erreur, il se ferme ou plante immédiatement.

Les bons programmeurs s'assurent que leur code ou leur logiciel peut gérer correctement les erreurs/exceptions qui peuvent survenir lors de l'utilisation du logiciel sans planter ni produire de résultats indésirables. Imaginez écrire un logiciel pour une institution financière qui n'accepte que la saisie numérique, si l'utilisateur saisit des lettres au lieu de chiffres pour les opérations arithmétiques, cela générera généralement une erreur et le logiciel plantera à cause d'un seul utilisateur, s'il n'y a aucun mécanisme dans endroit pour gérer les mots d’erreur. Ce n’est certainement pas une bonne chose : c’est mauvais pour les affaires, cela peut frustrer les clients et quelqu’un pourrait perdre son emploi pour cause d’incompétence.

Dans cet article, nous apprendrons comment gérer au mieux les erreurs dans votre code qui peuvent survenir en raison de l'interaction de l'utilisateur. restez à l'écoute.

Prérequis

Cet article convient à :

• Développeurs de logiciels Python souhaitant apprendre à gérer les exceptions dans leur code.
• Les personnes qui connaissent déjà Python et souhaitent apprendre les concepts de gestion des erreurs en Python.
• Professionnels existants cherchant à améliorer leurs connaissances de la gestion des erreurs Python.

Objectif

Après avoir lu cet article, les lecteurs devraient être capables de :

• Comprendre clairement le concept de gestion des erreurs en Python et son importance.
• Découvrez les classes d'exceptions personnalisées et comment les implémenter.
• Comprenez la principale différence entre les erreurs et les exceptions en Python.

Explication des erreurs et exceptions

Erreur et Exception sont souvent utilisés de manière interchangeable, mais ils signifient techniquement des choses différentes. En Python, Error et Exception sont toutes deux des sous-classes de BaseException, ceci en outre montre que même s’ils sont différents, ils ont quelque chose en commun.

Erreur

Les erreurs sont irrécupérables ; lorsque notre programme rencontre une erreur, il se ferme ou plante immédiatement. Même si vous pouvez vous attendre à des erreurs, il n’existe aucun moyen de les gérer par programmation. Certaines erreurs sont répertoriées ci-dessous :

SyntaxError：

C'est l'un des types d'erreurs les plus courants rencontrés par les programmeurs. Il se produit lorsque le code ne suit pas la syntaxe Python correcte et peut être détecté lors de l'analyse. C’est une question qui se pose facilement pour les apprenants ou les personnes passant d’autres langages de programmation à Python.

<code class="language-python">name = “Austin”;
print(name)</code>

Cela donne SyntaxError car en Python, les instructions ne se terminent pas par un point-virgule.

IndentationError：

Cette erreur se produit lorsque le code Python est mal indenté et est détecté lors de l'analyse du code. L'indentation en Python est très importante. C'est la seule manière en Python de définir des blocs de code, contrairement à la plupart des langages qui utilisent des accolades.

<code class="language-python">name = “Austin”;
print(name)</code>

Ce code provoquera des erreurs dues à une indentation incorrecte. Ce devrait être :

<code class="language-python">active = True
if (active):
print(“The user is active”)</code>

Exception

Des exceptions en Python se produisent au moment de l'exécution. Contrairement aux erreurs, elles peuvent être correctement gérées ou interceptées par programme afin que notre programme puisse continuer à s'exécuter sans planter. Autrement dit, ils sont récupérables. Voici quelques exceptions courantes en Python :

Exceptions intégrées

Ces types d'exceptions font partie du langage de programmation Python. Certains d'entre eux sont répertoriés ci-dessous :

ValueError：

Cette erreur se produit lorsqu'un paramètre non valide est transmis à une fonction, même si le type peut être correct.

<code class="language-python">if (active):
    print(“The user is active”)</code>

À partir de l'extrait de code ci-dessus, si nous transmettons une chaîne numérique à la fonction, elle sera convertie avec succès en nombre, sinon elle produira ValueError.

<code class="language-python">def str_num(num_string):
    return(int(string))</code>

TypeError：

Cette erreur est générée lorsqu'un paramètre de type inapproprié est transmis à une fonction.

<code class="language-python">print(str_num(“123”)) #works perfectly
print(str_num(“abc”)) #raises a ValueError</code>

Cela déclenchera TypeError.

IndexError：

Cette erreur se produit lorsque vous essayez d'accéder à une valeur dans une liste en utilisant le mauvais index.

<code class="language-python">def addition(num1, num2):
    return num1 + num2
# calling the function
addition(5, A)</code>

Cela donne IndexError car my_list[2] est inaccessible.

KeyError：

Cette erreur se produit lorsqu'une tentative est effectuée pour accéder à une valeur dans un dictionnaire à l'aide d'une clé incorrecte ou inexistante.

<code class="language-python">my_list = [“dog”, “cat”]
my_list[2]</code>

Cela déclenchera KeyError. Vous pouvez trouver d'autres exceptions intégrées ici.

Exception personnalisée

Les exceptions personnalisées sont définies par le programmeur. Ici, Python permet aux programmeurs de définir manuellement les conditions qu'un programme doit vérifier pendant l'exécution et de lever une exception s'il est trouvé. Vous pouvez y parvenir en créant une classe qui hérite de la classe Exception.

Gestion des exceptions

La gestion des exceptions garantit que nos applications logicielles ont des performances prévisibles lorsqu'elles rencontrent certaines erreurs qui surviennent au cours du cycle de vie de l'application. Dans cette section, vous apprendrez comment implémenter cela en programmation.

Utilisez la try-except déclaration

L'instruction

try-except fournit un moyen sûr de gérer le code susceptible de générer des erreurs ou des exceptions. Les instructions try enveloppent du code problématique ou des clauses try ; c'est la partie du code qui entraînera le plus probablement un dysfonctionnement de l'ensemble du programme ; cela est susceptible de se produire lors de la réception d'une entrée de l'utilisateur, lors de la lecture d'un fichier ; citer quelques exemples.

L'instruction

except marque le début de la clause except ; c'est le reste du code enveloppé dans un bloc except. La clause except gère les exceptions générées dans le bloc try.

Laissez-moi vous guider à travers le flux de travail d'exécution. Votre programme Python s'exécutera normalement jusqu'à ce qu'il atteigne le bloc try contenant le code "problématique", et s'il n'y a aucune erreur possible lors de l'exécution du code dans le bloc try à ce moment-là, il ignorera le bloc except et continuez Exécutez le reste de la base de code. Cependant, si une erreur est rencontrée lors de l'exécution du code dans le bloc try, immédiatement après la création de l'objet d'exception, le contrôle passe au bloc except où il doit être géré par la classe d'exception correspondante.

<code class="language-python">name = “Austin”;
print(name)</code>

À partir de l'extrait de code ci-dessus, si une valeur non numérique est transmise au programme, un objet d'exception est créé et ValueError est généré. Le contrôle passe immédiatement au bloc except, où il recherche la classe d'exception appropriée. Ici, la classe ValueError est suffisante. Les erreurs ont été traitées correctement. Cependant, si la bonne classe n'est pas trouvée, le contrôle se déplace vers le bloc try externe (s'il y en a un), et si l'exception n'est toujours pas gérée correctement, le programme plante.

Utilisez une except instruction pour gérer plusieurs classes d'exceptions

Peut vérifier plusieurs classes d'exceptions et gérer des exceptions spécifiques. Cette approche est préférable si vous ne savez pas laquelle des exceptions a entraîné l'exécution du code. Voir l'extrait de code ci-dessous.

<code class="language-python">active = True
if (active):
print(“The user is active”)</code>

Classe d'exceptions génériques

La classe

Exception est une sous-classe directe de BaseException. La classe Exception est la classe de base pour toutes les exceptions non fatales.

Dans la plupart des cas, la classe Exception est suffisante pour gérer la plupart des exceptions levées lors de l'exécution du code.

<code class="language-python">if (active):
    print(“The user is active”)</code>

Même si la classe Exception peut gérer des exceptions non fatales, il est préférable de l'utiliser avec prudence. Utilisez la bonne classe Exception car elle est meilleure pour le débogage et améliore la lisibilité du code.

Utilisez la déclaration finally

La partie du code enveloppée dans un bloc finally sera exécutée, qu'une exception se produise ou non. Cela le rend approprié pour gérer les tâches de nettoyage ; fermer des fichiers et libérer des ressources mémoire.

<code class="language-python">def str_num(num_string):
    return(int(string))</code>

Créer une classe d'exception personnalisée

La création d'exceptions personnalisées permet aux programmeurs de déclencher des exceptions spécifiques pour les logiciels. Cela peut inclure des conditions particulières ou des cas extrêmes qui peuvent nuire à la fonctionnalité d'un logiciel particulier. Les classes d'exceptions personnalisées définies doivent hériter de la classe Exception.

<code class="language-python">print(str_num(“123”)) #works perfectly
print(str_num(“abc”)) #raises a ValueError</code>

L'extrait de code ci-dessus montre comment créer et utiliser des exceptions personnalisées. Selon le cas d'utilisation, il peut être utilisé de manière plus complexe.

Pourquoi la gestion des erreurs/exceptions est importante

« Ne faites pas confiance à l'utilisateur » est un dicton courant parmi les développeurs de logiciels, qui réitère que vous ne pouvez pas être complètement sûr de la manière dont vos utilisateurs interagiront avec votre application logicielle ; quels types d'entrées ils entreront et ce que vous ferez. , le programmeur, le font lors de l'écriture de votre application. Il existe d'autres cas particuliers auxquels on n'a peut-être pas pensé. Certaines raisons importantes pour une gestion appropriée des erreurs/exceptions sont expliquées ci-dessous :

1. Prévenir les plantages Sans gestion des exceptions, les erreurs non gérées peuvent provoquer le crash soudain d'un programme. Cela peut entraîner une perte de données ou une mauvaise expérience utilisateur. Exemple: Aucune gestion des exceptions :

print(10 / 0) # ZeroDivisionError : division par zéro

Utiliser la gestion des exceptions :

essayez : imprimer(10/0) sauf ZeroDivisionError : print("Impossible de diviser par zéro !")

1. Améliorer l'expérience utilisateur Les exceptions correctement gérées facilitent l'utilisation des applications en fournissant des messages d'erreur significatifs au lieu d'erreurs système énigmatiques. Exemple:

essayez : age = int(input("Entrez votre âge :")) sauf ValueError : print("Saisie invalide ! Veuillez saisir un nombre.")

1. Maintenir la stabilité de l'application Il permet aux applications de continuer à s'exécuter même après avoir rencontré des erreurs, garantissant ainsi la stabilité. Exemple:

def diviser(a, b): essayer: retourner a/b sauf ZeroDivisionError : return "La division par zéro n'est pas autorisée !"

print(divide(10, 2)) # Sortie : 5.0 print(divide(10, 0)) # Résultat : la division par zéro n'est pas autorisée !

1. Gérer les situations extrêmes La gestion des exceptions vous permet de prendre en compte des situations imprévisibles telles que des pannes de réseau, des fichiers manquants ou une entrée utilisateur non valide. Exemple:

essayez : avec open("data.txt", "r") comme fichier : contenu = fichier.read() sauf FileNotFoundError : print("Le fichier est introuvable.")

1. Encourager l'écriture d'un code concis
   La gestion des exceptions rend votre code plus facile à lire, à déboguer et à maintenir en séparant la logique normale de la logique de gestion des erreurs.

2. Facilite le débogage
   Grâce aux messages d'erreur détaillés et aux journaux d'exceptions, les développeurs peuvent rapidement identifier et résoudre les problèmes dans leur code.
   Exemple :
   

journalisation des importations

essayez : résultat=10/0 sauf exception comme e : logging.error("Une erreur s'est produite", exc_info=True)

1. Critique pour les systèmes critiques Dans les systèmes où la fiabilité est critique (par exemple dans le secteur bancaire, dans le secteur de la santé), la gestion des exceptions est nécessaire pour garantir que les erreurs sont gérées en toute sécurité sans entraîner de corruption ou de perte de données.

Conclusion

En termes de programmation, les erreurs et les exceptions sont le plus souvent utilisées de manière interchangeable. La principale différence entre les erreurs et les exceptions en Python réside dans la manière dont elles affectent nos logiciels. Des erreurs telles que des erreurs de syntaxe et des erreurs d'indentation peuvent faire planter un programme lorsque l'interpréteur l'analyse. D'un autre côté, les exceptions peuvent faire planter le programme au moment de l'exécution si elles ne sont pas gérées correctement. Les exceptions personnalisées étendent les capacités de gestion des erreurs en permettant aux programmeurs de définir des classes d'exceptions spécifiques à une application logicielle particulière.

La gestion des erreurs est également très importante pour le débogage. Cela nous permet de voir pourquoi des erreurs se produisent dans l'application, fournissant ainsi aux responsables du logiciel suffisamment d'informations pour résoudre le problème. Assurez-vous toujours que la gestion des exceptions est introduite de manière appropriée dans votre code pour garantir la robustesse de votre application logicielle.

Merci d'avoir lu.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!