Comment utiliser le module de journalisation pour vous connecter dans Python 3.x

Comment utiliser le module de journalisation pour la journalisation dans Python 3.x

Introduction :
Dans le processus de développement logiciel, la journalisation est un élément important. En enregistrant l'état d'exécution du programme et divers événements, le dépannage, l'analyse des performances et la surveillance du système peuvent être facilement effectués. Le module de journalisation de Python fournit des fonctions de journalisation puissantes et flexibles, qui peuvent facilement générer et gérer des journaux.

1. Présentation du module de journalisation
Logging est un module intégré à Python qui fournit des fonctions de journalisation complètes. En utilisant le module de journalisation, vous pouvez définir différents formats de sortie et cibles de sortie, et vous pouvez également contrôler facilement le niveau de journalisation et enregistrer et afficher de manière flexible les informations du journal selon vos besoins.

2. Journalisation de base
L'exemple suivant montre comment utiliser le module de journalisation pour la journalisation de base en Python :

import logging

# 配置日志记录器
logging.basicConfig(level=logging.DEBUG, 
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 创建日志记录器
logger = logging.getLogger('my_logger')

# 记录不同级别的日志
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

Dans le code ci-dessus, le journal global est d'abord configuré via la fonction basicConfig Le logger spécifie le niveau de journalisation comme DEBUG et spécifie le format du journal. Créez ensuite un logger spécifique nommé 'my_logger' via la fonction getLogger. Ensuite, à travers différents niveaux de méthodes, telles que debug, info, warning, error et critical , enregistre respectivement différents niveaux d'informations de journal. <code>basicConfig函数配置了全局的日志记录器，指定了日志记录的级别为DEBUG，并且指定了日志的格式。然后通过getLogger函数创建一个名为 'my_logger' 的具体的日志记录器。之后，通过不同级别的方法，如debug、info、warning、error和critical，分别记录了不同级别的日志信息。

三、日志级别和输出格式控制
logging模块提供了多个级别的日志记录，包括DEBUG、INFO、WARNING、ERROR和CRITICAL五个级别，从低到高依次递增。可以通过设置日志记录器和不同的处理器的级别，来控制日志记录的详细程度。

import logging

# 配置日志记录器
logging.basicConfig(level=logging.WARNING, 
                    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')

# 创建日志记录器
logger = logging.getLogger('my_logger')

# 创建文件处理器
file_handler = logging.FileHandler('log.txt')
file_handler.setLevel(logging.DEBUG)

# 创建控制台处理器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.ERROR)

# 设置处理器的输出格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)

# 添加处理器到记录器
logger.addHandler(file_handler)
logger.addHandler(console_handler)

# 记录不同级别的日志
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')

在上述代码中，首先通过basicConfig函数将全局的日志记录级别设置为WARNING。然后使用getLogger函数创建名为 'my_logger' 的日志记录器。接着创建了两个处理器，一个是写入文件的文件处理器，一个是输出到控制台的控制台处理器。通过设置处理器的级别，可以分别控制文件和控制台的日志输出级别。最后，通过addHandler方法将处理器添加到日志记录器中。

四、更多高级配置
logging模块还提供了更多的高级配置选项，比如日志的输出位置、文件分割、日志轮转和日志审计等。下面是一个使用RotatingFileHandler进行日志文件轮转的示例：

import logging
from logging.handlers import RotatingFileHandler

# 创建日志记录器
logger = logging.getLogger('my_logger')
logger.setLevel(logging.DEBUG)

# 创建轮转文件处理器
file_handler = RotatingFileHandler('log.txt', maxBytes=1024, backupCount=5)

# 设置处理器的输出格式
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
file_handler.setFormatter(formatter)

# 添加处理器到记录器
logger.addHandler(file_handler)

# 记录不同级别的日志
for i in range(10):
    logger.debug('This is debug message %d' % i)

在上面的代码中，通过RotatingFileHandler

3. Contrôle du niveau de journalisation et du format de sortie

Le module de journalisation fournit plusieurs niveaux de journalisation, notamment DEBUG, INFO, WARNING. cinq niveaux de ERREUR et CRITIQUE, augmentant de faible à élevé. Vous pouvez contrôler la verbosité de la journalisation en définissant les niveaux de l'enregistreur et des différents processeurs.
rrreee

Dans le code ci-dessus, définissez d'abord le niveau de journalisation global sur WARNING via la fonction basicConfig. Utilisez ensuite la fonction getLogger pour créer un enregistreur nommé 'my_logger'. Ensuite, deux processeurs sont créés, l'un est le processeur de fichier qui écrit dans le fichier et l'autre est le processeur de console qui génère des sorties vers la console. En définissant le niveau du processeur, vous pouvez contrôler respectivement les niveaux de sortie des journaux des fichiers et des consoles. Enfin, ajoutez le gestionnaire au logger via la méthode addHandler. 🎜🎜4. Configurations plus avancées🎜Le module de journalisation fournit également des options de configuration plus avancées, telles que l'emplacement de sortie des journaux, le fractionnement des fichiers, la rotation des journaux et l'audit des journaux, etc. Voici un exemple d'utilisation de RotatingFileHandler pour la rotation des fichiers journaux : 🎜rrreee🎜Dans le code ci-dessus, un gestionnaire de fichiers est créé via la classe RotatingFileHandler et la taille maximale du fichier est spécifiée à 1 024 octets. , réservé Le nombre de fichiers de sauvegarde est de 5. De cette façon, lorsque le fichier journal atteint la taille maximale, il sera automatiquement divisé en plusieurs fichiers tout en conservant le nombre spécifié de fichiers de sauvegarde. 🎜🎜Résumé : 🎜Cet article présente la méthode de base d'utilisation du module de journalisation pour la connexion dans Python 3.x. En utilisant différents niveaux de méthodes, différents niveaux d'informations de journal peuvent être enregistrés facilement. En configurant différents processeurs et formats, vous pouvez contrôler de manière flexible l'emplacement de sortie et le format du journal. Dans le même temps, le module de journalisation fournit également des options de configuration plus avancées, telles que le fractionnement des fichiers, la rotation des journaux, etc., pour répondre à des besoins de journalisation plus complexes. Pour les débutants en journalisation, commencer par les méthodes de base et maîtriser progressivement les options de configuration plus avancées contribuera à améliorer la maintenabilité et l’efficacité du débogage du code. 🎜

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!