python_fullstack基础(十一)-常用模块

python常用模块

re模块

一、正则表达式

在线测试工具 http://tool.chinaz.com/regex/

1、字符组 ： [字符组]

在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示
字符分为很多类，比如数字、字母、标点等等。
假如你现在要求一个位置”只能出现一个数字”,那么这个位置上的字符只能是0、1、2…9这10个数之一。

2、字符

元字符：
.:匹配除换行符以外的任意字符
\w:匹配字母或数字或下划线
\s:匹配任意的空白符
\d:匹配数字
\n:匹配一个换行符
\t:匹配一个制表符
\b:匹配一个单词的结尾
^:匹配字符串的开始
$:匹配字符串的结尾
\W:匹配非字母或数字或下划线
\D:匹配非数字
\S:匹配非空白符
a|b:匹配字符a或字符b
():匹配括号内的表达式，也表示一个组

3、量词：

*:匹配零次或更多次
+:匹配一次或更多次
?:匹配零次或一次
{n}:匹配n次
{n,}:匹配n次或更多次
{n,m}:匹配n次至m次

4、.*$的用法：

5、*+?{ }的用法：

6、字符集［］［^］用法：

7、分组 ()与 或 ｜［^］用法：

8、转义符 \用法：

9、贪婪匹配用法：

二、python中re模块及常用方法

1、介绍

re 模块使 Python 语言拥有全部的正则表达式功能
re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数

2、常用方法

• 参数说明：
  pattern —— 匹配的正则表达式
  string —— 待匹配的字符串
  flags —— 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

• 匹配对象方法：
  group(num=0) —— 匹配的整个表达式的字符串，group() 可以一次输入多个组这里写代码片号，在这种情况下它将返回一个包含那些组所对应值的元组
  groups() —— 返回一个包含所有小组字符串的元组，从1到所含的小组号

• ①☆findall()返回所有满足匹配条件的结果至列表中

import re
res = re.findall('s','life is short')
print(res)
>>> ['s','s']

• ②☆search() 返回第一个包含匹配条件的信息对象，可以调用该对象的group()方法将匹配的字符输出，如果没有匹配到则调用group()方法会报错

import re
res = re.search('s','life is short')
print(res.group())
>>> 's'

• ③☆match() 与search()方法类似，但是仅在字符串开始出匹配，返回第一个包含匹配条件的信息对象，调用该对象的group()方法将匹配的字符输出，如果没有匹配到则调用group()方法会报错

import re
res = re.match('l','life is short')
print(res.group())
>>> 'l'

• ④split() 逐个按符合条件的字符串对待匹配字符串进行切分，返回结果列表

import re
res = re.split('[ab]','abcd') # 首先按'a'进行切分，形成['','bcd']，之后再按'b'进行切分，形成['','','cd']
print(res)
>>> ['','','cd']

• ⑤sub() 将待匹配字符串中满足匹配条件的内容进行替换，最后一个参数指定替换的次数，返回替换后的字符串

import re
res = re.sub('\d','_','life8is7short7',2)
print(res)
>>> 'life_is_short7'

• ⑥subn() 与sub()方法类型，但是无法指定替换的次数，并且输出的是一个元组，包括替换后的字符串和替换的总次数

import re
res = re.subn('\d','_','life8is7short7')
print(res)
>>> ('life_is_short_', 3)

• ⑦compile() 将正则表达式编译成为一个正则表达式对象，之后可以用re模块中的方法对对象进行操作

import re
obj = re.compile('\d{3}')
res = obj.search('123abc456')
或者res = re.search(obj,'123abc456')
print(res.group())

• ⑧finditer() finditer返回一个存放匹配结果的迭代器，用next等方法取出存放结果的对象，再用group()方法取出结果

import re
res = re.finditer('\d','a1b2c3d4e5')
print(next(res).group())
print(next(res).group())
print(next(res).group())
print([i.group() for i in res])
>>> 1
>>> 2
>>> 3
>>> ['4', '5']

• ★findall的优先级查询: 将findall()方法中匹配条件中加括号后，只会输出匹配到的字符串；可以在括号中加入?:取消权限

import re
res = re.findall('www.(baidu|google).com','www.baidu.com')
print(res)
>>> ['baidu']

#取消权限
import re
res = re.findall('www.(?:baidu|google).com','www.baidu.com')
print(res)
>>> ['www.baidu.com']

• ★split的优先级查询:将split()方法中的匹配条件加括号后，会将满足条件的切分字符也输出值最终列表中，同样可以在括号中加入?:取消权限

import re
res = re.split('(\d)','life1is2short3')
print(res)
>>> ['life', '1', 'is', '2', 'short', '3', '']

#取消权限 
import re
res = re.split('(?:\d)','life1is2short3')
print(res)
>>> ['life', 'is', 'short', '']

collections模块

在内置数据类型（dict、list、set、tuple）的基础上，
collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1.namedtuple: 生成可以使用名字来访问元素内容的tuple

from collections import namedtuple
Point = namedtuple('point',['x','y'])
p1 = Point(1,2)
p2 = Point(99,100)

print(p1.x)
print(p1.y)
print(p2)

>>> 1
>>> 2
>>> point(x=99, y=100)

2.deque: 双端队列，可以快速的从另外一侧追加和推出对象

使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：

from collections import deque
dq = deque(['A','B','C'])
dq.append('X')
dq.appendleft('Y')
print(dq)
>>> deque(['Y', 'A', 'B', 'C', 'X'])

print(dq.pop())
>>> X

print(dq.popleft())
>>> Y

dq.insert(1,666)
print(dq)
>>> deque(['A', 666, 'B', 'C'])

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

from collections import Counter
c = Counter('aaabbbbcccddddddeeeeffffff')
print(c)
>>> Counter({'d': 6, 'f': 6, 'e': 4, 'b': 4, 'c': 3, 'a': 3})

4.OrderedDict: 有序字典

使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：

from collections import OrderedDict
od = OrderedDict([('a',1),('b',2),('c',3)])
print(od)
print(od['a'])
print(od['b'])
print(od['c'])

>>> OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> 1
>>> 2
>>> 3

5.defaultdict: 带有默认值的字典

from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]

dd = defaultdict(list)
dd['k1'].append(1)
dd['k1'].append(2)
dd['k1'].append(3)
dd['k1'].append(4)
dd['k1'].append(5)
print(dd)
>>> defaultdict(<class 'list'>, {'k1': [1, 2, 3, 4, 5]})

时间模块

一、表示时间的三种方式

1、时间戳（timestamp）

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

import time
print(time.time())
>>> 1515570662.77503

2、时间字符串（Format String）

import time
print(time.strftime("%Y-%m-%d %H-%M-%S"))
>>> 2018-01-10 15-59-16

3、结构化时间（struct_time）

import time
print(time.localtime())
>>> time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=16, tm_min=0, tm_sec=33, tm_wday=2, tm_yday=10, tm_isdst=0)

二、几种格式之间的转换

1、时间戳–>结构化时间

语法：
time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致
time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间

import time
print(time.localtime(1515570662.77503))
>>> time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=15, tm_min=51, tm_sec=2, tm_wday=2, tm_yday=10, tm_isdst=0)

import time
print(time.gmtime(1515570662.77503))
>>> time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=7, tm_min=51, tm_sec=2, tm_wday=2, tm_yday=10, tm_isdst=0)

2、结构化时间–>时间戳　

语法：
time.mktime(结构化时间)

import time
time_tuple  = time.localtime(1500000000)
print(time.mktime(time_tuple))
>>> 1500000000.0

3、字符串时间–>结构化时间

语法：
time.strptime(时间字符串,字符串对应格式)

import time
print(time.strftime("%Y-%m-%d %X"))
>>> 2018-01-10 16:19:46
print(time.strftime("%Y-%m-%d",time.localtime(1515570662.77503)))
>>> 2018-01-10

4、结构化时间–>字符串时间

语法:
time.strftime(“格式定义”,”结构化时间”) 结构化时间参数若不传，则现实当前时间

import time
print(time.strptime("2017-03-16","%Y-%m-%d"))
>>> time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
print(time.strptime("07/24/2017","%m/%d/%Y"))
>>> time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

random模块

一、常用方法

1、随机小数

import random
print(random.random()) # 随机输出在0-1之间的小数
>>> 0.11828833626857149

import random
print(random.uniform(1,5)) # 随机输出在范围之间的小数
>>> 2.164732131520036

2、随机整数

import random
print(random.randint(5,10)) # randint中的范围包括首尾
>>> 8

import random
print(random.randrange(5,10,2)) # randrange中的范围顾首不顾尾，可以指定步长
>>> 7

3、随机选择一个返回

import random
print(random.choice([1,'23',[4,5],(6,7)]))
>>> (6, 7)

4、随机选择多个返回，可以指定返回的个数

import random
print(random.sample([1,'23',[4,5],(6,7)],2)) 
>>> [(6, 7), 1]

5、打乱顺序

import random
item=[1,2,3,4,5,6,7,8,9]
random.shuffle(item)
print(item)
>>> [2, 6, 8, 3, 5, 4, 7, 1, 9]

二、应用实例

import random
def v_code():
    code = ''
    for i in range(5):
        num=random.randint(0,9)
        alf=chr(random.randint(65,90))
        add=random.choice([num,alf])
        code="".join([code,str(add)])
    return code
print(v_code())

os模块

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.sep    输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
os.linesep    输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
os.pathsep    输出用于分割文件路径的字符串 win下为;,Linux下为:
os.name    输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
os.system("bash command")  运行shell命令，直接显示
os.popen("bash command)  运行shell命令，获取执行结果
os.environ  获取系统环境变量

os.path部分

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.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

sys模块

sys模块是与python解释器交互的一个接口

sys.argv       命令行参数List，第一个元素是程序本身路径
sys.exit(n)        退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version        获取Python解释程序的版本信息
sys.path           返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform       返回操作系统平台名称

二、应用实例：异常处理和status

import sys
try:
    sys.exit(1)
except SystemExit as e:
    print(e)

序列化模块

一、定义

将原本的字典、列表等内容转换成一个字符串的过程叫做序列化，其反过程叫反序列化。

二、目的

1. 以某种存储形式使自定义对象持久化
2. 将对象从一个地方传递到另一个地方
3. 使程序更具维护性

三、过程

• 字符串——反序列化——>其他数据结构
• 字符串<——序列化——其他数据结构

四、序列化相关模块

1、json:用于字符串(包括其他支持json的语言)和python数据类型间进行转换

• ①dumps、loads 内存操作，dumps用于将结构化数据转化成字符串，loads用于将字符串转化为结构化数据
  

  注意，json转换完的字符串类型的字典中的字符串是由”“表示的

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
dic_d = json.dumps(dic)
print(dic_d)
>>> {"k2": "v2", "k3": "v3", "k1": "v1"}

dic_s = json.loads(dic_d)
print(dic_s)
>>> {'k1': 'v1', 'k3': 'v3', 'k2': 'v2'}

• ②dump、load 文件句柄操作，dumps用于将结构化数据转化成字符串并操作文件句柄存储于文件中， loads用于将字符串转化为结构化数据并操作文件句柄将数据从文件中读至内存

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
with open('json_file',mode='w') as f:
    dic_fd=json.dump(dic,f)
文件中的内容：
>>> {"k3": "v3", "k2": "v2", "k1": "v1"}

with open('json_file',mode='r') as f:
    dic_fs=json.load(f)
print(dic_fs)
>>> {'k1': 'v1', 'k3': 'v3', 'k2': 'v2'}

• ③ensure_ascii关键字参数：ensure_ascii默认True，如果数据中包括非ascii字符，则会以bytes类型数据存储在文件中，若将ensure_ascii改为False，则会以人类可识别字符存储

import json

# 默认ensure_ascii是True，说明支持系统用ascii编码进行数据存储，所以数据在文件中是以bytes类型(utf-8/utf-16/GBK)等方式进行
# 存储的，人类不能直接识别文件中的中文数据内容，如果非要识别则需要进行解码操作；
# 如果将ensure_ascii改为False，则在数据存储时就将数据按照人类可识别的内容进行存储，可直接阅读
dic = {'姓名':'张三','性别':'男','年龄':'18'}
with open('json_file',mode='w') as f:
    dic_fd = json.dump(dic,f)
>>> {"\u5e74\u9f84": "18", "\u6027\u522b": "\u7537", "\u59d3\u540d": "\u5f20\u4e09"}

str1 = b'\u5e74\u9f84'
print (str1.decode('unicode_escape'))
>>> 年龄

dic = {'姓名':'张三','性别':'男','年龄':'18'}
with open('json_file',mode='w') as f:
    dic_fd = json.dump(dic,f,ensure_ascii=False)
>>> 乱码，因为在windows系统下默认用GBK存储，但是道理没变，如果是内存操作，则可以通过pycharm是utf-8的字符编码直接读出

• ④其他参数说明

  • Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key

  • ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为\uXXXX序列，只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。)

  • indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json

  • separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。

  • sort_keys：将数据根据keys的值进行排序。

import json
data = {'username':['张三','李四'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

\>\>\> {
      "age":16,
      "sex":"male",
      "username":[
        "张三",
        "李四"
      ]
    }

2、pickle:用于python特有的类型和python的数据类型间进行转换

注意：

• ①与json相似，pickle提供的方法与json相同，不同的是pickle可以转换python特有的数据类型，而非只有dic、list(tuple)
• ②pickle在文件存储时，使用bytes类型进行存储，所以在读写文件的时候要求mode为wb/rb模式

3、shelve:只提供一个open方法，用key来访问，使用起来与字典类似

• ①序列化到文件、从文件反序列化

import shelve
with shelve.open('shelve_file') as f:
    f['key'] = {1,2,3,4,5,6,7,8,9}

import shelve
with shelve.open('shelve_file') as f:
    data = f['key']
print(data)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

• ②该模块不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB。

import shelve
with shelve.open('shelve_file',flag='r') as f:
    data = f['key']
print(data)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}

• ③??? 该模块在默认情况下不会记录待持久化对象的任何修改，所以需要在shelve.open()时修改默认参数，否则对象的修改不会保存。

import shelve
with shelve.open('shelve_file', writeback=True) as f2:
    print('修改前：'+ str(f2['key']))
    f2['key'] = 'this was not here before'
>>> 修改前：{1, 2, 3, 4, 5, 6, 7, 8, 9}

with shelve.open('shelve_file', writeback=True) as f3:
    print('修改后：'+str(f3['key']))
>>> 修改后：this was not here before

hashlib模块

一、基本功能：

1、不管算法多么不同，摘要的功能始终不变

2、对于相同的字符串使用同一个算法进行摘要，得到的值总是不变的；多次update与一次update的值相同

3、使用不同算法对相同的字符串进行摘要，得到的值应该不同

4、不管使用什么算法，hashlib的方式永远不变

二、应用场景：

1、摘要算法

2、密码的密文存储

3、文件的一致性验证

①在下载的时候 检查我们下载的文件和远程服务器上的文件是否一致

②两台机器上的两个文件 你想检查这两个文件是否相等

三、实例

import hashlib   # 提供摘要算法的模块
md5 = hashlib.md5()
md5.update(b'life is short')
print(md5.hexdigest())

>>> 617d2b938b9b59b347b92f19f84436bd

configparser模块

一、定义：该模块用于读写适用于配置文件的格式与windows的ini文件类似，可以包含一个或多个节(section)，每个节可以有多个参数(键=值)

二、基本操作：

1、创建ini文件

import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
                     'Compression': 'yes',
                     'CompressionLevel': '9',
                     'ForwardX11': 'yes'
                     }
config['config_section_2'] = {'User': 'username'}
config['config_section_3'] = {'Host Port': '8088', 'Host Ip': '192.168.1.1'}
with open('sample.ini', 'w') as configfile:
    config.write(configfile)

2、增删改查操作

①增

import configparser
config = configparser.ConfigParser()
config.add_section('new_added')
config.set('new_added','config_key_1','Value')
config.write(open('sample_add.ini', "w"))

②删

import configparser
config = configparser.ConfigParser()
config.read('sample.ini')
config.remove_section('new_added')
config.remove_option('new_added_2',"config_key_2")
config.write(open('sample_del.ini', "w"))

③改

import configparser
config = configparser.ConfigParser()
config.read('sample.ini')
config.set('config_section_2','user','python')
config.write(open('sample_modi.ini', "w"))

④查

import configparser

config = configparser.ConfigParser()
print(config.sections())
>>> []
config.read('sample.ini')
print(config.sections())  #
>>> ['config_section_1', 'config_section_1']
print('config_section_3' in config)
>>> False
print('config_section_1' in config)
>>> True
print(config['config_section_1']["config_key"])
>>> key
print(config['DEFAULT']['Compression'])
>>> yes
print(config['config_section_1']['active'])
>>> no
print(config['config_section_1'])
>>> < Section: config_section_1 >
for key in config['config_section_1']:  # 注意,有default会默认default的键
    print(key)
print(config.options('config_section_1'))  # 同for循环,找到'config_section_1'下所有键
print(config.items('config_section_1'))  # 找到'config_section_1'下所有键值对
print(config.get('config_section_1', 'config_key'))  # get方法Section下的key对应的value
>>> key

logging模块

一、定义：用于帮助记录不同级别的log信息，可以自定制记录方式和内容

二、简单说明：

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

默认的日志级别设置为：WARNING
日志级别等级：CRITICAL > ERROR > WARNING > INFO > DEBUG
默认的日志格式为：日志级别：Logger名称：用户输出消息

三、配置方式：

1、Basicconfig方式

①特点：灵活配置日志级别，日志格式，输出位置；

• 不足在于对于在文件中写入中文字符无法支持；不能同时输出在终端和文件中

②配置参数：

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

  • filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
  • filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
  • format：指定handler使用的日志显示格式。
  • datefmt：指定日期时间格式。
  • level：设置rootlogger（后边会讲解具体概念）的日志级别
  • stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。

• format参数中可能用到的格式化串：

  • %(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 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
  • %(thread)d 线程ID。可能没有
  • %(threadName)s 线程名。可能没有
  • %(process)d 进程ID。可能没有
  • %(message)s用户输出的消息

③举例

import logging

logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%a, %d %b %Y %H:%M:%S',
                    filename='test.log',
                    filemode='a')

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

# 输出
>>> Wed, 24 Jan 2018 16:09:12 practice.py[line:144] DEBUG debug message
>>> Wed, 24 Jan 2018 16:09:12 practice.py[line:145] INFO info message
>>> Wed, 24 Jan 2018 16:09:12 practice.py[line:146] WARNING warning message
>>> Wed, 24 Jan 2018 16:09:12 practice.py[line:147] ERROR error message
>>> Wed, 24 Jan 2018 16:09:12 practice.py[line:148] CRITICAL critical message

2、logging对象方式

①特点：解决了basicconfig方式的中文支持问题和终端、文本同时输出的问题，推荐

②举例

import logging

logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log', encoding='utf-8')

# 再创建一个handler，用于输出到控制台
sh = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')

fh.setLevel(logging.DEBUG)

fh.setFormatter(formatter)
sh.setFormatter(formatter)

logger.addHandler(fh)  # logger对象可以添加多个fh和ch对象
logger.addHandler(sh)

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

>>> 2018-01-24 16:24:15,398 - root - WARNING - logger warning message
>>> 2018-01-24 16:24:15,398 - root - ERROR - logger error message
>>> 2018-01-24 16:24:15,398 - root - CRITICAL - logger critical message