Connexion Python - Votre guide unique

La journalisation est une étape cruciale à effectuer par un programmeur lors du développement du logiciel. Il aide les développeurs à suivre les événements qui se produisent pendant l'exécution d'un programme, ce qui peut être utile pour le futur processus de débogage. Si vous êtes un nouvel apprenant ou que vous travaillez sur un nouveau projet, c'est une bonne pratique d'utiliser la journalisation pour suivre le flux de code et pour résoudre les erreurs.

Lors de l'écriture de programmes courts, la plupart d'entre nous ignorent généralement la journalisation, mais lorsque le programme devient complexe, il s'agit d'une étape essentielle et utile de l'utilisation de la journalisation pour corriger les erreurs qui empêchent le logiciel de fonctionner correctement. La journalisation n'est rien de plus que l'écriture des événements dans le logiciel dans un fichier journal ou la sortie dans le terminal.

La journalisation n'est pas seulement utilisée pour le débogage. C'est également un processus utile pour la collecte d'informations, la collecte de données d'utilisation et de nombreuses autres tâches utiles. C'est également l'une des fonctions les plus courantes pour les développeurs Web, non seulement pour détecter les erreurs, mais également pour collecter les données des utilisateurs telles que les adresses IP, qui peuvent être utilisées pour d'autres analyses commerciales.

En Python, la plupart des fonctionnalités de journalisation sont fournies par le enregistrement module présenté dans la bibliothèque standard de python, nous n'avons donc pas à faire de configuration supplémentaire. Voyons comment l'utiliser pour se connecter en python. Avant de suivre ce tutoriel, il est nécessaire d'avoir la dernière version de python installée sur votre système. Si vous n'avez pas installé le dernier python sur votre système, vous pouvez suivre notre guide étape par étape sur l'installation et la mise à jour de python sur Linux.

Le module de journalisation Python

Le module de journalisation de python est l'une des bibliothèques de journalisation les plus utilisées en python. La meilleure partie est qu'il est préinstallé avec la bibliothèque standard de python, nous n'avons donc pas à faire de configuration ou d'installation. Le module de journalisation est robuste et simple, ce qui signifie qu'il est utile à la fois pour les débutants et les entreprises. Pour utiliser le module de journalisation en python, nous devons l'importer dans notre programme comme je le fais dans la ligne de code suivante.

importer la journalisation

Voyons maintenant une démonstration de la façon dont nous pouvons enregistrer certains messages dans le terminal. Copiez simplement le code suivant dans votre IDE python préféré et exécutez.

importation journalisation journalisation.avertissement("Ceci est un avertissement")

En exécutant le code ci-dessus, nous obtiendrons la sortie comme indiqué dans l'image ci-dessous.

Comme on le voit dans la sortie, le programme imprime un message d'avertissement. Le module de journalisation a également d'autres niveaux de journalisation comme informations, erreur, etc., qui rendent notre tâche facile. Discutons-en brièvement avec des exemples.

Niveaux de journalisation Python

De nombreux niveaux de journalisation peuvent être utilisés pour consigner différents messages au niveau de gravité. Les niveaux fournis par le python enregistrement modules sont

CRITIQUE
ERREUR
ATTENTION
INFO
DÉBOGUER

Ces niveaux sont indiqués dans l'ordre décroissant de leur gravité. Voyons comment utiliser ces niveaux dans notre programme. Copiez simplement le code suivant et exécutez-le dans l'IDE Python.

importation journalisation journalisation.Critical ("Ceci est un message critique") journalisation.error("Ceci est un message d'erreur") journalisation.warning("Ceci est un message d'avertissement").info("Ceci est un message d'information").debug ("Ceci est un message de débogage")

Lors de l'exécution du code ci-dessus dans l'IDE, la sortie affichée par le terminal est affichée dans l'image ci-dessous.

Comme vous pouvez le voir dans la sortie, les messages DEBUG et INFO ne sont pas imprimés dans le terminal car le module de journalisation, par défaut, n'enregistre que les messages de niveau de sécurité supérieur ou égal à l'avertissement. Pour afficher INFO et DEBUG dans le terminal, nous devons modifier manuellement la configuration de base de l'enregistreur. Pour ce faire, nous pouvons utiliser le basicConfig(**kwargs) méthode fournie par le module de journalisation. Pour voir une simple démonstration de configuration, exécutez simplement le code suivant dans votre IDE Python.

importation journalisation journalisation.basicConfig(niveau=journalisation.DEBUG) journalisation.Critical ("Ceci est un message critique") journalisation.error("Ceci est un message d'erreur") journalisation.warning("Ceci est un message d'avertissement").info("Ceci est un message d'information").debug ("Ceci est un message de débogage")

Dans le code ci-dessus, nous avons défini le niveau de enregistrement.DÉBOGUER, ce qui signifie que tous les niveaux qui sont au-dessus du niveau de débogage seront enregistrés. Ainsi, dans le code ci-dessus, tous les messages seront enregistrés comme indiqué dans l'image ci-dessous.

Discutons plus en détail de la méthode basicConfig() du module de journalisation.

Configurations de base

Le module de journalisation fournit une méthode très utile basicConfig(**Kwargs), qui est utilisée pour définir les configurations pour la journalisation des données. Certains des paramètres couramment utilisés de la fonction basicConfig() sont :

niveau: Ceci est utilisé pour définir le niveau de gravité, qui doit être enregistré.
nom de fichier: Ceci est utilisé pour spécifier le fichier où nous voulons enregistrer les messages. Si nous ne définissons pas le fichier, alors il sera enregistré dans le terminal, comme nous l'avons vu jusqu'à présent.
mode fichier : Ceci est utilisé lorsque nous écrivons les journaux dans un fichier. Ces paramètres acceptent le mode d'ouverture du fichier journal. Par défaut, il est défini sur le mode 'a', ce qui signifie que le fichier s'ouvrira en mode ajout.
format: Ceci est utilisé pour formater le message de journal car nous en avons besoin pour afficher.

Voyons comment nous pouvons utiliser ces configurations dans le module de journalisation de python en explorant l'exemple de l'une après l'autre.

Le paramètre level est utilisé pour définir le niveau de gravité, pour voir une démonstration pratique de son utilisation, copiez le code ci-dessous dans l'IDE python et exécutez.

importation journalisation journalisation.basicConfig(niveau=journalisation.INFO) journalisation.Critical ("Ceci est un message critique") journalisation.error("Ceci est un message d'erreur") journalisation.warning("Ceci est un message d'avertissement").info("Ceci est un message d'information").debug ("Ceci est un message de débogage")

Lors de l'exécution du code, vous pouvez voir la sortie, comme indiqué dans l'image ci-dessous. Comme vous pouvez le voir, les messages situés au-dessus des niveaux d'informations sont imprimés, mais le message au niveau de débogage ne s'imprime pas.

Le paramètre level est une configuration utile qui doit être effectuée pour que les fichiers journaux ne soient pas trop volumineux en contenant des données inutiles et n'aient que les informations requises.

Connexion à un fichier

Nous avons seulement vu comment se connecter au terminal, mais la connexion au terminal n'est pas toujours utile car nous ne pouvons pas l'enregistrer pour une utilisation ultérieure. Pour une meilleure solution, nous pouvons imprimer les journaux dans un fichier texte que nous sauvegardons et analysons plus tard. Les journaux sont du texte et peuvent être conservés dans un fichier texte de n'importe quel format, mais il est universellement adopté pour enregistrer les journaux dans un fichier avec le .extension de journal. Ces fichiers sont appelés fichiers journaux et sont utilisés universellement pour stocker les journaux de programmes, d'applications Web et d'autres logiciels.

Nous pouvons enregistrer les journaux dans un fichier en configurant la configuration du module de journalisation à l'aide de la fonction basicConfig(). Nous devons donner le nom du fichier où nous voulons enregistrer les journaux dans le paramètre filename de la fonction basicConfig(), après quoi les enregistrements seront automatiquement imprimés dans le fichier journal que nous spécifions. Voyons un exemple pratique pour savoir comment cela fonctionne.

importation journalisation journalisation.basicConfig(niveau=journalisation.INFO, nom_fichier="monjournal.log") journalisation.Critical ("Ceci est un message critique") journalisation.error("Ceci est un message d'erreur") journalisation.warning("Ceci est un message d'avertissement").info("Ceci est un message d'information").debug ("Ceci est un message de débogage")

Lors de l'exécution du code, vous pouvez voir qu'un nouveau fichier a été créé dans le nom du répertoire de travail actuel mon journal.Journal. En ouvrant le fichier avec un éditeur de texte, vous remarquerez peut-être que les journaux ont été enregistrés dans le fichier.

Si nous réexécutons le code, nous verrons que le journal sera ajouté dans le fichier. Nous pouvons changer cela en spécifiant le paramètre filemode dans la fonction basiconfig(). Par défaut, le paramètre filemode a la valeur "a", qui signifie append. Mais parfois, nous voulons également supprimer les données précédemment enregistrées et écrire les nouveaux journaux uniquement dans le fichier. Pour ce faire, nous pouvons donner au paramètre filemode la valeur "w", qui signifie écriture, et il supprime toutes les données précédentes dans le fichier et écrit les nouvelles. Pour une démo, voir l'exemple suivant.

importation journalisation journalisation.basicConfig(niveau=journalisation.INFO, nom_fichier="monjournal.log", filemode="w") journalisation.Critical ("Ceci est un message critique") journalisation.error("Ceci est un message d'erreur") journalisation.warning("Ceci est un message d'avertissement").info("Ceci est un message d'information").debug ("Ceci est un message de débogage")

Lors de l'exécution du code ci-dessus, vous remarquerez peut-être que les journaux précédents présents dans le fichier ont été supprimés du fichier et que les nouveaux journaux ont été ajoutés. Chaque fois que nous exécutons le code, les nouveaux journaux seront ajoutés et le précédent sera supprimé, ce qui est utile lorsque nous n'avons pas besoin des enregistrements pour une utilisation ultérieure.

Formatage des journaux

Nous avons vu que les journaux de sortie ont la disposition par défaut, mais nous pouvons modifier le format en définissant le paramètre de format de la fonction basicConfig(). Voyons une démonstration pratique pour savoir comment nous pouvons utiliser le paramètre format dans la fonction basicConfig() pour changer le format du journal.

importation journalisation journalisation.basicConfig(niveau=journalisation.INFO, format="%(filename)s : %(levelname)s : %(message)s") journalisation.Critical ("Ceci est un message critique") journalisation.error("Ceci est un message d'erreur") journalisation.warning("Ceci est un message d'avertissement").info("Ceci est un message d'information").debug ("Ceci est un message de débogage")

La sortie du code ci-dessus est comme indiqué dans l'image ci-dessous.

Comme vous pouvez le voir dans la sortie, le nom du fichier a également été affiché. Nous pouvons utiliser le paramètre format pour indiquer de nombreux autres formats, discutons de certains d'entre eux.

%(asctime)s : Ceci est utilisé pour afficher l'heure lisible par l'homme dans les journaux. Pour voir comment il affiche l'heure, exécutez le code suivant dans l'IDE Python.

importation journalisation journalisation.basicConfig(niveau=journalisation.INFO, format="%(asctime)s : %(message)s") journalisation.avertissement("Ceci est un message d'avertissement")

Lors de l'exécution du code, vous pouvez voir la sortie, comme indiqué dans l'image ci-dessous.

%(créé)f : Cela affichera l'heure à laquelle le journal est créé.

%(nom de fichier)s : Ceci est utilisé pour afficher le nom du fichier dans le message de journal. Pour voir comment cela fonctionne, exécutez simplement l'exemple de code suivant dans votre IDE Python.

importation journalisation journalisation.basicConfig(niveau=journalisation.INFO, format="%(asctime)s : %(filename)s : %(message)s") journalisation.avertissement("Ceci est un message d'avertissement")

La sortie fournie par le code est illustrée dans l'image suivante. Dans la sortie, le nom du fichier a été affiché. Ceci est utile lorsque vous travaillez sur un projet impliquant plusieurs fichiers afin que nous puissions obtenir rapidement le fichier contenant l'erreur.

%(nom de niveau)s : Ceci est utilisé pour afficher le nom du niveau utilisé comme WARNING, DEBUG, etc.

%(niveauno)s : Ceci est utilisé pour imprimer la valeur numérique du niveau auquel le message fait partie.

%(lineno)d : Ceci est utilisé pour imprimer le numéro de ligne de la ligne en cours, qui affiche le message. C'est très utile car cela nous donne le numéro de ligne où nous devons voir une erreur, donc cela aide le processus de débogage. Voyons un exemple de code pour voir comment l'utiliser pour former la sortie des journaux.

Importer la journalisation Format = '%(asctime)s : %(filename)s:%(lineno)d : %(message)s' journalisation.basicConfig(niveau=journalisation.INFO, format= Format) journalisation.avertissement("Ceci est un message d'avertissement")

Ce code imprimera également le numéro de ligne, comme indiqué dans l'image ci-dessous.

%(messages: Il est utilisé pour afficher le message que nous avons enregistré.

%(chemin)s : Ceci est utilisé pour afficher le chemin complet du fichier de code source.

%(processus)d : Cela affichera l'identifiant du processus s'il est disponible.

%(processname)s : Cela affichera le nom du processus s'il est disponible.

%(fil)d : Cela affichera l'identifiant du fil s'il est disponible.

%(threadName)s : Cela affichera le nom du fil s'il est disponible.

Enregistrement des données variables

Nous avons donné nous-mêmes les messages dans les journaux, qui sont des données statiques. Pourtant, dans les applications du monde réel, les données que nous avons enregistrées seront principalement des informations dynamiques de notre application. Pour ce faire, nous devons sortir les variables avec le journal des messages. Nous pouvons le faire de plusieurs manières. Par exemple, nous pouvons inclure les variables et formater la chaîne avec des espaces réservés, puis les transmettre au journal des messages afin que les valeurs des variables soient sorties dans les enregistrements.

Par exemple, consultez le code ci-dessous ; vous pouvez copier le code et l'exécuter dans votre IDE python.

journalisation des importations var_message = journalisation "erreur interne".warning("Le serveur a été arrêté à cause de %s", var_message)

Lors de l'exécution du code, vous verrez la sortie, comme indiqué dans l'image ci-dessous. Comme vous pouvez le voir sur l'image que la valeur stockée dans la variable est également imprimée à l'écran.

Nous pouvons également afficher des variables dans les journaux en utilisant les f-strings, qui sont introduits en python 3.6. Mais pour utiliser les f-strings, vous aurez besoin de python 3.6 ou supérieur installé dans votre système. Vous pouvez vérifier quelle version de python est installée sur votre système en exécutant la commande suivante dans le terminal.

python --version # pour python 2 sous Linux python3 --version # pour python 3 sous Linux

Cela imprimera la version de python que vous utilisez dans votre système. C'est une bonne pratique d'utiliser la dernière version de python pour obtenir de meilleures performances ; vous pouvez consulter notre guide pour mettre à jour votre version de python sous Linux.

Pour formater des chaînes à l'aide des f-strings en python, nous devons utiliser la syntaxe de code suivante. Vous pouvez copier et exécuter le code dans votre IDE python préféré.

journalisation des importations var_message = journalisation "erreur interne".warning(f"Le serveur a été arrêté à cause de var_message")

En exécutant le code, vous obtiendrez une sortie similaire à celle que nous obtenons en exécutant le code ci-dessus. Mais quand on voit le code, on peut remarquer le f au début de la chaîne, qui représente qu'il s'agit d'une f-string, et on peut directement utiliser des variables dans les f-strings en les mettant entre accolades.

Journalisation des traces de pile

Le module de journalisation peut également être utilisé pour capturer des traces de pile. Les traces de pile sont les messages d'exception qui sont émis lorsqu'une erreur s'est produite dans le programme. Nous pouvons capturer l'exception en configurant le paramètre exc_info sur True lors de l'appel de la fonction de journalisation. Ce paramètre est utile car nous pouvons enregistrer le message d'exception complet avec notre message d'erreur dans un fichier ou un écran de terminal.

Pour obtenir une démo pratique pour savoir comment nous pouvons supprimer les traces de la pile, copiez le code suivant dans votre IDE python et exécutez.

import logging try: a = 1/0 sauf exception car e: logging.error("Une erreur s'est produite", exc_info=True)

Lors de l'exécution du code, l'exception sera enregistrée dans le terminal. Vous verrez la sortie du code, comme indiqué dans l'image ci-dessous. Vous pouvez également enregistrer l'exception dans un fichier en utilisant le paramètre filename dans la méthode basicConfig(), comme nous l'avons vu ci-dessus.

Cette méthode est également essentielle à la création de l'application étendue, car nous pouvons gérer les exceptions avec la journalisation, ce qui est excellent pour le processus de débogage.

Objets de consignation

Le module de journalisation fournit également des classes utiles qui peuvent être utilisées pour une meilleure journalisation, principalement pour une application plus large. Voyons quelques-unes des classes les plus utilisées du module de journalisation et quoi et comment elles fonctionnent.

Enregistreurs : La classe Logger est la classe dont les objets sont utilisés pour appeler directement les fonctions.
Gestionnaires : Les gestionnaires sont utilisés pour envoyer les messages de journal à l'emplacement de sortie souhaité i.e., fichier ou console.
Filtres : Ceci est utilisé pour filtrer l'affichage des enregistrements de journal.
Formateurs : Ceux-ci ont été utilisés pour formater la sortie des messages de journaux.

Si vous souhaitez des détails complets sur l'utilisation de ces classes, vous pouvez vous référer à la documentation officielle du module de journalisation python.

Conclusion

Dans cet article, nous avons appris les bases de la connexion en python. Le module de journalisation est un moyen simple et puissant de se connecter en python. Supposons que vous ne fassiez pas de journalisation jusqu'à présent, aujourd'hui est le jour pour commencer à journaliser pendant que vous lisez l'article et avez appris à quel point il est facile d'utiliser la connexion en python. Vous pouvez désormais utiliser la connexion dans les applications petites et importantes.

Si vous vous connectez correctement, cela sera en effet utile d'une manière ou d'une autre. Je vous conseille de commencer à l'utiliser à partir de petits programmes car cela vous aidera à avoir une bonne connaissance de la chose ou deux et sera inestimable pour les gros projets. Vous voudrez peut-être aussi voir comment travailler avec les bases de données SQLite en python.