Python3学习笔记_logging_20200528

Python3学习笔记_logging_20200528

25、logging日志

接口测试基础框架搭建
1、unittest
2、Excel
3、ddt
4、logging日志管理
5、yaml配置文件

logging日志管理：
不用print显示程序执行的状况
日志的种类：
控制台信息
文件形式
日志的作用：
出现问题以后，排查问题，定位问题的依据
测试写的代码，有没有可能出问题？有
测试自己写的代码，也会出bug，也会有错误，也需要记录日志，排查问题

日志的级别：
debug-----用来调试【输出详细的运行情况，主要用于调试】
info------主体功能【确认一切按预期运行，一般用于输出重要运行情况】
warning—有可能会出现问题【一些意想不到的事情发生了（比如：‘警告’：内存空间不足），但是这个软件还能按预期工作，在不久的将来会出现问题】
error-----出错了，但是还可以继续执行（try…except…里面的是error级别的）【发生了错误，软件没能执行一些功能，还可以继续执行】
critical—无法执行，崩溃【一个严重的错误，表明程序本身可能无法继续运行】
注意：日志的级别并不需要分的特别清楚，不是有明显的界限的，只要能大概的判断一下是什么级别就OK了
logging日志默认只会记录warning 以及warning以上的bug，debug和info默认是不记录的，但是自己可以设置级别

记录日志：

    logging.debug('日志信息')
    logging.info('日志信息')
    logging.warning('日志信息')
    logging.error('日志信息')
    logging.critical('日志信息')

记录日志用在哪里？
哪里都可以用
日志用在哪里合适？如果是觉得比较重要的流程想要记录一下，就可以打印一下log

#示例1：

import logging   #logging是内置模块，不需要安装

python29=[
    ['lemon','dingding'],
    ['张三','李四'],
    ['王五','阿七'],
    ['小八','数九']
]

for group in python29:
    # print(group)
    logging.debug('group={}'.format(group))
    for name in group:
        # print(name)
        logging.debug('name={}'.format(name))

#print(python29)
logging.info(python29)
if type(python29)==dict:
    logging.warning('注意：现在我们支持dict，但是之后我们会取消dict的支持')

#版本真的迭代之后，取消对dict支持以后
if type(python29)==dict:
    logging.error('不要用dict了！！！')
    raise ValueError()

设置日志级别：
py文件----》日志收集器（自己的笔记本）------》输入处理器----》控制台
py文件----》日志收集器（自己的笔记本）------》文件处理器----》文件

日志收集器：可以自己设置级别
处理器：也可以自己设置级别
最后的日志级别：日志收集器+处理器

格式设置：
%(name)s：收集器名称
%(levelno)s：打印日志级别的数据
%(levelname)s：打印日志级别名称
%(pathname)s：打印当前执行程序的路径，其实就是sys.argv[0]
%(filename)s：打印当前执行程序名
%(funcName)s：打印日志的当前函数
%(lineno)d：打印日志的当前行号
%(asctime)s：打印日志的时间
%(thread)d：打印线程ID
%(threadName)s：打印线程名称
%(process)d：打印进程ID
%(message)s：打印日志信息
常用格式：’%(asctime)s–%(filename)s–line:%(lineno)d–%(levelname)s:%(message)s’

#示例2：控制台输出处理器

#第一步：创建一个日志收集器（笔记本：Python日志收集器）
import logging
 root_logger=logging.getLogger('Python29')    #如果getLogger传参数了，那么日志名字就是这个参数，如果没有传参数，默认是：root
root_logger=logging.getLogger()

 root_logger.info('info 等级的日志')   #现在还不能收集到日志，因为默认级别还是warning以及warning以上

#设置收集器的收集等级
root_logger.setLevel('DEBUG')     #注意：这里面的字符串，统一要大写

#handler输出处理器，流信息（控制台输出的）
stream_handler=logging.StreamHandler()
stream_handler.setLevel('DEBUG')

#把输入处理器添加到收集器上面
root_logger.addHandler(stream_handler)

root_logger.debug('debug 等级的日志')
root_logger.info('info 等级的日志')
#debug及debug以上级别的日志都可以打印出来

#示例3:

#设置收集器的收集等级
root_logger.setLevel('DEBUG')     #注意：这里面的字符串，统一要大写

#handler输出处理器，流信息（控制台输出的）
stream_handler=logging.StreamHandler()
stream_handler.setLevel('INFO')

#把输入处理器添加到收集器上面
root_logger.addHandler(stream_handler)

root_logger.debug('debug 等级的日志')
root_logger.info('info 等级的日志')
#只能打印info及info以上级别的日志

#示例4：

#设置收集器的收集等级
root_logger.setLevel('INFO')     #注意：这里面的字符串，统一要大写

#handler输出处理器，流信息（控制台输出的）
stream_handler=logging.StreamHandler()
stream_handler.setLevel('DEBUG')

#把输入处理器添加到收集器上面
root_logger.addHandler(stream_handler)

root_logger.debug('debug 等级的日志')
root_logger.info('info 等级的日志')
#只能打印info及info以上级别的日志

总结：两者取其级别大的

#示例5：文件输出处理器

#文件输出处理器
file_handler=logging.FileHandler('log.txt',encoding='utf-8')
file_handler.setLevel('INFO')
#把输出处理器添加到收集器上面
root_logger.addHandler(file_handler)

总结：文件和控制台输出处理器可以同时使用,这样可以满足控制台和日志文件中输出不同级别的日志



日志输出的格式：
#设置日志格式
fmt=logging.Formatter('%(asctime)s--%(filename)s--line:%(lineno)d--%(levelname)s:%(message)s')
file_handler.setFormatter(fmt)
stream_handler.setFormatter(fmt)


封装日志：
    函数封装：
    def get_logger():
    """参数，等级，fmt，文件：filename"""
        logger=logging.getLogger()
        return logger
    logger=get_logger()
    logger.debug()


    类封装：
    class MyLogger(logging.Logger):
        def __init__(self):
            #收集器
            logger-''

            handler=logging.FlieHandler()

            logger.addHandler
            pass

26、日志封装：
用函数封装就可以了，类封装是扩展

import logging

 def get_logger(
     name=None,
     file=None,
     file_level='INFO',
     logger_level='DEBUG',
     stream_level='DEBUG',
     fmt='%(asctime)s--%(filename)s--line:%(lineno)d--%(levelname)s:%(message)s',

     ):

     logger=logging.getLogger(name)
     logger.setLevel(logger_level)

     #控制台输出处理器
     stream_handler=logging.StreamHandler()
     stream_handler.setLevel(stream_level)
     logger.addHandler(stream_handler)
#
     #格式设置
     fmt=logging.Formatter(fmt)
     stream_handler.setFormatter(fmt)

     #文件输出处理器
     if file:
         file_handler=logging.FileHandler(file)
         file_handler.setLevel(file_level)
         file_handler.setFormatter(fmt)

         logger.addHandler(file_handler)

     return logger

 logger=get_logger(file='log1.txt')
 logger.debug('debug等级日志')
 logger.info('info等级日志')
 logger.warning('warning等级日志')
 logger.error('error等级日志')

#类的封装方法1：不继承类

import logging

 class LoggerHandler():

     def __init__(self,
                 name=None,
                 file=None,
                 file_level='INFO',
                 logger_level='DEBUG',
                 stream_level='DEBUG',
                 fmt='%(asctime)s--%(filename)s--line:%(lineno)d--%(levelname)s:%(message)s',

                  ):
         logger = logging.getLogger(name)
         logger.setLevel(logger_level)

         #控制台输出处理器
         stream_handler=logging.StreamHandler()
         stream_handler.setLevel(stream_level)
         logger.addHandler(stream_handler)

         #格式设置
         fmt=logging.Formatter(fmt)
         stream_handler.setFormatter(fmt)

         #文件输出处理器
         if file:
             file_handler=logging.FileHandler(file)
             file_handler.setLevel(file_level)
             file_handler.setFormatter(fmt)

             logger.addHandler(file_handler)

         self.logger=logger

 logger=LoggerHandler(file='log2.txt')
 logger.logger.debug('debug等级日志')
 logger.logger.info('info等级日志')
 logger.logger.warning('warning等级日志')
 logger.logger.error('error等级日志')

#类的封装方法2：继承类

class LoggerHandler2(logging.Logger):

     def __init__(self,
                 name=None,
                 file=None,
                 file_level='INFO',
                 logger_level='DEBUG',
                 stream_level='DEBUG',
                 fmt='%(asctime)s--%(filename)s--line:%(lineno)d--%(levelname)s:%(message)s',

                  ):
         super().__init__(name,logger_level)    #因为类的继承，这里就相当于声明了一个logger对象，所以下面的注释的声明logger就不需要了
                                                 #同时，self就可以使用了，self==logger，所以所有的logger就可以换成self了，最后也不需要去设置self.logger属性了
         # logger = logging.getLogger(name)
         self.setLevel(logger_level)

         #控制台输出处理器
         stream_handler=logging.StreamHandler()
         stream_handler.setLevel(stream_level)
         self.addHandler(stream_handler)

         #格式设置
         fmt=logging.Formatter(fmt)
         stream_handler.setFormatter(fmt)

         #文件输出处理器
         if file:
             file_handler=logging.FileHandler(file)
             file_handler.setLevel(file_level)
             file_handler.setFormatter(fmt)

             self.addHandler(file_handler)

 logger=LoggerHandler2(file='log3.txt')
 logger.debug('debug等级日志')
 logger.info('info等级日志')
 logger.warning('warning等级日志')
 logger.error('error等级日志')