python模块思维导图模板_ProcessOn思维导图、流程图

time模块

表示时间的三种方式

1、时间戳（timestamp）

#导入时间模块 >>>import time #时间戳 >>>time.time() 1500875844.800804

2、格式化的时间字符串(Format String)

%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

当前时区的名称

%

%号本身

#时间字符串 >>>time.strftime("%Y-%m-%d %X") '2017-07-24 13:54:37' >>>time.strftime("%Y-%m-%d %H-%M-%S") '2017-07-24 13-55-04'

3、元组（struct_time）

#时间元组:localtime将一个时间戳转换为当前时区的struct_time time.localtime() time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, 　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37, tm_wday=0, tm_yday=205, tm_isdst=0)

几种格式之间的转换

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

计算时间差

import time true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S')) time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S')) dif_time=time_now-true_time struct_time=time.gmtime(dif_time) print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,                                                                                   struct_time.tm_mday-1,struct_time.tm_hour,                                                                                   struct_time.tm_min,struct_time.tm_sec))

datetime模块

# datatime模块 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

random模块

随机小数

>>> random.random() # 大于0且小于1之间的小数 0.7664338663654585 >>> random.uniform(1,3) #大于1小于3的小数 1.6270147180533838

随机整数

>>> random.randint(1,5) # 大于等于1且小于等于5之间的整数 >>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数

随机选择一个返回

>>> random.choice([1,'23',[4,5]]) # #1或者23或者[4,5]

随机选择多个返回

>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2个组合 [[4, 5], '23']

打乱列表顺序

>>> item=[1,3,5,7,9] >>> random.shuffle(item) # 打乱次序 >>> item [5, 1, 3, 7, 9] >>> random.shuffle(item) >>> item [5, 9, 7, 1, 3]

re模块

正则匹配

正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

单个字符匹配

import re # \w 与 \W # print(re.findall('\w', '太白jx 12*() _')) # ['太', '白', 'j', 'x', '1', '2', '_'] # print(re.findall('\W', '太白jx 12*() _')) # [' ', '*', '(', ')', ' '] # \s 与\S # print(re.findall('\s','太白barry*(_ \t \n')) # [' ', '\t', ' ', '\n'] # print(re.findall('\S','太白barry*(_ \t \n')) # ['太', '白', 'b', 'a', 'r', 'r', 'y', '*', '(', '_'] # \d 与 \D # print(re.findall('\d','1234567890 alex *（_')) # ['1', '2', '3', '4', '5', '6', '7', '8', '9', '0'] # print(re.findall('\D','1234567890 alex *（_')) # [' ', 'a', 'l', 'e', 'x', ' ', '*', '（', '_'] # \A 与 ^ # print(re.findall('\Ahel','hello 太白金星 -_- 666')) # ['hel'] # print(re.findall('^hel','hello 太白金星 -_- 666')) # ['hel'] # \Z、\z 与 $ @@ # print(re.findall('666\Z','hello 太白金星 *-_-* \n666')) # ['666'] # print(re.findall('666\z','hello 太白金星 *-_-* \n666')) # [] # print(re.findall('666$','hello 太白金星 *-_-* \n666')) # ['666'] # \n 与 \t # print(re.findall('\n','hello \n 太白金星 \t*-_-*\t \n666')) # ['\n', '\n'] # print(re.findall('\t','hello \n 太白金星 \t*-_-*\t \n666')) # ['\t', '\t']

重复匹配

# . ? * + {m,n} .* .*? # . 匹配任意字符，除了换行符（re.DOTALL 这个参数可以匹配\n）。 # print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb')) # ['aab', 'a*b', 'a2b', 'a牛b'] # print(re.findall('a.b', 'ab aab a*b a2b a牛b a\nb',re.DOTALL)) # ['aab', 'a*b', 'a2b', 'a牛b'] # ？匹配0个或者1个由左边字符定义的片段。 # print(re.findall('a?b', 'ab aab abb aaaab a牛b aba**b')) # ['ab', 'ab', 'ab', 'b', 'ab', 'b', 'ab', 'b'] # * 匹配0个或者多个左边字符表达式。满足贪婪匹配 @@ # print(re.findall('a*b', 'ab aab aaab abbb')) # ['ab', 'aab', 'aaab', 'ab', 'b', 'b'] # print(re.findall('ab*', 'ab aab aaab abbbbb')) # ['ab', 'a', 'ab', 'a', 'a', 'ab', 'abbbbb'] # + 匹配1个或者多个左边字符表达式。满足贪婪匹配 @@ # print(re.findall('a+b', 'ab aab aaab abbb')) # ['ab', 'aab', 'aaab', 'ab'] # {m,n} 匹配m个至n个左边字符表达式。满足贪婪匹配 @@ # print(re.findall('a{2,4}b', 'ab aab aaab aaaaabb')) # ['aab', 'aaab'] # .* 贪婪匹配从头到尾. # print(re.findall('a.*b', 'ab aab a*()b')) # ['ab aab a*()b'] # .*? 此时的?不是对左边的字符进行0次或者1次的匹配, # 而只是针对.*这种贪婪匹配的模式进行一种限定:告知他要遵从非贪婪匹配推荐使用! # print(re.findall('a.*?b', 'ab a1b a*()b, aaaaaab')) # ['ab', 'a1b', 'a*()b'] # []: 括号中可以放任意一个字符,一个中括号代表一个字符 # - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间. # ^ 在[]中表示取反的意思. # print(re.findall('a.b', 'a1b a3b aeb a*b arb a_b')) # ['a1b', 'a3b', 'a4b', 'a*b', 'arb', 'a_b'] # print(re.findall('a[abc]b', 'aab abb acb adb afb a_b')) # ['aab', 'abb', 'acb'] # print(re.findall('a[0-9]b', 'a1b a3b aeb a*b arb a_b')) # ['a1b', 'a3b'] # print(re.findall('a[a-z]b', 'a1b a3b aeb a*b arb a_b')) # ['aeb', 'arb'] # print(re.findall('a[a-zA-Z]b', 'aAb aWb aeb a*b arb a_b')) # ['aAb', 'aWb', 'aeb', 'arb'] # print(re.findall('a[0-9][0-9]b', 'a11b a12b a34b a*b arb a_b')) # ['a11b', 'a12b', 'a34b'] # print(re.findall('a[*-+]b','a-b a*b a+b a/b a6b')) # ['a*b', 'a+b'] # - 在[]中表示范围,如果想要匹配上- 那么这个-符号不能放在中间. # print(re.findall('a[-*+]b','a-b a*b a+b a/b a6b')) # ['a-b', 'a*b', 'a+b'] # print(re.findall('a[^a-z]b', 'acb adb a3b a*b')) # ['a3b', 'a*b']

分组

# () 制定一个规则,将满足规则的结果匹配出来 # print(re.findall('(.*?)_sb', 'alex_sb wusir_sb 日天_sb')) # ['alex', ' wusir', ' 日天']

| 匹配左边或者右边

# print(re.findall('alex|太白|wusir', 'alex太白wusiraleeeex太太白odlb')) # ['alex', '太白', 'wusir', '太白'] # print(re.findall('compan(y|ies)','Too many companies have gone bankrupt, and the next one is my company')) # ['ies', 'y'] # print(re.findall('compan(?:y|ies)','Too many companies have gone bankrupt, and the next one is my company')) # ['companies', 'company'] # 分组() 中加入?: 表示将整体匹配出来而不只是()里面的内容。

常用方法

findall

全部找到返回一个列表

print(relx.findall('a', 'alexwusirbarryeval')) # ['a', 'a', 'a']

search

只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

# print(relx.search('sb|alex', 'alex sb sb barry 日天')) # <_sre.SRE_Match object; span=(0, 4), match='alex'> # print(relx.search('alex', 'alex sb sb barry 日天').group()) # alex

match

None,同search,不过在字符串开始处进行匹配,完全可以用search+^代替match

# print(relx.match('barry', 'barry alex wusir 日天')) # <_sre.SRE_Match object; span=(0, 5), match='barry'> # print(relx.match('barry', 'barry alex wusir 日天').group()) # barry

split

分割可按照任意分割符进行分割

print(relx.split('[ ：:,;；，]','alex wusir,日天，太白;女神;肖锋：吴超')) # ['alex', 'wusir', '日天', '太白', '女神', '肖锋', '吴超']

sub

替换

# print(relx.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。')) # 太白是最好的讲师，太白就是一个普通老师，请不要将太白当男神对待。 # print(relx.sub('barry', '太白', 'barry是最好的讲师，barry就是一个普通老师，请不要将barry当男神对待。',2)) # 太白是最好的讲师，太白就是一个普通老师，请不要将barry当男神对待。 # print(relx.sub('([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)([^a-zA-Z]+)([a-zA-Z]+)', r'\5\2\3\4\1', r'alex is sb')) # sb is alex

obj = re.complie('\d{2}')

# print(obj.search('abc123eeee').group()) #12 # print(obj.findall('abc123eeee')) #['12'],重用了obj

命名分组

ret = re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>") # #还可以在分组中利用?<name>的形式给分组起名字 # #获取的匹配结果可以直接用group('名字')拿到对应的值 # print(ret.group('tag_name')) #结果：h1 # print(ret.group()) #结果：<h1>hello</h1> # # ret = relx.search(r"<(\w+)>\w+</\1>","<h1>hello</h1>") # #如果不给组起名字，也可以用\序号来找到对应的组，表示要找的内容和前面的组内容一致 # #获取的匹配结果可以直接用group(序号)拿到对应的值 # print(ret.group(1)) # print(ret.group()) #结果：<h1>hello</h1>

自定义模块

什么是模块？

1、使用python编写的代码（.py文件） 2、已被编译为共享库或DLL的C或C++扩展 3、包好一组模块的包 4、使用C编写并链接到python解释器的内置模块

为什么要使用模块？

如果退出python解释器然后重新进入，那么之前定义的函数或者变量都将丢失，因此我们通常将程序写到文件中以便永久保存下来，需要时就通过python test.py方式去执行，此时test.py被称为脚本script。 随着程序的发展，功能越来越多，为了方便管理，我们通常将程序分成一个个的文件，这样做程序的结构更清晰，方便管理。这时我们不仅仅可以把这些文件当做脚本去执行，还可以把他们当做模块来导入到其他的模块中，实现了功能的重复利用

模块的分类

内置模块

第三方模块

自定义模块

调用模块的方法

import

from...import...

导入模块的三件事

1、创建一个以模块命名的名称空间 2、执行这个名称空间里面的代码 3、通过此模块名.的方式引用该模块里面的内容

为模块起别名

import tbjx as t t.read1()

序列化模块

json模块

1、不同语言都遵循的一种数据转化格式，即不同语言都是用的特殊字符串 2、json序列化只支持部分Python数据结构：dict、list、tuple、str、int、float、True、False、None

用于网络传输

dumps

序列化：将一个字典转换成一个字符串

loads

反序列化：讲一个字符串格式的字典转换成一个字典

用于文件写读

dump

接收一个文件句柄，直接将字典转换成json字符串写入文件

load

接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回

其他参数

ensure_ascii

为True时，所有非ASCII码字符显示为\uXXXX序列，在dump时将ensure_ascii设置为False，存入json文件的中文即可正常显示

separators

分隔符，实际上时（item_separator,dict_separator）的一个元组，默认为（',' ,' :'）表示dictionary内keys之间用","隔开而KEY和value之间用":"隔开

sort_keys

将数据根据keys的值进行排序

json序列化存储多个数据到同一个文件中

dic1 = {'name':'oldboy1'} dic2 = {'name':'oldboy2'} dic3 = {'name':'oldboy3'} f = open('序列化',encoding='utf-8',mode='a') str1 = json.dumps(dic1) f.write(str1+'\n') str2 = json.dumps(dic2) f.write(str2+'\n') str3 = json.dumps(dic3) f.write(str3+'\n') f.close() f = open('序列化',encoding='utf-8') for line in f: print(json.loads(line))

pickle模块

1、只能是Python语言遵循的一种数据转化格式，只能在Python语言中使用。 2、支持Python所有的数据类型包括实例化对象。

用于网络传输

dumps

import pickle dic = {'k1':'v1','k2':'v2','k3':'v3'} str_dic = pickle.dumps(dic) print(str_dic) # bytes类型 dic2 = pickle.loads(str_dic) print(dic2) #字典

loads

# 还可以序列化对象 import pickle def func(): print(666) ret = pickle.dumps(func) print(ret,type(ret)) # b'\x80\x03c__main__\nfunc\nq\x00.' <class 'bytes'> f1 = pickle.loads(ret) # f1得到 func函数的内存地址 f1() # 执行func函数

用于文件传输

dump

同json模块

load

同json模块

pickle序列化存储多个数据到一个文件中

dic1 = {'name':'oldboy1'} dic2 = {'name':'oldboy2'} dic3 = {'name':'oldboy3'} f = open('pick多数据',mode='wb') pickle.dump(dic1,f) pickle.dump(dic2,f) pickle.dump(dic3,f) f.close() f = open('pick多数据',mode='rb') while True: try: print(pickle.load(f)) except EOFError: break f.close()

shelve模块

类似于字典的操作方法去操作特殊的字符串

os模块

常用的

os.getcwd()

获取当前工作目录，即当前python脚本工作的目录路径   

os.chdir('dirname')

改变当前脚本的工作目录；相当于shell下cd  

os.curdir

返回当前目录:（'.'） 

os.pardir

获取当前目录的父目录字符串名：('..')  

os.makedirs('dirname1/dirname2')

可生成多层递归目录 

os.removedirs('dirname1')

若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，以此类推 

os.mkdir('dirname')

生成单级目录；相当于shell中mkdir dirname 

os.rmdir('dirname')

删除单极目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname 

os.listdir('dirname')

列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 

os.remove

删除一个文件 

os.rename（'oldname','newname'）

重命名文件/目录 

os.stat('path/filename')

获取文件/目录信息  

os.system('bash command')

运行shell命令，直接显示

os.popen('bash command').read()

运行shell命令，获取执行结果

os.environ

获取系统环境变量

os.path.abspath(path)

返回path规范化的绝对路径

os.path.split(path)

将path分割成目录和文件名二元组返回

os.path.dirname(path)

返回一个path的目录。其实就是os.path.split(path)的第一个元素

os.path.basename(path)

返回path最后的文件名。如何path以/或\结尾，那么就会返回空值，即os.path.split(path)的第二个元素

os.path.exists(path)

如果path存在，返回True；如果path不存在，返回False

os.path.isfile(path)

如果path是一个存在的文件，返回True。否则返回False

os.path.isabs(path)

如果path是绝对路径，返回True

os.path.isdir(path)

如果path是一个存在的目录，则返回True

os.path.join(path1[,path2[, ...]])

将多个路径组合后返回,第一个绝对路径之前的参数将被忽略

os.path.getatime(path)

返回path所指向的文件或者目录的最后访问时间

os.path.getmtime(path)

返回path所指向的文件或目录的最后修改时间

os.path.getsize(path)

返回path的大小

不常用的

os.sep

输出操作系统特定的路径分隔符，win下为'\\',Linus下为'/'

os.linesep

输出当前平台使用的行终止符，win下为'\t\n',Linus下为'\n'

os.pathsep

输出用于分割文件路径的字符串 win下为；,Linus下为：

os.name 

输出字符串指示当前适用平台 win->'nt'; Linux->'posix'

os.stat('path/filename') 获取文件/目录信息的结构说明

stat 结构：

st_mode: inode保护模式

st_ino: inode节点号

st_dev: inode驻留的设备

st_nlink: inode的链接数

st_uid: 所有者的用户ID

st_gid：所有者的组ID

st_size：普通文件以字节为单位的大小；包含等待某些特殊文件的数据

st_atime：上次访问的时间

st_mtime：最后一次修改的时间

st_ctime：有操作系统报告的'ctime'。

sys模块

sys.argv

命令行参数List，第一个元素是程序本身路径

sys.exit(n)

退出程序，正常退出时exit(),错误退出sys.exit(1)

sys.version

获取Python解释程序的版本信息

sys.path

返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.platform

返回操作系统平台名称

hashlib模块

hashlib的特征以及使用要点

1、bytes类型数据-->通过hashlib算法-->固定长度的字符串 2、不同的bytes类型数据转化成的结果一定不同 3、相同的bytes类型数据转化成的结果一定相同 4、此转化过程不可逆

密码加密

普通加密

import hashlib md5 = hashlib.md5() md5.update('123456'.encode('utf-8')) print(md5.hexdigest()) # 计算结果如下： 'e10adc3949ba59abbe56e057f20f883e' # 验证：相同的bytes数据转化的结果一定相同 import hashlib md5 = hashlib.md5() md5.update('123456'.encode('utf-8')) print(md5.hexdigest()) # 计算结果如下： 'e10adc3949ba59abbe56e057f20f883e' # 验证：不相同的bytes数据转化的结果一定不相同 import hashlib md5 = hashlib.md5() md5.update('12345'.encode('utf-8')) print(md5.hexdigest()) # 计算结果如下： '827ccb0eea8a706c4c34a16891f84e7b'

加盐加密

固定的盐

ret = hashlib.md5('xx教育'.encode('utf-8')) # xx教育就是固定的盐 ret.update('a'.encode('utf-8')) print(ret.hexdigest())

动态的盐

username = '太白金星666' ret = hashlib.md5(username[::2].encode('utf-8')) # 针对于每个账户，每个账户的盐都不一样 ret.update('a'.encode('utf-8')) print(ret.hexdigest())

文件一致性校验

def file_check(file_path): with open(file_path,mode='rb') as f1: sha256 = hashlib.sha256() while 1: content = f1.read(1024) if content: sha256.update(content) else: return sha256.hexdigest() print(file_check('pycharm-professional-2019.1.1.exe'))

collections模块

在内置数据类型（dict、list、set、tupel）的基础上，collections模块还提供了几个额外的数据类型

1、namedtuple:生成可以使用名字来访问元素内容的tuple 2、deque:双端队列，可以快速的从另外一侧追加和推出对象 3、Counter:计数器，主要用来计数 4、OrderedDict：有序字典 5、defaultdict:带有默认值的字典

namedtuple

查找坐标

>>> from collections import namedtuple >>> Point = namedtuple('Point', ['x', 'y']) >>> p = Point(1, 2) >>> p.x 1 >>> p.y 2

deque

为了高效实现插入和删除操作的双向列表，适用于队列

>>> from collections import deque >>> q = deque(['a', 'b', 'c']) >>> q.append('x') >>> q.appendleft('y') >>> q deque(['y', 'a', 'b', 'c', 'x'])

OrdderedDict

在对字典做迭代时无法确定键的值时用

>>> from collections import OrderedDict >>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d # dict的Key是无序的 {'a': 1, 'c': 3, 'b': 2} >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> od # OrderedDict的Key是有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)]

defaultdict

使用字典时,如果引用的key不存在，就会抛出KeyError，如果希望key不存在时，返回一个默认值，就可以用defaultdict

>>> from collections import defaultdict >>> dd = defaultdict(lambda: 'N/A') >>> dd['key1'] = 'abc' >>> dd['key1'] # key1存在 'abc' >>> dd['key2'] # key2不存在，返回默认值 'N/A'

Counter

Counter类的目的是用来跟踪值得出现次数。是一个无序得容器类型，以字典得键值对形式存储，其中元素作为key,其计数作为value.计数值可以是任意得lnterger(包括0和负数)。Counter类和其他语言得bags或multisets很相似。

c = Counter('abcdeabcdabcaba') print c 输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})

logging模块

函数式简单配置

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

日志级别等级

CRITICAL >  ERROR  >  WARNING  >  INFO  >  DEBUG

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

filename

用指定得文件名创建FiledHandler,这样日志会被储存在指定得文件中

filemode

文件打开方式，在指定了filename是使用这个参数，默认值为'a'还可以指定为'w'

format

指定handler使用得日志显示格式

%(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

字符串形式的当前时间。默认格式是'2020-10-17  17：42：32，869' 逗号后面是毫秒

%(thread)d

线程ID。可能没有

%(threadName)s

线程名。可能没有

%(process)d

进程ID。可能没有

%(message)s

用户输出的消息

datefmt

指定日期时间格式

level

设置rootlogger的日志级别

stream

用指定的stream创建StreamHandler.可以指定输出到sys.stderr,sys.stdout或者文件（f=open('test.log','w')）

logger配置文件

import os 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' id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s' # 定义日志输出格式结束 logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log文件的目录 logfile_name = 'all2.log' # log文件名 # 如果不存在定义的日志目录就创建一个 if not os.path.isdir(logfile_dir): os.mkdir(logfile_dir) # log文件的全路径 logfile_path = os.path.join(logfile_dir, logfile_name) # log配置字典 LOGGING_DIC = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'standard': { 'format': standard_format }, 'simple': { 'format': simple_format }, }, 'filters': {}, 'handlers': { #打印到终端的日志 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', # 打印到屏幕 '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乱码了 }, }, 'loggers': { #logging.getLogger(__name__)拿到的logger配置 '': { 'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕 'level': 'DEBUG', 'propagate': True, # 向上（更高level的logger）传递 }, }, } def load_my_logging_cfg(): logging.config.dictConfig(LOGGING_DIC) # 导入上面定义的logging配置 logger = logging.getLogger(__name__) # 生成一个log实例 logger.info('It works!') # 记录该文件的运行状态 if __name__ == '__main__': load_my_logging_cfg()