Cara menggunakan pengelogan terbina dalam Python

Fungsi utama pengelogan

Menyediakan antara muka pengelogan dan pelbagai modul pemprosesan untuk pengguna menyimpan log dalam pelbagai format, membantu nyahpepijat atur cara atau merekod maklumat output semasa program berjalan.

peringkat log pembalakan

peringkat log log terbahagi kepada lima peringkat, keutamaan dari tinggi ke rendah ialah:

**KRITIKAL ** ralat program yang serius

**Ralat; **Ralat program/fungsi separa

**AMARAN; **Atur cara mungkin mempunyai ralat

**INFO **Apabila program berjalan seperti biasa Maklumat

Maklumat penyahpepijatan program DEBUG

Tahap rakaman log lalai ialah AMARAN, iaitu, ia hanya akan direkodkan apabila tahap log lebih besar daripada atau sama dengan AMARAN.

Tahap rakaman yang biasa digunakan ialah INFO, yang digunakan untuk merekodkan beberapa maklumat tentang operasi biasa program (serupa dengan cetakan).

Apabila tahap log mencapai AMARAN atau lebih tinggi, ini menunjukkan bahawa atur cara tidak dapat berjalan secara normal pada masa ini

Fungsi asas pengelogan

logging.basicConfig(**kwargs)

tidak mencipta pembalak; secara eksplisit ( logger), logger akar akan dibuat secara lalai, dan logging.basicConfig(**kwargs) boleh mencipta streamHandle dengan Pemformat lalai dan menambahkannya pada logger akar untuk memulakan konfigurasi asas.

Sebagai contoh,

import logging
logging.debug('Debug code!')
logging.info('Run code!')
logging.warning('Watch out!')  
logging.error('This is an error')
logging.critical('This is a ciritical')

Dalam kod di atas, pengelogan tidak secara eksplisit mencipta logger (logging.getLogger), tetapi secara langsung menggunakan debug(), info(), warning(), ralat (), logger akar lalai akan digunakan apabila critical() dipanggil, dan logging tersuai atau lalai.basicConfig(**kwargs) akan dipanggil secara automatik untuk memulakan pengelog akar.

Parameter dalam logging.basicConfig(**kwargs) tersuai mempunyai pilihan utama berikut:

参数	功能
filename	指定保存日志的文件名，用指定文件名创建一个FileHandler，记录的日志会保存到该文件中
format	指定输出的格式和内容，默认是以冒号分割的levalname、name 和 message
datefmt	使用指定的日期/时间格式，与 time.strftime() 所接受的格式相同。
level	指定根日志记录器级别，默认为 logging.WARNING
stream	指定日志的输出流，可以指定输出到sys.stderr,std.stdout 或 文件，默认输出到sys.stderr。使用指定的流初始化StramHandler，注意：stream和filename参数不兼容，如果两者同时使用，则会引发ValueError 错误

Sebagai contoh, perkara berikut dilakukan dengan menyesuaikan logging.basicConfig(**kwargs) Mulakan pengelog akar untuk mendapatkan rekod log tahap DEBUG dan ke atas dan simpannya ke fail log.txt.

import logging
logging.basicConfig(filename='./log.txt',
                        format='%(asctime)s-%(name)s-%(levelname)s-%(message)s-%(funcName)s:%(lineno)d',
                        level=logging.DEBUG)
logging.debug('Debug code!')
logging.info('Run code!')
logging.warning('Watch out!')  
logging.error('This is an error')
logging.critical('This is a ciritical')

Empat komponen utama (kelas) pembalakan

Logger

Selain daripada root logger, perkara yang paling penting ialah anda boleh mencipta logger anda sendiri.

Segera logger melalui fungsi peringkat modul logging.getLogger(name)

Secara lalai, logger menggunakan struktur hierarki dan . digunakan untuk membezakan tahap yang berbeza. Contohnya, jika terdapat pembalak bernama foo, maka foo.a dan foo.b kedua-duanya adalah pembalak anak foo. Sudah tentu, pembalak peringkat pertama atau tertinggi ialah pembalak akar. Jika name=None, root logger dibina.

Anda boleh terus menggunakan nama modul semasa sebagai nama pembalak logging.getLogger(__name__)

Pembalak peringkat kanak-kanak biasanya tidak perlu menetapkan tahap log dan Pengendali secara berasingan logger peringkat kanak-kanak tidak ditetapkan secara berasingan , tingkah lakunya akan diwakilkan kepada ibu bapa. Contohnya, pembalak foo mempunyai tahap INFO, tetapi foo.a mahupun foo.b tidak menetapkan tahap log. Pada masa ini, foo.a dan foo.b akan mengikut tetapan tahap foo, iaitu, hanya log yang lebih besar daripada atau sama dengan tahap INFO akan direkodkan Jika foo tidak ditetapkan, pencatat akar akan ditemui . Tahap lalai akar ialah WARGING.

Beberapa kaedah kelas pembalak yang biasa digunakan

方法	功能描述
Logger.setLevel()	设置日志器（Logger）将会处理的日志消息级别
Logger.addHandler()	添加一个handler对象
Logger.removeHandler()	移除一个handler对象
Logger.addFilter()	添加一个filter对象
Logger.removeFilter()	移除一个filter对象
Logger.debug()	设置DEBUG级别的日志记录
Logger.info()	设置INFO级别的日志记录
Logger.warning()	设置WARNING级别的日志记录
Logger.error()	设置ERROR级别的日志记录
Logger.critical()	设置CRITICAL级别的日志记录
Logger.exception()	输出堆栈追踪信息
Logger.log()	设置一个自定义的level参数来创建一个日志记录

logger boleh mencapai fungsi berikut dalam kombinasi dengan tiga komponen lain yang akan diperkenalkan kemudian:

• Logger perlu mengeluarkan maklumat log ke lokasi sasaran melalui pengendali dan sasaran lokasi boleh menjadi sys. stdout dan fail dsb. (ini tidak konsisten dengan tetapan logging.basicConfig(**kwargs)).

• Seorang Logger boleh menetapkan Pengendali yang berbeza, dan Pengendali yang berbeza boleh mengeluarkan log ke lokasi yang berbeza (fail log yang berbeza), dan setiap Pengendali boleh menetapkan penapisnya sendiri untuk Melaksanakan penapisan log dan mengekalkan log diperlukan dalam projek sebenar. Pada masa yang sama, setiap Pengendali juga boleh menyediakan Pemformat yang berbeza, dan setiap Pemformat boleh menyedari bahawa log yang sama boleh dikeluarkan ke tempat yang berbeza dalam format yang berbeza.

Mengendalikan

pemproses; ia boleh mengawal di mana log yang direkodkan adalah output (output/fail/...), dan pemproses juga boleh menambah penapis Penapis dan formatter digunakan untuk mengawal kandungan output dan format output.

Ia mempunyai beberapa pemproses biasa:

• log.StreamHandler pemproses strim standard, yang menghantar mesej ke strim output standard dan strim ralat--> sys.stdout) # sys.stdout bermaksud menunjuk ke konsol, iaitu output standard; apabila kita memanggil print obj untuk mencetak objek dalam Python, kita sebenarnya memanggil sys.stdout.write(obj+'n').

• cetak mencetak kandungan yang anda perlukan pada konsol, dan kemudian menambahkan aksara baris baharu

• log.Pemproses fail FileHandler, mesej Hantar kepada fail --> logging.FileHandler(log_path)

• logging.RotatingFileHandler pengendali fail, selepas fail mencapai saiz yang ditentukan, dayakan fail baharu untuk menyimpan log

• log.TimedRotatingFileHandler pengendali fail, log memutarkan fail log pada selang masa tertentu

Beberapa kaedah biasa kelas pemegang

Handler.setLevel()	设置处理器将会处理的日志消息的最低严重级别
Handler.setFormatter()	为处理器设置一个格式对象
Handler.addFilter()	为处理器添加一个过滤器对象
Handler.removeFilter()	为处理器删除一个过滤器对象
logging.StramHandler()	将日志消息发送到输出Stream，如std.out,std.err
logging.FilterHandler()	将日志消息发送到磁盘文件，默认情况文件大小会无线增长
RotationFileHandler()	将日志消息发送到磁盘文件，支持日志文件按大小切割
TimeRotatingFileHandler()	将日志消息发送到磁盘文件，并支持日志文件按时间切割
logging.handers.HTTPHandler()	将日志消息通过GET或POST的方式发送给一个HTTP服务器
logging.handlers.SMTPHandler()	将日志消息发送email地址

Filter

filter组件用来过滤 logger 对象，一个 filter 可以直接添加到 logger对象上，也可以添加到 handler 对象上，而如果在logger和handler中都设置了filter，则日志是先通过logger的filter，再通过handler的filter。由于所有的信息都可以经过filter，所以filter不仅可以过滤信息，还可以增加信息。

Filter 类的实例化对象可以通过 logging.Filter(name) 来创建，其中name 为 记录器的名字，如果没有创建过该名字的记录器，就不会输出任何日志：

filter = logging.Filter("foo.a")

基本过滤器类只允许低于指定的日志记录器层级结构中低于特定层级的事件，例如 这个用 foo.a 初始化的过滤器，则foo.a.b;foo.a.c 等日志记录器记录的日志都可以通过过滤器，而foo.c; a.foo 等就不能通过。如果name为空字符串，则所有的日志都能通过。

Filter 类 有 三个方法 ：

• addFilter(filter) : 为 logger（logger..addFilter(filter)） 或者 handler（handler..addFilter(filter)） 增加过滤器

• removeFilter(filter) : 为 logger 或者 handler 删除一个过滤器

• filter(record) : 表示是否要记录指定的记录？返回零表示否，非零表示是。一般自定义Filter需要继承Filter基类，并重写filter方法

Formatter

格式化日志的输出；实例化：formatter = logging.Formatter(fmt=None,datefmt=None); 如果不指明 fmt，将默认使用 ‘%(message)s’ ，如果不指明 datefmt，将默认使用 ISO8601 日期格式。

其中 fmt 参数 有以下选项：

%(name)s	Logger的名字
%(levelno)s	数字形式的日志级别
%(levelname)s	文本形式的日志级别;如果是logger.debug则它是DEBUG，如果是logger.error则它是ERROR
%(pathname)s	调用日志输出函数的模块的完整路径名，可能没有
%(filename)s	调用日志输出函数的模块的文件名
%(module)s	调用日志输出函数的模块名
%(funcName)s	调用日志输出函数的函数名
%(lineno)d	调用日志输出函数的语句所在的代码行
%(created)f	当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d	输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s	字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d	线程ID。可能没有
%(threadName)s	线程名。可能没有
%(process)d	进程ID。可能没有
%(message)s	用户输出的消息; 假如有logger.warning("NO Good")，则在%(message)s位置上是字符串NO Good

例如：

formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s')		# -表示右对齐 8表示取8位
handler.formatter = formatter

datefmt 参数 有以下选项：

参数	含义
%y	两位数的年份表示（00-99）
%Y	四位数的年份表示（000-9999）
%m	月份（01-12）
%d	月内中的一天（0-31）
%H	24小时制小时数（0-23）
%I	12小时制小时数（01-12）
%M	分钟数（00=59）
%S 秒	（00-59）

例如：

formatter = logging.Formatter('%(asctime)s %(levelname)-8s: %(message)s')		# -表示右对齐 8表示取8位
handler.formatter = formatter

datefmt 参数 有以下选项：

参数	含义
%y	两位数的年份表示（00-99）
%Y	四位数的年份表示（000-9999）
%m	月份（01-12）
%d	月内中的一天（0-31）
%H	24小时制小时数（0-23）
%I	12小时制小时数（01-12）
%M	分钟数（00=59）
%S 秒	（00-59）

例子：

formatter = logging.Formatter("%(asctime)s %(levelname)s %(message)s","%Y%m%d-%H:%M:%S")
handler.formatter = formatter

logging 的配置

• conf 形式的配置

在 loguser.conf 中 写入相关的信息

[loggers]
keys=root,fileLogger,rotatingFileLogger

[handlers]
keys=consoleHandler,fileHandler,rotatingFileHandler

[formatters]
keys=simpleFormatter

[logger_root]
level=INFO
handlers=consoleHandler

[logger_fileLogger]
level=INFO
handlers=fileHandler
qualname=fileLogger
propagate=0

[logger_rotatingFileLogger]
level=INFO
handlers=consoleHandler,rotatingFileHandler
qualname=rotatingFileLogger
propagate=0

[handler_consoleHandler]
class=StreamHandler
level=INFO
formatter=simpleFormatter
args=(sys.stdout,)

[handler_fileHandler]
class=FileHandler
level=INFO
formatter=simpleFormatter
args=("logs/fileHandler_test.log", "a")

[handler_rotatingFileHandler]
class=handlers.RotatingFileHandler
level=WARNING
formatter=simpleFormatter
args=("logs/rotatingFileHandler.log", "a", 10*1024*1024, 50)

[formatter_simpleFormatter]
format=%(asctime)s - %(module)s - %(levelname)s -%(thread)d : %(message)s
datefmt=%Y-%m-%d %H:%M:%S

• 在使用logger时，直接导入配置文件即可

from logging import config

with open('./loguser.conf', 'r', encoding='utf-8') as f:
	## 加载配置
    config.fileConfig(f)
    ## 创建同名Logger，其按照配置文件的handle，formatter，filter方法初始化
    logger = logging.getLogger(name="fileLogger")

• yaml 形式配置文件

在 loguser.yaml文件 中 配置相关信息

version: 1
disable_existing_loggers: False
# formatters配置了日志输出时的样式
# formatters定义了一组formatID,有不同的格式;
formatters:
  brief:
      format: "%(asctime)s - %(message)s"
  simple:
      format: "%(asctime)s - [%(name)s] - [%(levelname)s] :%(levelno)s: %(message)s"
      datefmt: '%F %T'
# handlers配置了需要处理的日志信息,logging模块的handler只有streamhandler和filehandler
handlers:
  console:
      class : logging.StreamHandler
      formatter: brief
      level   : DEBUG
      stream  : ext://sys.stdout
  info_file_handler:
      class : logging.FileHandler
      formatter: simple
      level: ERROR
      filename: ./logs/debug_test.log
  error_file_handler:
    class: logging.handlers.RotatingFileHandler
    level: ERROR
    formatter: simple
    filename: ./logs/errors.log
    maxBytes: 10485760 # 10MB #1024*1024*10
    backupCount: 50
    encoding: utf8

loggers:
#fileLogger, 就是在代码中通过logger = logging.getLogger("fileLogger")来获得该类型的logger
  my_testyaml:
      level: DEBUG
      handlers: [console, info_file_handler,error_file_handler]
# root为默认情况下的输出配置, 当logging.getLogger("fileLoggername")里面的fileLoggername没有传值的时候,
# 就是用的这个默认的root,如logging.getLogger(__name__)或logging.getLogger()
root:
    level: DEBUG
    handlers: [console]

同样的可以通过导入 yaml 文件加载配置

with open('./loguser.yaml', 'r', encoding='utf-8') as f:
        yaml_config = yaml.load(stream=f, Loader=yaml.FullLoader)
        config.dictConfig(config=yaml_config)

    root = logging.getLogger()
    # 子记录器的名字与配置文件中loggers字段内的保持一致
    # loggers:
    #   my_testyaml:
    #       level: DEBUG
    #       handlers: [console, info_file_handler,error_file_handler]
    my_testyaml = logging.getLogger("my_testyaml")

logging 和 print 的区别

看起来logging要比print复杂多了，那么为什么推荐在项目中使用 logging 记录日志而不是使用print 输出程序信息呢。

相比与print logging 具有以下优点：

• 可以通过设置不同的日志等级，在 release 版本中只输出重要信息，而不必显示大量的调试信息；

• print 将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；logging 则可以由开发者决定将信息输出到什么地方，以及怎么输出；

• 和 print 相比，logging 是线程安全的。（python 3中 print 也是线程安全的了，而python 2中的print不是）（线程安全是指在多线程时程序不会运行混乱；而python 2 中的print 分两步打印信息，第一打印字符串，第二打印换行符，如果在这中间发生线程切换就会产生输出混乱。这就是为什么python2的print不是原子操作，也就是说其不是线程安全的）印信息，第一打印字符串，第二打印换行符，如果在这中间发生线程切换就会产生输出混乱。这就是为什么python2的print不是原子操作，也就是说其不是线程安全的）

Atas ialah kandungan terperinci Cara menggunakan pengelogan terbina dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!