目录
一、python logging日志处理模板
1.什么是日志?
日志是一种可以追踪某些软件运行时所发生事件的方法。通过log的分析,可以方便用户了解系统或软件、应用的运行情况。简单来说,我们通过记录和分析日志可以了解一个系统或软件程序运行情况是否正常,也可以在应用程序出现故障时快速定位问题。
2.logging模块简介
logging模块是Python的一个标准库模块,由标准库模块提供日志记录API的关键好处是所有Python模块都可以使用这个日志记录功能。所以,你的应用日志可以将你自己的日志信息与来自第三方模块的信息整合起来。
logging模块的日志级别
logging模块默认定义了以下几个日志等级,它允许开发人员自定义其他日志级别,但是这是不被推荐的。
日志等级(level) | 描述 |
---|---|
DEBUG | 最详细的日志信息,典型应用场景是问题诊断 |
INFO | 信息详细程度仅次于DEBUG,通常只记录关键节点信息,用于确认一切都是按照我们预期的那样进行工作 |
WARNING | 当某些不期望的事情发生时记录的信息(如:磁盘可用空间较低),但是此时应用程序还是正常运行的 |
ERROR | 由于一个更严重的问题导致某些功能不能正常运行时记录的信息 |
CRITICAL | 当发生严重错误,导致应用程序不能继续运行时记录的信息 |
上面列表中的日志等级是从上到下一次升高的,即:DEBUG < INFO < WARNING < ERROR < CRITICAL,而日志的信息量是依次减少的。
logging模块的使用方式介绍
logging模块提供了两种记录日志的方式:
第一种方式是使用logging提供的模块级别的函数
第二种方式是使用logging日志系统的四大组件
其实,logging所提供的模块级别的日志记录函数也是对logging日志系统相关类的封装而已。
logging模块的四大组件:
组件名称 | 对应类名 | 功能描述 |
---|---|---|
日志器 | Logger | 提供了应用程序可一直使用的接口 |
处理器 | Handler | 将logger创建的日志记录发送到合适的目的输出 |
过滤器 | Filter | 提供了更细粒度的控制工具来决定输出哪条日志记录,丢弃哪条日志记录 |
格式器 | Formatter | 决定日志记录的最终输出格式 |
这件组件之间的关系描述:
日志器(logger)需要通过处理器(handler)将日志信息输出到目标位置,如:文件、sys.stdout、网络等;
不同的处理器(handler)可以将日志输出到不同的位置;
日志器(logger)可以设置多个处理器(handler)将同一条日志输出到不同的位置;
每个处理器(handler)都可以设置自己的过滤器(filter)实现日志过滤,从而只保留感兴趣的日志;
每个处理器(handler)都可以设置自己的格式器(formatter)实现同一条日志以不同的格式输出到不同的地方。
简单点说就是:日志器(logger)是入口,真正干活儿的是处理器(handler),处理器(handler)还可以通过过滤器(filter)和格式器(formatter)对要输出的日志内容做过滤和格式化等处理操作。
3.logging模块使用实例
所有常用方法及使用说明:docs.python.org/zh-cn/3/lib…
import logging
import os.path
import time
# 记录器对象。注意 永远 不要直接实例化记录器,应当通过模块级别的函数 logging.getLogger(name) 。
# 多次使用相同的名字调用 getLogger() 会一直返回相同的 Logger 对象的引用。
logger = logging.getLogger()
# setLevel(level):给记录器设置阈值为 level 。
# 日志等级小于 level 会被忽略。严重性为 level 或更高的日志消息将由该记录器的任何一个或多个处理器发出,除非将处理器的级别设置为比 level 更高的级别。
logger.setLevel(logging.INFO)
rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
log_path = os.path.dirname(os.getcwd()) + '/Logs/'
log_name = rq + '.log'
print(log_name)
# 将日志消息发送到磁盘文件,默认情况下文件大小会无限增长
fh = logging.FileHandler(log_name, mode='w')
# setLevel(level):给处理器设置阈值为 level。
# 日志级别小于 level 将被忽略。创建处理器时,日志级别被设置为 NOTSET (所有的消息都会被处理)
# debug<info<warning<error<critical
fh.setLevel(logging.DEBUG)
#Formater对象用于配置日志信息的最终顺序、结构和内容。与logging.Handler基类不同的是,应用代码可以直接实例化Formatter类。
formatter = logging.Formatter("%(asctime)s - %(filename)s[line:%(lineno)d] -%(levelname)s:%(message)s")
# setFormatter(fmt): 将此处理器的 Formatter 设置为 fmt。
fh.setFormatter(formatter)
# addHandler(hdlr):将指定的处理器hdlr添加到此记录器。
logger.addHandler(fh)
# logging.debug(msg, *args, **kwargs):
# 在根日志记录器上记录一条 DEBUG 级别的消息。 msg 是消息格式字符串,而 args 是要使用字符串格式化运算符合并到 msg 的参数。
logger.debug('this is a logger debug message')
logger.info('this is a logger info message')
logger.warning('this is a logger warning message')
logger.error('this is a logger error message')
logger.critical('this is a logger critical message')
生产log文件如下:
2021-03-24 20:22:17,490 - log.py[line:23] -INFO:this is a logger info message
2021-03-24 20:22:17,491 - log.py[line:24] -WARNING:this is a logger warning message
2021-03-24 20:22:17,491 - log.py[line:25] -ERROR:this is a logger error message
2021-03-24 20:22:17,491 - log.py[line:26] -CRITICAL:this is a logger critical message
二、python序列化和反序列化
在程序运行的过程中,所有的变量都是在内存中,比如,定义一个 dict:
d = dict(name='Bob', age=20, score=88)
复制代码
可以随时修改变量,比如把 name 改成 'Bill',但是一旦程序结束,变量所占用的内存就被操作系统全部回收。如果没有把修改后的 'Bill' 存储到磁盘上,下次重新运行程序,变量又被初始化为 'Bob'。
我们把变量从内存中变成可存储或传输的过程称之为序列化,在 Python 中叫 pickling,在其他语言中也被称之为 serialization,marshalling,flattening 等等,都是一个意思。
序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。
反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即 unpickling。
Python 提供了 pickle 模块来实现序列化。首先,我们尝试把一个对象序列化并写入文件:
In [1]: import pickle
In [2]: d = dict(name='Bob', age=20, score=88)
In [3]: pickle.dumps(d)
Out[3]: b'\x80\x04\x95$\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x03Bob\x94\x8c\x03age\x94K\x14\x8c\x05score\x94KXu.'
复制代码
pickle.dumps()
方法把任意对象序列化成一个 bytes,然后,就可以把这个 bytes 写入文件。或者用另一个方法 pickle.dump() 直接把对象序列化后写入一个 file-like Object:
In [5]: f = open('dump.txt', 'wb')
In [6]: d = dict(name='Bob', age=20, score=88)
In [7]: pickle.dump(d, f)
In [8]: f.close()
复制代码
看看写入的 dump.txt
文件,一堆乱七八糟的内容,这些都是 Python 保存的对象内部信息。
当我们要把对象从磁盘读到内存时,可以先把内容读到一个 bytes,然后用 pickle.loads()
方法反序列化出对象,也可以直接用 pickle.load()
方法从一个 file-like Object 中直接反序列化出对象。我们打开另一个 Python 命令行来反序列化刚才保存的对象:
In [23]: f = open('dump.txt', 'rb')
In [24]: d = pickle.load(f)
In [25]: f.close()
In [26]: d
Out[26]: {'name': 'Bob', 'age': 20, 'score': 88}
复制代码
变量的内容又回来了!
当然,这个变量和原来的变量是完全不相干的对象,它们只是内容相同而已。
Pickle 的问题和所有其他编程语言特有的序列化问题一样,就是它只能用于 Python,并且可能不同版本的 Python 彼此都不兼容,因此,只能用 Pickle 保存那些不重要的数据,不能成功地反序列化也没关系。
JSON
如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如 XML,但更好的方法是序列化为 JSON,因为 JSON 表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过网络传输。JSON 不仅是标准格式,并且比 XML 更快,而且可以直接在 Web 页面中读取,非常方便。
JSON 表示的对象就是标准的 JavaScript 语言的对象,JSON 和 Python 内置的数据类型对应如下:
JSON类型 | Python类型 |
---|---|
{} | dict |
[] | list |
"string" | str |
1234.56 | int 或 float |
true/false | True/False |
null | None |
Python 内置的 json 模块提供了非常完善的 Python 对象到 JSON 格式的转换。我们先看看如何把 Python对象变成一个 JSON:
In [27]: import json
In [28]: d = dict(name='Bob', age=20, score=88)
In [29]: json.dumps(d)
Out[29]: '{"name": "Bob", "age": 20, "score": 88}'
In [30]: type(json.dumps(d))
Out[30]: str
复制代码
dumps()
方法返回一个 str,内容就是标准的 JSON。类似的,dump()
方法可以直接把 JSON 写入一个 file-like Object。
要把 JSON 反序列化为 Python 对象,用 loads()
或者对应的 load()
方法,前者把 JSON 的字符串反序列化,后者从 file-like Object 中读取字符串并反序列化:
In [31]: json_str = '{"age": 20, "score": 88, "name": "Bob"}'
In [32]: json.loads(json_str)
Out[32]: {'age': 20, 'score': 88, 'name': 'Bob'}
In [33]: type(json.loads(json_str))
Out[33]: dict
复制代码
由于 JSON 标准规定 JSON 编码是 UTF-8,所以我们总是能正确地在 Python 的 str 与 JSON 的字符串之间转换。
JSON 进阶
Python 的 dict 对象可以直接序列化为 JSON 的 {},不过,很多时候,我们更喜欢用 class . 表示对象,比如定义 Student 类,然后序列化:
import json
class Student(object):
def __init__(self, name, age, score):
self.name = name
self.age = age
self.score = score
s = Student('Bob', 20, 88)
print(json.dumps(s))
复制代码
运行代码,毫不留情地得到一个 TypeError:
Traceback (most recent call last):
...
TypeError: Object of type Student is not JSON serializable
复制代码
错误的原因是 Student 对象不是一个可序列化为 JSON 的对象。
如果连 class 的实例对象都无法序列化为 JSON,这肯定不合理!
别急,我们仔细看看 dumps()
方法的参数列表,可以发现,除了第一个必须的 obj 参数外,dumps()
方法还提供了一大堆的可选参数:docs.python.org/3/library/j…
这些可选参数就是让我们来定制 JSON 序列化。前面的代码之所以无法把 Student 类实例序列化为 JSON,是因为默认情况下,dumps()
方法不知道如何将 Student 实例变为一个 JSON 的 {} 对象。
可选参数 default 就是把任意一个对象变成一个可序列为 JSON 的对象,我们只需要为 Student 专门写一个转换函数,再把函数传进去即可:
In [40]: s.name
Out[40]: 'Bob'
In [41]: s.age
Out[41]: 20
In [42]: s.score
Out[42]: 88
复制代码
def student2dict(std):
return {
'name': std.name,
'age': std.age,
'score': std.score
}
复制代码
这样,Student 实例首先被 student2dict()
函数转换成 dict,然后再被顺利序列化为 JSON:
print(json.dumps(s, default=student2dict))
复制代码
不过,下次如果遇到一个 Teacher 类的实例,照样无法序列化为 JSON。再写一个函数 也可以,但是我们可以偷个懒,把任意 class 的实例变为 dict:
print(json.dumps(s, default=lambda obj: obj.__dict__))
复制代码
因为通常 class 的实例都有一个 __dict__
属性,它就是一个 dict,用来存储实例变量。也有少数例外,比如定义了 __slots__
的 class。
同样的道理,如果我们要把 JSON 反序列化为一个 Student 对象实例,loads() 方法首先转换出一个 dict 对象,然后,我们传入的 object_hook 函数负责把 dict 转换为 Student 实例:
def dict2student(d):
return Student(d['name'], d['age'], d['score'])
复制代码
运行结果如下:
In [48]: json_str = '{"age": 20, "score": 88, "name": "Bob"}'
In [49]: def dict2student(d):
...: return Student(d['name'], d['age'], d['score'])
...:
In [50]: print(json.loads(json_str, object_hook=dict2student))
<__main__.Student object at 0x1065c6f70>
复制代码
打印出的是反序列化的 Student 实例对象。
练习
对中文进行 JSON 序列化时,json.dumps()
提供了一个 ensure_ascii
参数,观察该参数对结果的影响:
import json
obj = dict(name='小明', age=20)
s = json.dumps(obj, ensure_ascii=True)
print(s)
复制代码
三、小结
Python logging 库设计的真的非常灵活,如果有特殊的需要还可以在这个基础的 logging 库上进行改进,创建新的 Handler 类解决实际开发中的问题。
Python 语言特定的序列化模块是pickle,但如果要把序列化搞得更通用、更符合 Web 标准,就可以使用 json 模块。
B站最牛的Python自动化测试框架全栈测试开发实战项目入门到精通,涨薪必备教程!!!