Discussion pratique sur la façon dont Python effectue la gestion et la journalisation des exceptions

[Aperçu de diffusion en direct] Les grands modèles remplaceront-ils les programmeurs ? "

Cet article est partagé par la communauté Huawei Cloud « Gestion et journalisation des exceptions Python pour créer des applications robustes et fiables » par Lemony Hug.

La gestion et la journalisation des exceptions sont des éléments essentiels à l'écriture d'applications logicielles fiables et faciles à entretenir. Python fournit un puissant mécanisme de gestion des exceptions et des fonctions de journalisation flexibles, permettant aux développeurs de gérer plus facilement les erreurs dans le code et de suivre le processus d'exécution de l'application. Dans cet article, nous explorerons les meilleures pratiques en matière de gestion et de journalisation des exceptions en Python, ainsi que du code de cas pour illustrer ces concepts.

L’importance de la gestion des exceptions

La gestion des exceptions fait référence au processus de gestion des erreurs ou des situations anormales pouvant survenir lors de l'exécution du programme. Une bonne gestion des exceptions peut nous aider à :

Améliorer la stabilité du programme : en détectant et en gérant les exceptions, nous pouvons éviter les plantages inattendus du programme et améliorer la stabilité des applications.
Améliorer l'expérience utilisateur : lorsqu'une erreur se produit dans le programme, des invites et une gestion d'erreur conviviales peuvent améliorer l'expérience utilisateur et éviter une mauvaise impression des utilisateurs à l'égard du programme.
Débogage et maintenance plus faciles : une bonne gestion des exceptions peut nous aider à localiser et à résoudre plus facilement les problèmes du programme et à améliorer la maintenabilité du code.

Gestion des exceptions en Python

En Python, la gestion des exceptions est implémentée via l'instruction try-sauf. Voici un exemple simple de gestion des exceptions :

essayer:
    # Tentative d'exécution de code pouvant lever une exception
    résultat = 10 / 0
sauf ZeroDivisionError :
    # Gérer des types spécifiques d'exceptions
    print("Une erreur de division par zéro s'est produite !")

Dans cet exemple, nous essayons de calculer 10 divisé par 0, ce qui déclenche une exception ZeroDivisionError. Ensuite, nous utilisons la clause except pour intercepter cette exception et afficher le message d'erreur. En plus de détecter des types spécifiques d'exceptions, nous pouvons également utiliser exceptla clause pour détecter tous les types d'exceptions pour la gestion générique des erreurs.

En plus de détecter les exceptions, nous pouvons également utiliser elsedes clauses pour exécuter du code spécifique lorsqu'aucune exception ne se produit dans le bloc try, et finallydes clauses pour exécuter du code de nettoyage spécifique, qu'une exception se produise ou non.

L’importance de la journalisation

La journalisation est une technique qui enregistre des informations importantes lors de l'exécution d'une application. Une bonne journalisation nous aide à :

Suivre le processus d'exécution de l'application : en enregistrant les événements clés et les informations d'état, nous pouvons suivre le processus d'exécution de l'application et nous aider à comprendre le comportement du programme.
Diagnostic et débogage : lorsqu'un problème survient dans le programme, la journalisation peut fournir des informations de débogage utiles pour nous aider à localiser et à résoudre rapidement le problème.
Surveillance et analyse : en analysant les données des journaux, nous pouvons comprendre les performances et l'utilisation de l'application, ce qui nous aide à optimiser et à améliorer le programme.

Connexion en Python

Les modules de la bibliothèque standard Python loggingoffrent des fonctionnalités de journalisation puissantes et flexibles. Nous pouvons utiliser ce module pour créer un enregistreur, définir le niveau de journalisation, définir le format du journal, etc. Voici un exemple de journalisation simple :

journalisation des importations

# Créer un enregistreur
enregistreur = journalisation.getLogger(__name__)
logger.setLevel(logging.INFO)

#Créer un gestionnaire de fichiers
file_handler = journalisation.FileHandler('app.log')
file_handler.setLevel(logging.INFO)

#Créer un format de journal
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatteur)

# Ajouter un gestionnaire au logger
logger.addHandler(file_handler)

# Enregistrer les informations du journal
logger.info('Ceci est un journal d'informations')
logger.warning('Ceci est un journal d'avertissement')
logger.error('Ceci est un journal d'erreurs')

Dans cet exemple, nous créons d’abord un enregistreur loggeret définissons le niveau de journalisation sur INFO. Nous avons ensuite créé un gestionnaire de fichiers file_handler, défini son niveau sur INFO également et défini le format du journal. Enfin, nous ajoutons le processeur de fichiers à l'enregistreur et utilisons des méthodes telles que logger.info(), logger.warning()et logger.error()pour enregistrer différents niveaux d'informations de journal.

Exemples de bonnes pratiques

Voici un exemple de bonnes pratiques combinant gestion des exceptions et journalisation :

journalisation des importations

# Créer un enregistreur
enregistreur = journalisation.getLogger(__name__)
logger.setLevel(logging.INFO)

#Créer un gestionnaire de fichiers
file_handler = journalisation.FileHandler('app.log')
file_handler.setLevel(logging.INFO)

#Créer un format de journal
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatteur)

# Ajouter un gestionnaire au logger
logger.addHandler(file_handler)

def diviser (x, y):
    essayer:
        résultat = x / y
    sauf ZeroDivisionError comme e :
        logger.error(f"erreur de division par zéro : {e}")
    sauf exception comme e :
        logger.error(f"Une exception s'est produite : {e}")
    autre:
        logger.info(f"Résultat : {résultat}")
    enfin:
        logger.info("Opération terminée")

# Fonction de test
diviser(10, 2)
diviser (10, 0)

Dans cet exemple, nous définissons une divide()fonction appelée qui calcule le quotient de deux nombres. À l'intérieur de la fonction, nous utilisons une instruction try-sauf pour détecter d'éventuelles erreurs de division par zéro et utilisons un enregistreur pour enregistrer les informations d'exception. A la fin de l'exécution de la fonction, nous utilisons finallyune clause pour enregistrer des informations sur la fin de l'opération.

Mieux comprendre comment utiliser Python pour la gestion et la journalisation des exceptions, et appliquer ces bonnes pratiques dans des projets réels. Dans le développement réel, en plus de la gestion et de la journalisation des exceptions de base, une configuration et une optimisation plus complexes peuvent également être effectuées en fonction des caractéristiques et des besoins du projet, telles que :

Utiliser des classes d'exceptions personnalisées : en plus des types d'exceptions intégrés à Python, nous pouvons également définir nos propres classes d'exceptions pour mieux organiser et gérer les informations sur les exceptions.
Utilisation flexible des niveaux de journalisation : Selon les différentes parties et besoins de l'application, le niveau de l'enregistreur peut être ajusté de manière flexible pour le débogage et la surveillance dans différents environnements.
Enregistrement hiérarchique des journaux : en plus d'utiliser différents niveaux de méthodes de journalisation, les journaux peuvent également être enregistrés dans différents fichiers ou sources de données en fonction de l'importance et du type des messages de journal pour une analyse et un traitement ultérieurs.
Intégrer des services de journalisation tiers : Pour les grands projets ou les systèmes distribués, vous pouvez envisager d'intégrer des services de journalisation tiers (tels que ELK Stack, Splunk, etc.) pour obtenir des fonctions de gestion et de surveillance des journaux plus avancées.

Pour résumer, la gestion des exceptions et la journalisation sont des composants indispensables et importants dans le développement d'applications Python. En utilisant raisonnablement le mécanisme de gestion des exceptions et les fonctions de journalisation fournies par Python, et en configurant et en optimisant de manière flexible en fonction de la situation réelle du projet, nous pouvons écrire des applications logicielles plus robustes et plus fiables, améliorer l'expérience utilisateur et réduire le coût des pannes. l'occurrence et le traitement. , fournissant un soutien solide pour la livraison, l'exploitation et la maintenance réussies du projet.

Dans des projets réels, voici quelques conseils supplémentaires et bonnes pratiques qui peuvent encore améliorer l'efficacité et la maintenabilité de la gestion et de la journalisation des exceptions :

Utilisation des gestionnaires de contexte

Le gestionnaire de contexte est un élégant outil de gestion des ressources en Python qui garantit l'allocation et la libération correctes des ressources. En combinant les gestionnaires de contexte et la gestion des exceptions, nous pouvons mieux gérer les ressources et éviter les fuites de ressources et les erreurs inattendues. Par exemple, vous pouvez utiliser withdes instructions pour gérer les opérations sur les fichiers :

essayer:
    avec open('file.txt', 'r') comme f :
        contenu = f.read()
sauf FileNotFoundError :
    logger.error('Le fichier n'existe pas')
sauf exception comme e :
    logger.error(f'Une exception s'est produite : {e}')

Utiliser des décorateurs

Les décorateurs sont une fonctionnalité puissante de Python qui peut être utilisée pour ajouter une logique supplémentaire avant et après l'exécution d'une fonction. En personnalisant les décorateurs, nous pouvons implémenter une logique unifiée de gestion des exceptions et de journalisation et éviter d’écrire à plusieurs reprises du code similaire dans chaque fonction. Par exemple, vous pouvez écrire un décorateur pour enregistrer le temps d'exécution de la fonction et les informations sur les exceptions :

heure d'importation

def log_exceptions (func) :
    def wrapper(*args, **kwargs):
        essayer:
            start_time = time.time()
            résultat = func(*args, **kwargs)
            end_time = time.time()
            logger.info(f"{func.__name__} temps d'exécution : {end_time - start_time} secondes")
            résultat de retour
        sauf exception comme e :
            logger.error(f"Une exception s'est produite dans la fonction {func.__name__} : {e}")
    emballage de retour

@log_exceptions
def une_fonction() :
    # Logique de fonction
    passer

Combiné avec des codes d'erreur

Dans les applications complexes, les codes d'erreur peuvent être utilisés pour identifier différents types d'erreurs afin de mieux organiser et gérer les informations sur les exceptions. En définissant un ensemble de codes d'erreur et les messages d'erreur correspondants, vous pouvez rendre votre code plus lisible et plus maintenable. Par exemple:

ERROR_CODE_DIVIDE_BY_ZERO = 1001
ERREUR_CODE_FILE_NOT_FOUND = 1002

def diviser (x, y):
    essayer:
        résultat = x / y
    sauf ZeroDivisionError :
        logger.error(f"erreur de division par zéro : {e}", extra={'error_code' : ERROR_CODE_DIVIDE_BY_ZERO})
    sauf FileNotFoundError :
        logger.error(f"Fichier introuvable : {e}", extra={'error_code' : ERROR_CODE_FILE_NOT_FOUND})

Utiliser une bibliothèque de journalisation tierce

En plus du module de journalisation dans la bibliothèque standard Python, il existe de nombreuses excellentes bibliothèques de journalisation tierces parmi lesquelles choisir, telles que Loguru, structlog, etc. Ces bibliothèques fournissent des fonctions plus riches et des API plus conviviales, et vous pouvez choisir la bibliothèque appropriée pour la journalisation en fonction des besoins réels.

Définir des politiques claires au niveau des journaux

Lors de la conception d'un système de journalisation, une politique claire au niveau des journaux doit être définie pour garantir l'exactitude et la lisibilité des informations des journaux. Généralement, différents niveaux de journalisation peuvent être définis en fonction de l'importance et de l'urgence du message de journal, tels que DEBUG, INFO, AVERTISSEMENT, ERREUR et CRITICAL. Dans le développement quotidien, des niveaux de journalisation appropriés doivent être utilisés en fonction de situations spécifiques afin de garantir que les informations du journal ne soient ni trop verbeuses ni que des informations critiques ne soient perdues.

Tenir compte des besoins d’internationalisation et de localisation

Pour les applications ciblant des utilisateurs mondiaux, les exigences d'internationalisation et de localisation doivent être prises en compte, et des méthodes de texte et de formatage internationalisées standard doivent être utilisées dans les enregistrements de journaux pour garantir la lisibilité et la cohérence des informations de journal dans différents environnements linguistiques. Dans le même temps, les formats horaires et les habitudes des différents fuseaux horaires et régions doivent également être pris en compte pour mieux comprendre et analyser les informations des journaux.

Mettre en œuvre la rotation et l’archivage des journaux

Dans les applications à exécution longue, les fichiers journaux peuvent croître continuellement et occuper de grandes quantités d'espace disque. Pour éviter cette situation, vous pouvez mettre en œuvre des fonctions de rotation et d'archivage des journaux, ainsi que nettoyer et compresser régulièrement les anciens fichiers journaux pour économiser de l'espace de stockage et garantir l'accessibilité des informations des journaux. Vous pouvez utiliser des bibliothèques tierces en Python (telles que LogRotate) pour implémenter des fonctions de rotation et d'archivage des journaux, ou les implémenter vous-même en fonction des besoins du projet.

Intégrer des systèmes de surveillance et d’alarme

Dans un environnement de production, il est crucial de détecter et de gérer les exceptions en temps opportun. Par conséquent, les systèmes de surveillance et d’alerte peuvent être combinés pour obtenir une surveillance et une alerte en temps réel des informations des journaux. En ajoutant des mots-clés et des identifiants aux enregistrements des journaux et en mettant en place un système de surveillance pour les surveiller, des situations anormales peuvent être découvertes à temps et des mesures correspondantes peuvent être prises pour garantir le fonctionnement stable de l'application.

Apporter des améliorations et des optimisations continues

La gestion et la journalisation des exceptions sont un processus d'amélioration continue, et les stratégies existantes de gestion et de journalisation des exceptions doivent être régulièrement revues et optimisées pour s'adapter au développement et aux changements du projet. Les enregistrements de journaux peuvent être analysés et comptés régulièrement pour découvrir les problèmes potentiels et l'espace d'optimisation, et les processus et mécanismes de gestion des exceptions et de journalisation peuvent être ajustés et améliorés en temps opportun pour améliorer la stabilité et la maintenabilité de l'application.

Grâce aux conseils et aux bonnes pratiques ci-dessus, nous pouvons mieux appliquer Python pour la gestion et la journalisation des exceptions, et créer des applications logicielles robustes et fiables dans des projets réels. La gestion des exceptions et la journalisation sont des maillons importants dans le processus de développement logiciel. Ils peuvent non seulement nous aider à trouver et à résoudre les problèmes, mais également à améliorer la maintenabilité et la lisibilité du code, fournissant ainsi un soutien solide pour la livraison et le fonctionnement réussis du projet.

Résumer

La gestion et la journalisation des exceptions sont des composants indispensables et critiques dans le développement d'applications Python. À travers l'introduction et la discussion détaillée de cet article, nous approfondissons les meilleures pratiques d'utilisation de Python pour la gestion et la journalisation des exceptions, et fournissons une multitude de codes de cas et de techniques pour aider les développeurs à mieux comprendre et appliquer ces concepts importants.

En termes de gestion des exceptions, nous avons appris à utiliser l'instruction try-sauf pour intercepter et gérer les exceptions qui peuvent survenir, et avons expliqué comment utiliser les clauses else et final pour effectuer le travail de nettoyage associé. Nous avons également exploré comment combiner des techniques avancées telles que les gestionnaires de contexte et les décorateurs pour améliorer encore l'efficacité et la maintenabilité de la gestion des exceptions.

En termes de journalisation, nous avons examiné en profondeur le module de journalisation dans la bibliothèque standard Python et avons appris à créer un enregistreur, à définir le niveau de journalisation et à définir le format de journalisation ainsi que d'autres opérations de base. En outre, nous avons également expliqué comment utiliser différents niveaux de journalisation et méthodes de journalisation en fonction des exigences du projet, et comment combiner des technologies telles que les codes d'erreur et les bibliothèques de journaux tierces pour obtenir des fonctions de journalisation plus flexibles et plus efficaces.

En plus de la gestion de base des exceptions et de la journalisation, nous explorons également une série de conseils avancés et de bonnes pratiques, tels que la définition de politiques claires au niveau des journaux, la prise en compte des besoins d'internationalisation et de localisation, la mise en œuvre de la rotation et de l'archivage des journaux, et la combinaison d'un système de surveillance et d'alerte, etc. Ces compétences et pratiques peuvent aider les développeurs à mieux faire face aux exigences complexes des projets et aux situations réelles, et à améliorer la qualité et la maintenabilité du code.

En bref, en appliquant correctement les meilleures pratiques de gestion et de journalisation des exceptions, nous pouvons écrire des applications Python robustes et fiables, améliorer l'expérience utilisateur, réduire l'apparition de pannes et les coûts de traitement, et fournir un soutien solide pour la livraison et le fonctionnement réussis des projets. Dans les futurs travaux de développement, nous devons continuer à prêter attention et à optimiser continuellement la gestion et la journalisation des exceptions pour garantir la stabilité et la maintenabilité de l'application et fournir aux utilisateurs de meilleurs services et expériences.

Cliquez pour suivre et découvrir les nouvelles technologies de Huawei Cloud dès que possible~