[Python知识库]python中常用的内置模块

1. time模块

（1）功能汇总

在Python中，通常有这3种方式来表示时间：

1. 时间戳(timestamp)：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量.我们运行“type(time.time())”，返回的是float类型。通常用于时间间隔的计算。

---

2. 格式化的时间字符串(Format String)（按照某种格式显示的）例如‘1999-12-06’。通常用于格式化显示时间。

符号	说明
%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）
%a	本地简化星期名称
%A	本地完整星期名称
%b	本地简化的月份名称
%B	本地完整的月份名称
%c	本地相应的日期表示和时间表示
%j	年内的一天（001-366）
%p	本地A.M.或P.M.的等价符
%U	一年中的星期数（00-53）星期天为星期的开始
%w	星期（0-6），星期天为星期的开始
%W	一年中的星期数（00-53）星期一为星期的开始
%x	本地相应的日期表示
%X	本地相应的时间表示
%Z	当前时区的名称
%%	%号本身

---

3. 结构化时间(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）

索引（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	比如2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（时）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 60
6	tm_wday（weekday）	0 - 6（0表示周一）
7	tm_yday（一年中的第几天）	1 - 366
8	tm_isdst（是否是夏令时）	默认为0

（2）程序解释

• 3种类型的时间举例

import time
print('--------------时间戳-------------')
time1 = time.time() #时间戳，float类型
time2 = time.time()
diff_time = time2 - time1
print('时间间隔：{0} s'.format(diff_time))

print('--------------时间字符串-------------')
str1 = time.strftime("%Y-%m-%d %X")
print(str1)

print('--------------结构化时间(struct_time) -------------')
loc_time_1 = time.localtime()#本地时区的struct_time
loc_time_2 = time.gmtime() #UTC时区的struct_time
print(loc_time_1)
print(loc_time_2)

输出：

--------------时间戳-------------
时间间隔：4.76837158203125e-07 s
--------------时间字符串-------------
2021-11-13 22:29:37
--------------结构化时间(struct_time) -------------
time.struct_time(tm_year=2021, tm_mon=11, tm_mday=13, tm_hour=22, tm_min=29, tm_sec=37, tm_wday=5, tm_yday=317, tm_isdst=0)
time.struct_time(tm_year=2021, tm_mon=11, tm_mday=13, tm_hour=14, tm_min=29, tm_sec=37, tm_wday=5, tm_yday=317, tm_isdst=0)

• 3种类型的时间转换

import time
print('--------------时间戳《==》时间字符串-------------')
t = time.time()
st = time.localtime(t) #时间戳 ---> 结构化时间
ft = time.strftime('%Y/%m/%d %H:%M:%S',st) # 结构化时间 ---> 格式化时间
print(st)
print(ft)

print('--------------结构化时间(struct_time)《==》时间字符串 -------------')
st = time.strftime('%Y/%m/%d %H:%M:%S')
ft = time.strptime(st,'%Y/%m/%d %H:%M:%S') # 时间字符串 ---> 格式化时间
st= time.strftime('%Y/%m/%d %H:%M:%S',ft) # 格式化时间 ---> 时间字符串
print(st)
print(ft)

输出：

--------------时间戳《==》时间字符串-------------
time.struct_time(tm_year=2021, tm_mon=11, tm_mday=13, tm_hour=22, tm_min=45, tm_sec=50, tm_wday=5, tm_yday=317, tm_isdst=0)
2021/11/13 22:45:50
--------------结构化时间(struct_time)《==》时间字符串 -------------
2021/11/13 22:45:50
time.struct_time(tm_year=2021, tm_mon=11, tm_mday=13, tm_hour=22, tm_min=45, tm_sec=50, tm_wday=5, tm_yday=317, tm_isdst=-1)

import time
print('--------------时间戳》》时间字符串-------------')
#time.ctime(时间戳)  如果不传参数，直接返回当前时间的格式化串
time1 = time.time() #时间戳，float类型
str_time = time.ctime(time1)
print(str_time)

print('--------------结构化时间(struct_time)》》时间字符串 -------------')
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
loc_time = time.localtime()#本地时区的struct_time
print(time.asctime(loc_time))

输出：

--------------时间戳》》时间字符串-------------
Sat Nov 13 22:36:19 2021
--------------结构化时间(struct_time)》》时间字符串 -------------
Sat Nov 13 22:36:19 2021

2. datetime模块

（1）功能汇总

datetime模块中包含如下类：

datetime模块中包含的常量：

（2）程序解释

import datetime
now_time = datetime.datetime.now()  # 现在的时间
# 只能调整的字段：weeks days hours minutes seconds
print(datetime.datetime.now() + datetime.timedelta(weeks=3)) # 三周后
print(datetime.datetime.now() + datetime.timedelta(weeks=-3)) # 三周前
print(datetime.datetime.now() + datetime.timedelta(days=-3)) # 三天前
print(datetime.datetime.now() + datetime.timedelta(days=3)) # 三天后
print(datetime.datetime.now() + datetime.timedelta(hours=5)) # 5小时后
print(datetime.datetime.now() + datetime.timedelta(hours=-5)) # 5小时前
print(datetime.datetime.now() + datetime.timedelta(minutes=-15)) # 15分钟前
print(datetime.datetime.now() + datetime.timedelta(minutes=15)) # 15分钟后
print(datetime.datetime.now() + datetime.timedelta(seconds=-70)) # 70秒前
print(datetime.datetime.now() + datetime.timedelta(seconds=70)) # 70秒后

current_time = datetime.datetime.now()
# 可直接调整到指定的 年 月 日 时 分 秒 等

print(current_time.replace(year=1977))  # 直接调整到1977年
print(current_time.replace(month=1))  # 直接调整到1月份
print(current_time.replace(year=1989,month=4,day=25))  # 1989-04-25 18:49:05.898601

# 将时间戳转化成时间
print(datetime.date.fromtimestamp(1232132131))  # 2009-01-17

print(datetime.date.today()) #2021-11-13

3. calendar模块

（1）功能汇总

1. calendar.calendar(year,w=2,l=1,c=6,m=3)，返回一个字符串格式的年历。

• year接收一个年份数字，可以是过去现在或未来，比如我这里打印的是1千年以后的3019年。
• w表示个位天数相邻两天之间的间隔宽度(字符空格数)，默认是2.
• l表示每一个周占用的行数，默认是1。
• c表示并排的两个月之间的间隔宽度，默认是6。但是c不小于w。即当c值小于w时，c等于w。
• m表示并排展示多少个月。默认是3，显示一排3个月，会显示4排。

2. calendar.prcal(year,w=2,l=1,c=6, m=3)也是打印一年的年历，相当于print(calendar.calendar(year,w,l,c))。
3. calendar.month(2019, 10, w=0, l=0)，打印某一个月的日历。
4. calendar.timegm(tupletime)接受一个时间元组，返回时间戳，时间元组的值依次表示年、月、日、时、分、秒。
5. calendar.weekday(year,month,day)返回传入的日期是星期几。
6. calendar.isleap(year)返回传入的年是不是闰年，是返回True，否则为false。如2020年是闰年。
7. calendar.leapdays(start, end)返回start,end之间有多少个闰年，左闭右开区间。

（2）程序解释

import calendar

print("month: \n", calendar.month(2019, 10, w=0, l=0))
#print("month: \n", calendar.prmonth(2019, 10, w=0, l=0))

print("monthcalendar: ", calendar.monthcalendar(2019, 11))#2019年11月的日历
print("monthrange: ", calendar.monthrange(2019, 10))#2019年11月日历的范围

输出：

month: 
     October 2019
Mo Tu We Th Fr Sa Su
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30 31

monthcalendar:  [[0, 0, 0, 0, 1, 2, 3], [4, 5, 6, 7, 8, 9, 10], [11, 12, 13, 14, 15, 16, 17], [18, 19, 20, 21, 22, 23, 24], [25, 26, 27, 28, 29, 30, 0]]
monthrange:  (1, 31)

4. sys模块

Python的sys模块提供访问由解释器使用或维护的变量的接口，并提供了一些函数用来和解释器进行交互，操控Python的运行时环境。

（1）功能汇总

（2）程序解释

• sys.argv

传递给程序的命令行参数列表，其中argv[0]是传入的脚本名字，其它为传入的参数名字，且为str类型。

import sys
# filename：sys_test.py
for i in range(len(sys.argv)):
      print('argv{0}: type is {1}, value is {2}'.format(i, type(sys.argv[i]), sys.argv[i]))

然后执行代码python argv_test.py 1 a 2 b。运行结果如下：

argv0: type is <class 'str'>, value is sys_test.py
argv1: type is <class 'str'>, value is 1
argv2: type is <class 'str'>, value is a
argv3: type is <class 'str'>, value is 2
argv4: type is <class 'str'>, value is b

• sys.path

表示模块的搜索路径，其中sys.path[0]表示脚本当前目录。

import sys
print(sys.path[0])

输出：

/home/xxx/workspace/python/python_tutorials

• sys.getsizeof()

获取对象占用的内存大小（用字节表示）

import sys

for obj in [int(), float(), list(), tuple(), set(), dict(), object]:
    print(str(obj.__class__).ljust(20), sys.getsizeof(obj))

输出：

<class 'int'>        24
<class 'float'>      24
<class 'list'>       56
<class 'tuple'>      40
<class 'set'>        216
<class 'dict'>       232
<class 'type'>       408

5. os模块

os模块是与操作系统交互的一个接口。

（1）功能汇总

（2）程序解释

• 进入空间操作

import os
print(os.getcwd()) #当前工作目录
os.chdir('..') #返回上一层目录
print(os.curdir) #当前目录
print(os.getcwd())#当前工作目录
print(os.pardir)#当前目录的上一层

输出：

/home/liqiang/workspace/python/python_tutorials
.
/home/liqiang/workspace/python
..

6. pathlib模块

pathlib 库从 python3.4 开始，到 python3.6 已经比较成熟。如果你的新项目可以直接用 3.6 以上，建议用 pathlib。相比于老式的 os.path 有几个优势：

• 老的路径操作函数管理比较混乱，有的是导入 os, 有的又是在 os.path 当中，而新的用法统一可以用 pathlib 管理。
• 老用法在处理不同操作系统 win，mac 以及 linux 之间很吃力。换了操作系统常常要改代码，还经常需要进行一些额外操作。
• 老用法主要是函数形式，返回的数据类型通常是字符串。但是路径和字符串并不等价，所以在使用 os 操作路径的时候常常还要引入其他类库协助操作。新用法是面向对象，处理起来更灵活方便。
• pathlib 简化了很多操作，用起来更轻松。

有两大类一个是纯路径不带I/0操作，另一个可以进行I/0的类。pathlib各个类的继承关系如下图：

（1）功能汇总

Path获得的路径为对象类型，可以使用str方法转化为字符串。同样可以使用Path()方法将字符串转化path对象。

下面假设：

• file = Path(‘archive/demo.txt’)

常用的 pathlib 和 os 对比图：

（2）程序解释

from pathlib import Path

#获取当前路径
v = Path.cwd()

# 创建 project/test目录
Path('project/test').mkdir(parents=True, exist_ok=True)

# 将test.txt 重命名为 project/tests.txt
Path('test.txt').rename('project/test.txt')

# 拼接目录
paths = ["test","test.txt"]
Path.cwd().parent.joinpath(*paths)

# 获取上上层目录
print(Path.cwd().parent.parent) 

#迭代器访问的所有文件、文件夹路径的迭代器
p = Path.cwd()
for i in p.iterdir():
  print(i) #i为Path类型，linux下为pathlib.PosixPath类型

#*******************其它操作*************************
path = Path.cwd()

path.parents　　# 返回所有上级目录的列表

path.parts　　# 分割路径 类似os.path.split(), 不过返回元组

path.root　　# 返回路径的根目录

path.is_dir()　　# 判断是否是目录

path.is_dir()　　# 是否是文件

path.exists()　　# 判断路径是否存在

path.open()　　# 打开文件(支持with)

path.resolve()　　# 返回绝对路径

path.cwd()　　# 返回当前目录

path.iterdir()　　# 遍历目录的子目录或者文件

path.mkdir()　　# 创建目录

path.rename()　　# 重命名路径

path.unlink()　　# 删除文件或目录(目录非空触发异常)

path.joinpath()　　# 拼接路径

7. shutil模块

shutil模块提供了许多关于文件和文件集合的高级操作，特别提供了支持文件复制和删除的功能。

（1）功能汇总

（2）程序解释

• copyfileobj

import shutil
f1 = open("file.txt","r")#内容：11
f2 = open("file_copy.txt","a+") #内容：22，追加的方式读写
shutil.copyfileobj(f1,f2,length=1024) # f2变为：2211

• copyfile

import shutil
shutil.copyfile("file.txt","file_copy_1.txt")#会生成一个新的文件file_copy_1.txt

• copytree

将aaa中的所有内容，复制到bbb/ccc中(如果不存在，则自动创建)

import shutil,os
folder1 = os.path.join(os.getcwd(),"aaa")
folder2 = os.path.join(os.getcwd(),"bbb","ccc")# bbb与ccc文件夹都可以不存在,会自动创建
print(folder1)
print(folder2)
# 将"abc.txt","bcd.txt"忽略，不复制
shutil.copytree(folder1,folder2,ignore=shutil.ignore_patterns("abc.txt","bcd.txt"))

• rmtree

删除的文件树必须存在

import shutil,os
folder1 = os.path.join(os.getcwd(),"aaa")
shutil.rmtree(folder1)

8. random模块

random模块用于生成随机数

（1）功能汇总

（2）程序解释

import random

print( random.randint(1,10) )        # 产生 1 到 10 的一个整数型随机数  
print( random.random() )             # 产生 0 到 1 之间的随机浮点数
print( random.uniform(1.1,5.4) )     # 产生  1.1 到 5.4 之间的随机浮点数，区间可以不是整数
print( random.choice('tomorrow') )   # 从序列中随机选取一个元素
print(random.choice(['剪刀', '石头', '布']))  #随机选择元素
print( random.randrange(1,100,2) )   # 生成从1到100的间隔为2的随机整数，不包括100
print(random.sample('zyxwvutsrqponmlkjihgfedcba',5)) #随机选择5个元素，生成一个新的列表

#打乱排序
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
random.shuffle(items)
print(items) # [4, 3, 8, 2, 5, 9, 6, 1, 0, 7]

9. json模块

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式。Python3 中可以使用 json 模块来对 JSON 数据进行编解码，它主要提供了四个方法： dumps、dump、loads、load。

• dump和dumps对python对象进行序列化。将一个Python对象进行JSON格式的编码。
• load和loads反序列化方法,将json格式数据解码为python对象。

python 原始类型向 json 类型的转化对照表：

（1）功能汇总

函数以及参数说明：

1. dump和dumps介绍：

• dump函数形式：json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)
• dumps函数形式：json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

参数	说明
obj	表示是要序列化的对象。
fp	dump与dumps的唯一区别，dumps没有该参数，文件描述符，将序列化的str保存到文件中。json模块总是生成str对象，而不是字节对象；因此，fp.write（）必须支持str输入。
skipkeys	默认为False,如果skipkeysTrue,（默认值：False），则将跳过不是基本类型（str，int，float，bool，None）的dict键，不会引发TypeError。
ensure_ascii	默认值为True,能将所有传入的非ASCII字符转义输出。如果ensure_ascii为False，则这些字符将按原样输出。
check_circular	默认值为True,如果check_circular为False，则将跳过对容器类型的循环引用检查，循环引用将导致OverflowError。
allow_nan	默认值为True,如果allow_nan为False，则严格遵守JSON规范,序列化超出范围的浮点值（nan，inf，-inf）会引发ValueError。 如果allow_nan为True,则将使用它们的JavaScript等效项（NaN，Infinity，-Infinity）。
indent	设置缩进格式，默认值为None,选择的是最紧凑的表示。如果indent是非负整数或字符串，那么JSON数组元素和对象成员将使用该缩进级别进行输入；indent为0,负数或“”仅插入换行符；indent使用正整数缩进多个空格；如果indent是一个字符串（例如“\t”），则该字符串用于缩进每个级别。
separators	去除分隔符后面的空格，默认值为None,如果指定，则分隔符应为（item_separator，key_separator）元组。如果缩进为None，则默认为（’，’，’：’）;要获得最紧凑的JSON表示，可以指定（’，’，’:’）以消除空格。
default	默认值为None,如果指定，则default应该是为无法以其他方式序列化的对象调用的函数。它应返回对象的JSON可编码版本或引发TypeError。如果未指定，则引发TypeError。
sort_keys	默认值为False,如果sort_keys为True，则字典的输出将按键值排序。

---

2. load与loads介绍

• load函数形式：json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

参数	说明
fp	文件描述符，将fp（.read（）支持包含JSON文档的文本文件或二进制文件）反序列化为Python对象。
object_hook	默认值为None,object_hook是一个可选函数，此功能可用于实现自定义解码器。指定一个函数，该函数负责把反序列化后的基本类型对象转换成自定义类型的对象。
parse_float	默认值为None,如果指定了parse_float，用来对JSON float字符串进行解码,这可用于为JSON浮点数使用另一种数据类型或解析器。
parse_int	默认值为None,如果指定了parse_int，用来对JSON int字符串进行解码,这可以用于为JSON整数使用另一种数据类型或解析器。
parse_constant	默认值为None,如果指定了parse_constant,对-Infinity,Infinity,NaN字符串进行调用。如果遇到了无效的JSON符号，会引发异常。

---

• loads函数形式：json.loads(s, *, encoding=None, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

参数	说明
s	将s（包含JSON文档的str，bytes或bytearray实例）反序列化为Python对象。
encoding	指定一个编码的格式。

loads也不需要文件描述符，其他参数的含义和load函数的一致。

（2）程序解释

dump和dumps

import json

# dumps可以格式化所有的基本数据类型为字符串
data1 = json.dumps([1,2,3,4])         # 列表
print(data1, type(data1))
data2 = json.dumps(100)          # 数字
print(data2, type(data2))
data3 = json.dumps('qlee')        # 字符串
print(data3, type(data3))
dict = {"name": "Tom", "age": 23}   # 字典
data4 = json.dumps(dict)
print(data4, type(data4))

with open("test.json", "w", encoding='utf-8') as f:
    # indent,表示空格数，默认为None，小于0为零个空格
    f.write(json.dumps(dict, indent=4)) #保存到f中
    #json.dump(dict, f, indent=4)  # 保存到f中

输出：

[1, 2, 3, 4] <class 'str'>
100 <class 'str'>
"qlee" <class 'str'>
{"name": "Tom", "age": 23} <class 'str'>

最后保存的test.json内容为：

{
    "name": "Tom",
    "age": 23
}

import json

dict = '{"name": "Tom", "age": 23}'   # 将字符串还原为dict
data1 = json.loads(dict)
print(data1, type(data1))

with open("test.json", "r", encoding='utf-8') as f:
    data2 = json.loads(f.read())    # 加载方式一：load的传入参数为字符串类型
    print(data2, type(data2))
    f.seek(0)                       # 将文件游标移动到文件开头位置
    data3 = json.load(f)# 加载方式二
    print(data3, type(data3))

输出：

{'name': 'Tom', 'age': 23} <class 'dict'>
{'name': 'Tom', 'age': 23} <class 'dict'>
{'name': 'Tom', 'age': 23} <class 'dict'>

10. pickle模块

pickle模块实现了用于序列化和反序列化Python对象结构的二进制协议。pickle模块只能在Python中使用，python中几乎所有的数据类型（列表，字典，集合，类等）都可以用pickle来序列化，pickle序列化后的数据，可读性差，人一般无法识别。

pickle协议和JSON（JavaScript Object Notation）的区别 ：

1. JSON是一种文本序列化格式（它输出unicode文本，虽然大部分时间它被编码utf-8），而pickle是二进制序列化格式;
2. JSON是人类可读的，而pickle则不是;
3. JSON是可互操作的，并且在Python生态系统之外广泛使用，而pickle是特定于Python的;

（1）功能汇总

（2）程序解释

import pickle

path = 'test' #保存路径
f = open(path, 'wb')
data = {'a':123, 'b':'ads', 'c':[[1,2],[3,4]]}
pickle.dump(data, f) #保存
f.close()

f1 = open(path, 'rb')
data1 = pickle.load(f1) #解析
print(data1)

输出：

{'a': 123, 'b': 'ads', 'c': [[1, 2], [3, 4]]}

11. logging模块

logging模块是Python内置的标准模块，主要用于输出运行日志，可以设置输出日志的等级、日志保存路径、日志文件回滚等；相比print，具备如下优点：

1. 可以通过设置不同的日志等级，在release版本中只输出重要信息，而不必显示大量的调试信息；
2. print将所有信息都输出到标准输出中，严重影响开发者从标准输出中查看其它数据；logging则可以由开发者决定将信息输出到什么地方，以及怎么输出；

（1）基本使用

只有级别大于或等于日志记录器指定级别的日志记录才会被输出，小于该级别的日志记录将会被丢弃。级别排序:CRITICAL > ERROR > WARNING > INFO > DEBUG。

import logging
#logging的级别为DEBUG，所以全部输出
logging.basicConfig(level = logging.DEBUG,format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s')

logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

输出：

2021-11-14 16:42:56,718 - root - DEBUG - debug message
2021-11-14 16:42:56,718 - root - INFO - info message
2021-11-14 16:42:56,718 - root - WARNING - warning message
2021-11-14 16:42:56,718 - root - ERROR - error message
2021-11-14 16:42:56,718 - root - CRITICAL - critical message

我们将logger的级别改为ERROR，再观察一下输出结果：

2021-11-14 16:44:33,998 - root - ERROR - error message
2021-11-14 16:44:33,998 - root - CRITICAL - critical message

logging.basicConfig函数各参数说明：

参数	说明
filename	指定日志文件名；
filemode	和file函数意义相同，指定日志文件的打开模式，‘w’或者’a’；
format	指定输出的格式和内容，format可以输出很多有用的信息
datefmt	指定时间格式，同time.strftime()；
level	设置日志级别，默认为logging.WARNNING；
stream	指定将日志的输出流，可以指定输出到sys.stderr，sys.stdout或者文件，默认输出到sys.stderr，当stream和filename同时指定时，stream被忽略.

format中输出的格式个内容：

>参数	说明
%(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	打印日志信息

（2）将日志输出到文件

import logging
logger = logging.getLogger(__name__)
logger.setLevel(level = logging.DEBUG)

handler = logging.FileHandler("log.txt")#日志输出到log.txt中
handler.setLevel(logging.WARNING) #只输出hander和logger的setLeverl级别更高的一级
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logger.addHandler(handler)

logger.debug('debug message')
logger.info('info message')
logger.warning('warning message')
logger.error('error message')
logger.critical('critical message')
logger.info("Finish")

log.tx内容为：

2021-11-14 17:05:48,407 - __main__ - WARNING - warning message
2021-11-14 17:05:48,407 - __main__ - ERROR - error message
2021-11-14 17:05:48,407 - __main__ - CRITICAL - critical message

（3）使用json文件配置

使用JSON配置文件：

{
    "version":1,
    "disable_existing_loggers":false,
    "formatters":{
        "simple":{
            "format":"%(asctime)s - %(name)s - %(levelname)s - %(message)s"
        }
    },
    "handlers":{
        "console":{
            "class":"logging.StreamHandler",
            "level":"DEBUG",
            "formatter":"simple",
            "stream":"ext://sys.stdout"
        },
        "info_file_handler":{
            "class":"logging.handlers.RotatingFileHandler",
            "level":"INFO",
            "formatter":"simple",
            "filename":"info.log",
            "maxBytes":"10485760",
            "backupCount":20,
            "encoding":"utf8"
        },
        "error_file_handler":{
            "class":"logging.handlers.RotatingFileHandler",
            "level":"ERROR",
            "formatter":"simple",
            "filename":"errors.log",
            "maxBytes":10485760,
            "backupCount":20,
            "encoding":"utf8"
        }
    },
    "loggers":{
        "my_module":{
            "level":"ERROR",
            "handlers":["info_file_handler"],
            "propagate":"no"
        }
    },
    "root":{
        "level":"INFO",
        "handlers":["console","info_file_handler","error_file_handler"]
    }
}

使用程序如下：

import json
import logging.config
import os
 
def setup_logging(default_path = "logging.json",default_level = logging.INFO,env_key = "LOG_CFG"):
    path = default_path
    value = os.getenv(env_key,None)
    if value:
        path = value
    if os.path.exists(path):
        with open(path,"r") as f:
            config = json.load(f)
            logging.config.dictConfig(config)
    else:
        logging.basicConfig(level = default_level)
 
def func():
    logging.info("start func")
 
    logging.info("exec func")
 
    logging.info("end func")
 
if __name__ == "__main__":
    setup_logging(default_path = "logging.json")
    func()

（4）通过YAML文件配置

使用YAML文件进行配置：

version: 1
disable_existing_loggers: False
formatters:
        simple:
            format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
handlers:
    console:
            class: logging.StreamHandler
            level: DEBUG
            formatter: simple
            stream: ext://sys.stdout
    info_file_handler:
            class: logging.handlers.RotatingFileHandler
            level: INFO
            formatter: simple
            filename: info.log
            maxBytes: 10485760
            backupCount: 20
            encoding: utf8
    error_file_handler:
            class: logging.handlers.RotatingFileHandler
            level: ERROR
            formatter: simple
            filename: errors.log
            maxBytes: 10485760
            backupCount: 20
            encoding: utf8
loggers:
    my_module:
            level: ERROR
            handlers: [info_file_handler]
            propagate: no
root:
    level: INFO
    handlers: [console,info_file_handler,error_file_handler]

使用程序如下：

import yaml
import logging.config
import os
 
def setup_logging(default_path = "logging.yaml",default_level = logging.INFO,env_key = "LOG_CFG"):
    path = default_path
    value = os.getenv(env_key,None)
    if value:
        path = value
    if os.path.exists(path):
        with open(path,"r") as f:
            config = yaml.load(f)
            logging.config.dictConfig(config)
    else:
        logging.basicConfig(level = default_level)
 
def func():
    logging.info("start func")
 
    logging.info("exec func")
 
    logging.info("end func")
 
if __name__ == "__main__":
    setup_logging(default_path = "logging.yaml")
    func()

参考:
time：https://www.cnblogs.com/tkqasn/p/6001134.html
logging：https://blog.csdn.net/pansaky/article/details/90710751#t0
pathlib：https://www.cnblogs.com/heniu/p/12872604.html