logging模块

目录

• logging模块
  • 函数式简单配置
    • 灵活配置日志级别，日志格式，输出位置:
    • 日志切割
    • 配置参数：
  • logger对象配置
    • 日志详细使用
    • 配置成字典格式
    • 日志终极版
    • 日志使用(在项目中)

logging模块

函数式简单配置

import logging

'''根据日志级别的不同，选择性的记录'''
logging.debug('debug message')     # 10
logging.info('info message')  	   # 20
logging.warning('warning message') # 30
logging.error('error message')     # 40
logging.critical('critical message') # 50

默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。

灵活配置日志级别，日志格式，输出位置:

import logging

# 基本使用
# 产生日志的
file_handler = logging.FileHandler(filename='x1.log', mode='a', encoding='utf-8',)

"""
2023-03-13 12:06:48 PM - root - ERROR -05 logging模块基本使用:  你好
"""
# 指定日志的格式
logging.basicConfig(
    format='%(lineno)d - %(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s - %(pathname)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[file_handler,],
    level=logging.ERROR
)

logging.error('你好')  # 10

日志切割

import time
import logging
from logging import handlers

sh = logging.StreamHandler()
rh = handlers.RotatingFileHandler('myapp.log', maxBytes=1024,backupCount=5)
fh = handlers.TimedRotatingFileHandler(filename='x2.log', when='s', interval=5, encoding='utf-8')
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
    handlers=[fh,sh,rh],
    level=logging.ERROR
)

for i in range(1,100000):
    time.sleep(1)
    logging.error('KeyboardInterrupt error %s'%str(i))

配置参数：

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有：

filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

format参数中可能用到的格式化串：
%(name)s Logger的名字
%(levelno)s 数字形式的日志级别
%(levelname)s 文本形式的日志级别
%(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对象配置

# 日志的组成部分：
1. logger对象 # 负责产生日志
2. Filter对象 # 过滤的 （忽略）
3. Handler对象 # 负责日志产生的位置（文件中，终端中）
4. Formatter对象 # 负责产生的格式

logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过fh.setLevel(logging.Debug)单对文件流设置某个级别。

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8') # 再创建一个handler，用于输出到控制台 ch = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setLevel(logging.DEBUG)fh.setFormatter(formatter) ch.setFormatter(formatter) 
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象 logger.addHandler(ch) logger.debug('logger debug message') logger.info('logger info message') logger.warning('logger warning message') logger.error('logger error message') logger.critical('logger critical message')

日志详细使用

import logging


# 1.logger对象:负责产生日志
logger = logging.getLogger('转账记录')
# 2.filter对象:负责过滤日志(直接忽略)
# 3.handler对象:负责日志产生的位置
hd1 = logging.FileHandler('a1.log',encoding='utf8')  # 产生到文件的
hd2 = logging.FileHandler('a2.log',encoding='utf8')  # 产生到文件的
hd3 = logging.StreamHandler()  # 产生在终端的
# 4.formatter对象:负责日志的格式
fm1 = logging.Formatter(
    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S %p',
)
fm2 = logging.Formatter(
    fmt='%(asctime)s - %(name)s %(message)s',
    datefmt='%Y-%m-%d',
)
# 5.绑定handler对象
logger.addHandler(hd1)
logger.addHandler(hd2)
logger.addHandler(hd3)
# 6.绑定formatter对象
hd1.setFormatter(fm1)
hd2.setFormatter(fm2)
hd3.setFormatter(fm1)
# 7.设置日志等级
logger.setLevel(30)
# 8.记录日志
logger.debug('写了半天 好累啊 好热啊')

分析：

import logging

# 1.logger对象:负责产生日志
logger = logging.getLogger()
# 2.filter对象:负责过滤日志(直接忽略)  因为日志级别也可以过滤

# 3.handler对象:负责日志产生的位置
hd1 = logging.FileHandler('a1.log', encoding='utf8')  # 产生到文件的
hd2 = logging.FileHandler('a2.log', encoding='utf8')  # 产生到文件的
hd3 = logging.StreamHandler()  # 产生在终端的

# 4.formatter对象:负责日志的格式
fm1 = logging.Formatter(  ## __init__(self, fmt=None, datefmt=None, style='%')  日志的格式只能放fmt,datefmt两个参数
    fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S',
)
fm2 = logging.Formatter(
    fmt='%(asctime)s - %(name)s %(message)s',
    datefmt='%Y-%m-%d',
)
'''
formatter格式介绍：
%(asctime)s:时间位置，时间的格式是下面的datefmt
%(name)s：root
%(levelname)s：日志等级（分5级） DEBUG/INFO/WARNING/ERROR/CRITICAL
%(module)s：运行文件的文件名
%(message)s：需要记录的消息
'''

# 5.给logger对象绑定handler对象
logger.addHandler(hd1)
logger.addHandler(hd2)
logger.addHandler(hd3)
# 6.给handler绑定formmate对象
hd1.setFormatter(fm1)  # 给hd1设置格式
hd2.setFormatter(fm2)
hd3.setFormatter(fm1)
# 7.设置日志等级
logger.setLevel(10)
# 8.记录日志
logger.debug('写了半天 好累啊 好热啊')


# 终端中：hd3,设置fm1格式
2023-03-14 15:28:30 - root - DEBUG -01 logging:  写了半天 好累啊 好热啊
# a.log1： hd1,设置fm1格式
2023-03-14 15:28:30 - root - DEBUG -01 logging:  写了半天 好累啊 好热啊
# a.log2： hd2,设置fm2格式
2023-03-14 - root 写了半天 好累啊 好热啊

配置成字典格式

import logging
import logging.config

standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字

simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

test_format = '%(asctime)s] %(message)s'

logfile_path = 'a3.log'
# log配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
         'test': {
            'format': test_format
        },
    },
    'filters': {},  # 过滤日志
    'handlers': {
        #打印到终端的日志
        'console': {
            'level': 'DEBUG',
            # class 指定什么样的方式去写入日志，处理日志记录事件的类
            'class': 'logging.StreamHandler',  # 打印到屏幕
            # formatter用什么格式处理日志
            'formatter': 'simple'
        },
        #打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
        'other': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'formatter': 'test',
            'filename': 'a2.log',
            'encoding': 'utf-8',
        },
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置  空字符串作为键 能够兼容所有的日志
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
        'other': {
            'handlers': ['other',],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}


# 使用配置字典
logging.config.dictConfig(LOGGING_DIC)  # 自动加载字典中的配置
logger1 = logging.getLogger('xxx')
logger1.debug('好好的 不要浮躁 努力就有收获')

分析：

import logging  # logging是个包
import logging.config  # logging下的config模块

# 1.定义日志输出格式 开始
# 1.1标准格式
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]'  # 其中name为getlogger指定的名字

# 1.2简单格式
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'

test_format = '%(asctime)s] %(message)s'

'''
formatter对象:负责日志的格式:
以上是根据日志的格式组合而成
'''


# 2.日志文件
# 2.方法二：自定义文件路径————相对路径
import os
BASE_DIR = os.path.dirname(os.path.abspath(__file__))  # 根目录
log_path = os.path.join(BASE_DIR, 'log')

if not os.path.exists(log_path):
    os.mkdir(log_path)  # 如果log文件夹不存，就创建一个
logfile_path = os.path.join(log_path, 'a3.log')  # D:\python25\day22\log\a3.log
logfile_path1 = os.path.join(log_path, 'a4.log')  # D:\python25\day22\log\a3.log

# 2.方法一：绝对路径
# logfile_path = 'a3.log'


# 3.log配置字典
LOGGING_DIC = {
    'version': 1, #（忽略）
    'disable_existing_loggers': False,#（忽略）
    'formatters': {  # formatter对象:负责日志的格式
        'standard': { 
            'format': standard_format  # 上面1.1标准格式中定义好的格式
        },
        'simple': {  
            'format': simple_format
        },
    },
    'filters': {},  # 过滤日志
    'handlers': {  # handler对象:负责日志产生的位置
        # 打印到终端的日志
        'console': {
            'level': 'ERROR', # 可以更改日志级别（5种）****
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'  # 用1.2简单格式
        },
        # 打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',  # 更改日志级别
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',  # 1.1标准格式
            'filename': logfile_path,  # 日志文件名：文件路径（第2步） （可以更改）****
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M，（第一个文件写够5M就会再新建一个）
            'backupCount': 5,  # 最多建5个文件（5个文件都满了后，就删除第一个，以此类推）
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
        'other': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',  # 保存到文件
            'formatter': 'test',
            'filename': logfile_path1,
            'encoding': 'utf-8',
        },
    },
    'loggers': {  # logger对象（不能动）
        # logging.getLogger(__name__)拿到的logger配置  空字符串作为键 能够兼容所有的日志
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
        'other': {
            'handlers': ['other',],
            'level': 'DEBUG',
            'propagate': False,
        },
    },
}
'''loggers中可以设置一个空字符的键，调用时，传入空，可以使用这个，如果传入没有设置的键也会使用这个空的键。比如传入aaaa，但是loggers的键只有''和'other'两个键，也会使用空键中的数据。如果字典中没有空键，找不到就不会输出内容'''

使用：

# 4.使用配置字典
logging.config.dictConfig(LOGGING_DIC)  # 自动加载字典中的配置
# -----------------------------------------------------
logger1 = logging.getLogger('xxx')  # 即写到文件中，又写到终端中
logger1.debug('好好的 不要浮躁 努力就有收获')
# 终端中：
#[DEBUG][2023-03-14 16:23:55,169][01 logging.py:72]好好的 不要浮躁 努力就有收获
# a3.log文件中：
#[2023-03-13 16:23:55,169][MainThread:17820][task_id:xxx][01 logging.py:72][DEBUG][好好的 不要浮躁 努力就有收获]
# ------------------------------------------------------
logger2 = logging.getLogger('other')  # 只写到文件a4.log中
logger2.debug('好好的 不要浮躁 努力就有收获')
# a4.log文件中：
#[2023-03-14 09:23:55,327] 好好的 不要浮躁 努力就有收获
# ----------------------------------例3----------------
logger3 = logging.getLogger()  # 使用loggers中空键的数据
logger3.debug('好好的 不要浮躁 努力就有收获')

logger4 = logging.getLogger('aaaa')  # loggers中没有aaaa键也会使用空键中的数据
logger4.debug('好好的 不要浮躁 努力就有收获')

'''这样可以在不同功能中使用不同的格式记录log日志'''
logger1.info('好好的')
logger1.warning('不要浮躁')
logger1.error('努力就有收获')
logger1.critical('不要浮躁 努力就有收获')

日志终极版

import logging

# 一：日志配置
logging.basicConfig(
    # 1、日志输出位置：1、终端 2、文件
    # filename='access.log', # 不指定，默认打印到终端

    # 2、日志格式
    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',

    # 3、时间格式
    datefmt='%Y-%m-%d %H:%M:%S %p',

    # 4、日志级别
    # critical => 50
    # error => 40
    # warning => 30
    # info => 20
    # debug => 10
    level=30,
)

# 二：输出日志
logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

'''
# 注意下面的root是默认的日志名字
WARNING:root:警告warn
ERROR:root:错误error
CRITICAL:root:严重critical
'''

日志使用(在项目中)

ATM中的使用
直接放入在conf文件夹中settings.py文件：
把上面的日志整体代码放入，不要第四步，记得更改log文件保存的地址

# src.py文件中：
import logging
import logging.config
from ATM.conf import settings
from ATM.lib import common

def register():
    # username = input('username')
    # password = input('password')

    # 记录日志
    #-----------------------方法一：直接使用配置字典
    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置
    logger = logging.getLogger()
    logger.debug('这是注册功能')
    # -----------------------方法二：封装成函数放在common中
    # 导入commom模块
    common.get_logger('这是注册功能') # 可以不需要赋值给变量
    '''缺点：只能输出debug级别，这个写死了'''
    # -------------------方法三：把logging.getLogger(name)直接return出来   可以更改日志级别
    logger1 = common.get_logger1()
    logger1.debug('这是注册啊')
    
    
def login():
    # -----------------------方法二：
    logger = common.get_logger('这是登录功能')
    # -------------------方法三：把logging.getLogger(name)直接return出来
    logger1 = common.get_logger1()
    logger1.info('这是登录')


func_dict = {
    '1': register
}


def run():
    while True:
        print("""
            1. 注册功能
        """)
        cmd = input('请输入你的选择')
        if cmd in func_dict:
            func_dict[cmd]()
        else:
            print('请好好好输入')


# lib文件夹下common.py文件：
# -----------------------方法二：封装成函数放在common中
import logging
import logging.config
from ATM.conf import settings
def get_logger(msg, name=''):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置
    logger = logging.getLogger(name)
    logger.debug(msg)

# -------------------方法三：把logging.getLogger(name)直接return出来
def get_logger1(name=''):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置
    # return logging.getLogger(name)
    logger1 = logging.getLogger(name)
    return logger1