一、时间模块（time、datetime）
Python中有三种时间的表示方式：
- 时间戳 1970年1月1日之后的秒，即：time.time()
- 格式化时间 2014-11-11 11:11， 即：time.strftime('%Y-%m-%d')
- 结构化时间 元组包含了：年、日、星期等... time.struct_time 即：time.localtime()
1.1、几种时间表示方
1 #时间戳转结构化时间 2 import time 3 y=time.time() #时间戳 4 x=time.localtime(y) #时间戳转换结构化时间 5 #结构化时间转成时间戳 6 z=time.mktime(x) #结构化时间z转时间戳 7 time.gmtime() #世界标准时间（结构化时间） 8 9 10 #结构化时间转换为格式化时间 11 time.strftime(%Y-%m-%d-%b %H:%M:%S',x)) #可带参数指定结构化时间 12 time.strftime('%Y/%m/%d %H:%M:%S') #没有参数默认就是localtime 13 #格式化时间转换成结构化时间 14 time.strptime('2011-05-05 16:37:06', '%Y-%m-%d %X')) 15 #strptime(string, format) 16 17 # %Y %m %d %H %M %S %X %a %b 18 # 年 月 日 时 分 秒 时分秒统称 周 月 19 20 21 time.asctime() 22 #把一个表示时间的元组或者struct_time表示为这种形式：'Sun Jun 20 15:21:05 1998',如果没有参数，将会将time.localtime()作为参数传入 23 time.ctime() 24 #把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数
1.2、datetime模块
1 import datetime 2 3 print(datetime.datetime.now()) #返回格式 2018-12-16 17:12:41.621179 4 print(datetime.date.fromtimestamp(time.time()) )# 时间戳直接转成日期格式 2018-12-16 5 print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天 6 print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天 7 print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时 8 print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分 9 print(datetime.datetime.now() + datetime.timedelta(seconds=30)) #当前时间+30秒 10 11 12 n_time = datetime.datetime.now() 13 print(n_time.replace(minute=3,hour=2)) #时间替换
执行结果：
二、random 随机模块
1 import random #随机模块 2 random.random() #0-1 浮点型 3 random.uniform(1,3) # 随机取1-3的浮点数 4 random.randint(1,4) #随机取1-4的整型 5 random.randrange(1,4) #随机取1-3的整数 6 random.choice([1,23,[22]]) #列表随机取一个值 7 print(random.sample([1,2,3],3)) #列表随机取多个值 8 9 list=[1,3,5,7,9] 10 random.shuffle(list) #随机打乱列表顺序 11 print(list) 12 chr(random.randint(65,90)) #随机大写字母A-Z 13 chr(random.randint(97,122)) #随机小写字母a-z
随机取4个值要求包含0-9,a-z，A-Z
1 import random 2 def code(): 3 li = [] 4 for i in range(1,5): 5 a=random.randint(0,9) 6 b=chr(random.randint(65,90)) 7 c=chr(random.randint(97,122)) 8 c=random.sample([a,b,c],1) 9 li.append(c) 10 return li 11 print(code())
其实上面这个例子并不严谨，0-9，a-z，A-Z各取一个，然后在从三个里面再任意取一个，把获取的四个值任意排序即可
三、OS模块
1 #当前工作目录相关的 2 os.getcwd() #获取当前工作目录，即当前python脚本工作的目录路径 3 os.chdir("dirname") #改变当前脚本工作目录；相当于shell下cd 4 os.curdir #返回当前目录: ('.') 5 os.pardir #获取当前目录的父目录字符串名：('..') 6 7 #和文件相关 8 os.makedirs('name1/name2') #可生成多层递归目录 9 os.removedirs('dirname') #删除多层目录，为空删除，否则报错 10 os.mkdir('dirname') #生成单级目录；相当于shell中mkdir dirname 11 os.rmdir('dirname') #删除单级空目录，若目录不为空则无法删除 12 os.listdir('dirname') #列出指定目录下的所有文件和子目录，包括隐藏文件 13 os.remove('filename') #删除一个文件 14 os.rename("oldname","newname") #重命名文件/目录 15 os.stat('path/filename') #获取文件/目录信息 16 17 # 和执行系统命令相关 18 os.system("bash command") #运行系统命令，直接显示 19 os.popen("bash command").read() #运行系统命令，获取执行结果 20 os.environ #获取系统环境变量 21 os.name() #字符串指示当前使用平台。win->'nt'; Linux->'posix' 22 23 #path系列，和路径相关 24 os.path.abspath(path) #返回path规范化的绝对路径 25 os.path.split(path)#将path分割成目录和文件名二元组返回 26 os.path.dirname(path) #返回path的目录。其实就是os.path.split(path)的第一个元素 27 os.path.basename(path) #返回path最后的文件名。如何path以／或\结尾，那么就会返回空值，即os.path.split(path)的第二个元素。 28 os.path.exists(path) #如果path存在，返回True；如果path不存在，返回False 29 os.path.isabs(path) #如果path是绝对路径，返回True 30 os.path.isfile(path) #如果path是一个存在的文件，返回True。否则返回False 31 os.path.isdir(path) #如果path是一个存在的目录，则返回True。否则返回False 32 os.path.join(path,*paths) #将多个路径组合后返回 33 os.path.getatime(path) #返回path所指向的文件或者目录的最后访问时间 34 os.path.getmtime(path) #返回path所指向的文件或者目录的最后修改时间 35 os.path.getsize(path) #返回path的大小
os.stat('path/filename') 获取文件/目录信息 的详细说明
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"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间
OS模块中os.path.join()\basename()\split() 比较重要（对文件路径拼接、文件名操作等）
四、sys模块
1 sys.argv # 命令行参数，第一个元素是程序本身路径，后面为输入参数（list） 2 sys.exit() #退出程序，正常退出时exit(0) 3 sys.version #获取Python解释程序的版本信息 4 sys.maxint #最大的Int值 5 sys.path #返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 6 sys.platform # 返回操作系统平台名称 7 sys.stdin #输入相关 8 sys.stdout #输出相关 9 sys.stderror #错误相关 10 sys.stdout.write("#") #输出"#" 11 sys.stdout.flush() #刷新缓存
五、数据转换相关（序列化）
5.1、josn 用于【字符串】和 【python基本数据类型】 间进行转换
josn模块提供了四个功能：dumps、dump、loads、load
1 #dumps和loads 2 import json 3 dic = {'k1':'v1','k2':'v2','k3':'v3'} 4 str_dic = json.dumps(dic) #序列化：将一个字典转换成一个字符串 5 print(type(str_dic),str_dic) #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"} 6 #注意，json转换完的字符串类型的字典中的字符串是由""表示的 7 8 dic2 = json.loads(str_dic) #反序列化：将一个字符串格式的字典转换成一个字典 9 #注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示 10 print(type(dic2),dic2) #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} 11 12 13 list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}] 14 str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 15 print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}] 16 list_dic2 = json.loads(str_dic) 17 print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
1 #dump和load 2 import json 3 f = open('json_file','w') 4 dic = {'k1':'v1','k2':'v2','k3':'v3'} 5 json.dump(dic,f) #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件 6 f.close() 7 8 f = open('json_file') 9 dic2 = json.load(f) #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回 10 f.close() 11 print(type(dic2),dic2)
5.2、pickle 用于【python特有的类型】 和 【python基本数据类型】间进行转换
pickle模块提供了四个功能：dumps、loads、dump、load （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）
1 import pickle 2 dic = {'k1':'v1','k2':'v2','k3':'v3'} 3 str_dic = pickle.dumps(dic) 4 print(str_dic) #一串二进制内容 5 6 dic2 = pickle.loads(str_dic) 7 print(dic2) #字典 8 9 abc = {"k":1,"k1":2} 10 f = open('pickle_file','wb') 11 pickle.dump(abc,f) 12 f.close() 13 14 f = open('pickle_file','rb') 15 struct_time2 = pickle.load(f) 16 print(abc["k"])
5.3、shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似
1 import shelve 2 f1 = shelve.open('shelve_file') 3 f1['k1']={'name':'jump','age':18,'job':['php','smoking']} #写 4 print(f1['k1']['job']) #取 ['php', 'smoking'] 5 f1.close()
5.4、XML是实现不同语言或程序之间进行数据交换的协议，XML文件格式如下：
1 <data> 2 <city name="bj"> 3 <rank updated="yes">1</rank> 4 <year>2018</year> 5 <gdppc>141100</gdppc> 6 </city> 7 <city name="nj"> 8 <rank updated="yes">5</rank> 9 <year>2018</year> 10 <gdppc>59900</gdppc> 11 </city> 12 <city name="sh"> 13 <rank updated="yes">2</rank> 14 <year>2018</year> 15 <gdppc>13600</gdppc> 16 </city> 17 </data>
XML操作：
1 import xml.etree.ElementTree as ET 2 tree= ET.parse(filename) #解析文件 3 root=tree.getroot() #获取根节点 4 root.tag #根标签名称 5 6 for child in root: 7 print(child.tag, child.attrib) # 子节点的标签名称和标签属性 8 9 for i in child: #遍历XML文档的第三层 10 print(i.tag,i.text) # 二级节点的标签名称和内容 11 12 for i in root.iter("xxx"): #遍历根节点下面的所有xxx节点,然后修改 13 xx=int（i.text）+1 14 i.text=str(xx) 15 i.set("k",'v') #设置属性 16 del node.attrib['k'] #删除 17 tree.write("filename") #保存文件 18 19 for i in root.findall("city"): 20 xx = int（city.find("rank").text） 21 if xx>3: 22 root.remove(city) #删除排名大于3的
XML文件创建
1 import xml.etree.ElementTree as ET 2 new_xml=ET.Element("xxx") #创建根节点 3 name=ET.SubElement(new_xml,"name",attrib={"k":"v"}) #创建子节点 4 age=ET.SubElement(name,"age",attrib={"k1":"v1"}) #创建二级子节点 5 age.text = "22" #给节点定义值 6 et=ET.ElementTree(new_xml) #生成文档对象 7 et.write("abc.xml",encoding="utf8") #创建xml文件
六、文件及加密相关
6.1、configparser
configparser用于处理特定格式的文件，该模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节（section），每个节可以有多个参数（键=值）
配置文件形式（mysql）
1 [client] 2 port = 3306 3 [mysqld] 4 port = 3306 5 datadir=D:\websoft\mysql-5.6.15\data 6 basedir=D:\websoft\mysql-5.6.15 7 max_connections=500 8 performance_schema=0 9 key_buffer = 16M 10 max_allowed_packet = 1M 11 #table_cache = 64 12 sort_buffer_size = 512K 13 net_buffer_length = 8K 14 read_buffer_size = 256K 15 read_rnd_buffer_size = 512K 16 myisam_sort_buffer_size = 8M 17 slow_query_log_file=D:\websoft\mysql-5.6.15\log\slow.log
创建一个配置文件：
1 import configparser 2 config= configparser.ConfigParser() #新建对象 3 config["Name"] ={'server':'hostname','IP':'111'} #Name节点下sever和IP 4 with open("config.conf","w")as f: #创建配置文件 5 config.write(f)
增删改查操作：
1 import configparser 2 config= configparser.ConfigParser() 3 config.read("config.conf") #打开配置文件 4 print(config.sections()) #获取所有的节点名称 5 6 print(config["Name"]["server"]) #获取Name节点下server的值 7 print(config.options("Name2")) #获取Name2节点下的键 8 print(config.items("Name")) #获取Name节点下所有的键值对 9 print(config.get("Name","server")) #获取Name 节点下server 的值 10 11 has_sec = config.has_section('section1') 12 print(has_sec) #判断是否包含section1这个节点，返回False/True 13 14 config.add_section("section1") 15 config.write(open('config.conf', 'w')) #增加一个节点section1 16 config.remove_section("section1") 17 config.write(open('config.conf', 'w')) #删除一个节点section1 18 19 config.set('section1', 'k10', "123") 20 config.write(open('config.conf', 'w')) #将section1节点下的k10设置为123 21 config.remove_option('section1', 'k10') 22 config.write(open('config.conf', 'w')) #将section1节点下的k10删除 23 24 config.has_option('section1', 'k10') #检查section节点下k10是否存在，返回False/True
6.2、shutil 高级的 文件、文件夹、压缩包 处理模块
1 import shutil 2 3 # shutil.copyfileobj(fsrc, fdst[, length]) 将文件内容拷贝到另一个文件中 4 shutil.copyfileobj(open('oldfilename','r'), open('newfilename', 'w')) 5 6 #shutil.copyfile(src, dst) 拷贝文件，目标文件无需存在 7 shutil.copyfile('f1', 'f2') 8 9 #shutil.copymode(src, dst)仅拷贝权限。内容、组、用户均不变 10 shutil.copymode('f1', 'f2') #目标文件必须存在 11 12 #shutil.copystat(src, dst)仅拷贝文件状态的信息 13 shutil.copystat('f1', 'f2') #目标文件必须存在 14 15 #shutil.copy2(src, dst) 拷贝文件和状态信息 16 shutil.copy2('f1', 'f2') 17 18 #shutil.copy(src, dst) 拷贝文件和权限 19 shutil.copy('f1', 'f2') 20 21 #shutil.ignore_patterns(*patterns) 22 #shutil.copytree(src, dst, symlinks=False, ignore=None) 23 #递归的去拷贝文件夹 24 shutil.copytree('dir1', 'dir2', ignore=shutil.ignore_patterns('*.txt')) 25 #目标目录不能存在，注意对dir2目录父级目录要有可写权限，ignore的意思是排除 26 27 #shutil.rmtree(path[, ignore_errors[, onerror]]) 28 #递归的去删除文件夹 29 shutil.rmtree('dir1') 30 31 #shutil.move(src, dst) 32 #递归的去移动文件，它类似mv命令，其实就是重命名。 33 shutil.move('dir1', 'dir3') 34 35 #shutil.make_archive(base_name, format,...) 压缩文件 36 #base_name： 压缩包的文件名，也可以是压缩包的路径 37 #format：压缩包种类，“zip”, “tar”, “bztar”，“gztar” 38 #root_dir：要压缩的文件夹路径（默认当前目录） 39 shutil.make_archive("/bak/data_bak", 'zip', root_dir='/data') 40 41 #shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，如下： 42 import zipfile 43 # 压缩 44 z = zipfile.ZipFile('bak.zip', 'w') 45 z.write('1.txt') 46 z.write('2.txt') 47 z.close() 48 # 解压 49 z = zipfile.ZipFile('bak.zip', 'r') 50 z.extractall(path='.') 51 z.close() 52 53 import tarfile 54 tar = tarfile.open('your.tar','w') # 创建一个压缩包 55 tar.add('/Users/bbs2.log', arcname='bbs2.log') # 将文件添加到压缩包并命名 56 tar.add('/Users/cmdb.log', arcname='cmdb.log') 57 tar.close() # 关闭压缩包 58 # 解压 59 tar = tarfile.open('your.tar','r') # 打开一个压缩包 60 tar.extractall() # 解压包内所有文件（可设置解压地址） 61 tar.close() # 关闭压缩包
6.3、hashlib
用于加密相关的操作，代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
1 import hashlib 2 obj=hashlib.md5() #建立一个对象 3 obj.update("hello".encode("utf-8")) #加密 4 print(obj.hexdigest()) #5d41402abc4b2a76b9719d911017c592 (十六进制) 5 print(obj.digest)
以上加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。所以，有必要对加密算法中添加自定义key再来做加密
1 import hashlib 2 obj=hashlib.md5("jump".encode("utf8")) #加自定义key 3 obj.update("hello".encode("utf-8")) 4 print(obj.hexdigest()) #b455addaf0e23904477ba8db951f3edc
七、 re 正则
正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行
元字符 |
匹配内容 |
| \w | 匹配字母（包含中文）或数字或下划线 |
| \W | 匹配非字母（包含中文）或数字或下划线 |
| \s | 匹配任意的空白符 |
| \S | 匹配任意非空白符 |
| \d | 匹配数字 |
| \D | 匹配非数字 |
| \A | 从字符串开头匹配 |
| \z | 匹配字符串的结束，如果是换行，只匹配到换行前的结果 |
| \Z | 匹配字符串的结束 |
| \n | 匹配一个换行符 |
| \t | 匹配一个制表符 |
| ^ | 匹配字符串的开始 |
| $ | 匹配字符串的结尾 |
| . | 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 |
| [...] | 匹配字符组中的字符 |
| [^...] | 匹配除了字符组中的字符的所有字符 |
| * | 匹配0个或者多个左边的字符。 |
| + | 匹配一个或者多个左边的字符。 |
| ？ | 匹配0个或者1个左边的字符，非贪婪方式。 |
| {n} | 精准匹配n个前面的表达式。 |
| {n,m} | 匹配n到m次由前面的正则表达式定义的片段，贪婪方式 |
| a|b | 匹配a或者b。 |
| () | 匹配括号内的表达式，也表示一个组 |
7.1、常用方法举例
1 import re 2 #findall 全部找到返回一个列表 3 #findall(pattern, string, flags=0) 4 print(re.findall("a","abcdabcdaa")) #['a', 'a', 'a', 'a'] 5 6 #search 只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。 7 # search(pattern, string, flags=0) 8 print(re.search("a","abcdabcdaa").group()) #a 9 print(re.search("a","abcdabcdaa")) #<_sre.SRE_Match object; span=(0, 1), match='a'> 10 11 #match 同search,不过在字符串开始处进行匹配,完全可以用search+^代替match 12 #match(pattern, string, flags=0) 13 # pattern： 正则模型 14 # string ： 要匹配的字符串 15 # falgs ： 匹配模式 16 print(re.match('e','ebcdh').group()) #e 17 print(re.match('e','ebcdh')) #<_sre.SRE_Match object; span=(0, 1), match='e'> 18 19 #split 分割 可按照任意分割符进行分割 20 #split(pattern, string, maxsplit=0, flags=0) 21 # pattern： 正则模型 22 # string ： 要匹配的字符串 23 # maxsplit：指定分割个数 24 # flags ： 匹配模式 25 print(re.split('[ab]','abcd')) #['', '', 'cd']，先按'a'分割得到''和'bcd',再对''和'bcd'分别按'b'分割 26 27 #sub 替换 28 #sub(pattern, repl, string, count=0, flags=0) 29 # pattern： 正则模型 30 # repl ： 要替换的字符串或可执行对象 31 # string ： 要匹配的字符串 32 # count ： 指定匹配个数 33 # flags ： 匹配模式 34 r = re.sub("\d+", "999", "123abcd456edcf789", 2) 35 print(r) #999abcd999edcf789 36 37 #re.compile() 38 obj = re.compile("\d+") 39 print(obj.search("abcd123efg456yhn789").group()) 40 print(obj.findall("abcd123efg456yhn789")) 41 42 #返回123 和['123', '456', '789']
7.2、命名分组
1 print(re.search("(?P<tag_name>\w+)","abcd")) 2 #(?P<name>) 分组固定格式 3 4 print((re.search("(?P<tag_name>\w+)","abcd").group("tag_name"))) 5 #取分组值 6 7 8 print(re.search("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>").group()) 9 print(re.findall("<(?P<tag_name>\w+)>\w+</(?P=tag_name)>","<h1>hello</h1>")) 10 #返回的结果为：<h1>hello</h1>和[h1] 11 #group的作用是将所有组拼接到一起显示出来 12 #findall结果是组内的结果,且是最后一个组的结果
八、logging 用于便捷记录日志且线程安全的模块（日志模块）
日志等级：
1 CRITICAL = 50 #FATAL = CRITICAL 2 ERROR = 40 3 WARNING = 30 #WARN = WARNING 4 INFO = 20 5 DEBUG = 10 6 NOTSET = 0 #不设置
1 import logging 2 3 logging.debug('调试debug') 4 logging.info('消息info') 5 logging.warning('警告warn') 6 logging.error('错误error') 7 logging.critical('严重critical') 8 9 #返回结果： 10 """WARNING:root:警告warn 11 ERROR:root:错误error 12 CRITICAL:root:严重critical""" 13 14 #默认级别为warning，默认打印到终端
8.1、单文件日志
1 import logging 2 logging.basicConfig(level=logging.DEBUG, 3 format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s', 4 datefmt='%a, %d %b %Y %H:%M:%S', 5 filename='1.log', 6 filemode='w') 7 8 logging.debug('debug message') 9 logging.info('info message') 10 logging.warning('warning message') 11 logging.error('error message') 12 logging.critical('critical message')
执行结果：
相关参数详情：
1 logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有： 2 3 filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。 4 filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。 5 format：指定handler使用的日志显示格式。 6 datefmt：指定日期时间格式。 7 level：设置rootlogger（后边会讲解具体概念）的日志级别 8 stream：用指定的stream创建StreamHandler。 9 可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。 10 logging.StreamHandler() #打印到桌面 11 12 format参数中可能用到的格式化串： 13 %(name)s Logger的名字 14 %(levelno)s 数字形式的日志级别 15 %(levelname)s 文本形式的日志级别 16 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有 17 %(filename)s 调用日志输出函数的模块的文件名 18 %(module)s 调用日志输出函数的模块名 19 %(funcName)s 调用日志输出函数的函数名 20 %(lineno)d 调用日志输出函数的语句所在的代码行 21 %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示 22 %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数 23 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒 24 %(thread)d 线程ID。可能没有 25 %(threadName)s 线程名。可能没有 26 %(process)d 进程ID。可能没有 27 %(message)s用户输出的消息
8.2、多文件日志
1 import logging 2 #定义正确输出日志 3 run_log = logging.FileHandler('run.log', 'a', encoding='utf-8') 4 fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s : %(message)s") 5 run_log.setFormatter(fmt) 6 logger_info = logging.Logger('run_log', level=logging.INFO) 7 logger_info.addHandler(run_log) 8 9 #定义错误输出日志 10 error_log = logging.FileHandler('error.log', 'a', encoding='utf-8') 11 fmt = fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s : %(message)s") 12 error_log.setFormatter(fmt) 13 logger_error = logging.Logger('error_log', level=logging.ERROR) 14 logger_error.addHandler(error_log) 15 16 logger_info.info("xxx") 17 logger_error.error("yyy")
执行结果：
这样在后续的使用中我们可以通过定义函数（或者类）来按需调用 即可
1 #logger：产生日志的对象 2 #Filter：过滤日志的对象 3 #Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端 4 #Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式 5 6 #Handler对象：接收logger传来的日志，然后控制输出 7 run_log = logging.FileHandler('run.log', 'a', encoding='utf-8') 8 9 #Formatter对象：日志格式 10 fmt = logging.Formatter(fmt="%(asctime)s - %(levelname)s : %(message)s") 11 12 #为Handler对象绑定格式 13 run_log.setFormatter(fmt) 14 15 #logger对象：负责产生日志，然后交给Filter过滤，然后交给不同的Handler输出 16 logger_info = logging.Logger('run_log', level=logging.INFO) 17 18 #将Handler添加给logger 19 logger_info.addHandler(run_log)