前言
什么是模块？
一个模块就是一个包含了python定义和声明的文件。模块的本质就是一段在其他文件中的代码。
re模块
1.正则表达式
正则表达式不仅在python中，在整个编程中都占有举足轻重的作用。不管你以后做不做开发，只要你是一个程序员就应该了解正则表达式的基本使用。如果未来要在爬虫领域发展，更要学好这方面的知识。
re模块本质上和正则表达式没有任何的关系。他们的关系类似于time模块和时间的关系。在没有接触python之前，不知道time模块，但是我们都知道时间，时间有自己本身的格式和规则，time模块只不过是python提供给我们用来操作时间的一个工具。同样的，不管有没有python，正则表达式都是存在的，他有自己的格式和规则，而re模块只是python提供给我们使用正则表达式的工具而已。
正则表达式和python没有任何的关系，它是匹配字符串内容的一种规则。
官方定义：正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
正则表达式是用于操作字符串的，我们要想约束在同一个位置上字符出现的范围，就需要使用正则表达式中的一个规则：字符组。字符组的定义就是在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示，[字符组]，字符分为很多类，比如数字、字母、标点等等。
我们可以借助工具来验证：http://tool.chinaz.com/regex/
| 正则 | 匹配字符 | 匹配结果 | 说明 |
| [0123456789] | 5 | True |
在一个字符组里枚举合法的所有字符，字符组里的任意一个字符 |
| [0123456789] | a | False |
由于字符组中没有"a"字符，所以不能匹配
|
| [0-9] | 6 | True |
可以用-表示范围,[0-9]就和[0123456789]是一个意思
|
| [a-z] | d | True |
同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示
|
| [A-Z] | Q | True |
[A-Z]就表示所有的大写字母
|
| [0-9a-fA-F] | c | True |
可以匹配数字，大小写形式的a～f，用来验证十六进制字符
|
字符：
| 元字符 | 匹配内容 |
| . | 匹配除换行符以外任意字符 |
| w | 匹配字母或数字或下划线 |
| s | 匹配任意的空白符 |
| d | 匹配数字 |
| W | 匹配非字母数字下划线 |
| S | 匹配非空白符 |
| D | 匹配非数字 |
| 匹配一个换行符 | |
| 匹配一个制表符（tab键） | |
| 匹配单词的开始或结束 | |
| B | 匹配不是单词的开始或结束的位置 |
| ^ | 匹配字符串的开始 |
| $ | 匹配字符串的结尾 |
| a|b | 匹配字符a或字符b |
| () | 匹配括号内的表达式，也表示一个组 |
| [...] | 匹配字符组中的字符 |
| [^...] | 匹配除了字符组中字符的所有字符 |
备注：元字符中a|b如果匹配的两个字符是包含关系时，将较长的字符放在前面。比如：'abc'和'abcdef'，匹配两个字符串时，如果较短的放在前面，输入较长的字符时，由于计算机执行的方式是由左往右，此时执行匹配的结果就是'abc'，而不会继续匹配后面的'def'。
^和$的使用非常重要。^必须在最前面，$必须在最后面，当^和$同时出现时，要匹配的内容就是^和$之间的固定内容。比如：使用^as$来匹配一个文件，那文件内容必须是as，不是asas，也不是a...s
量词：
| 量词 | 用法说明 |
| * | 重复零次或更多次 |
| + | 重复一次或更多次 |
| ？ | 重复零次或一次 |
| {n} | 重复n次 |
| {n,} | 重复n次或更多次 |
| {n,m} | 重复n次到m次 |
贪婪匹配和惰性匹配：
贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配
| 正则 | 待匹配字符 | 匹配结果 |
| 海.* | 海风海洋海域 | 海风海洋海域 |
| 海.+ | 海风海洋海域 | 海风海洋海域 |
| 海.？ | 海风海洋海域 |
海风 海洋 海域 |
| 海.{1,2} | 海风海洋海域 |
海风海 海域 |
| 正则 | 待匹配字符 | 匹配结果 |
| 海.*? | 海风海洋海域 |
海 海 海 |
| 海.+? | 海风海洋海域 |
海风 海洋 海域 |
| 海.?? | 海风海洋海域 |
海 海 海 |
| 海.{1,2}? | 海风海洋海域 |
海风 海洋 海域 |
注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
.*?的用法
. 是任意字符 * 是取 0 至 无限长度 ? 是非贪婪模式。 何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在： .*?x 就是取前面任意长度的字符，直到一个x出现
| 正则 | 待匹配的字符 | 匹配结果 | 说明 |
| d+ | 55 | 55 | 表示所有的整数 |
| 0.d+ | 0.45 | 0.45 | 表示所有的正小数 |
| d+.?d* | 3.0 | 3.0 | 表示所有的非负数 |
身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部由数字组成，首位不能为0；如果是18位，则前17位全部是数字，首位不能为0，末位可能是数字或x，下面我们尝试用正则来表示：
1.使用元字符a|b表示：^([1-9]d{16}[0-9x]|[1-9]d{14})$
2.使用量词?实现15或18位两者间差的三位的有或无：^[1-9]d{14}(d{2}[0-9x])?$
2.re模块下的使用方法
在python中对正则表达式进行操作就需要引用一个模块：import re
我们使用模块，只需要两个参数: 自己写的正则表达式 和 待匹配的字符
re模块中常用的三种方法：
import re #re.findall的使用需要两个参数：正则表达式和待匹配的字符串。返回值是一个列表，列表中包含‘所有’符合条件的项 # findall(pattern, string, flags=0) ret = re.findall('d','a1b2c3') print(ret) #['1', '2', '3'] 返回所有满足匹配条件的结果，放在列表里 ret = re.findall('[^和]','风和日丽和雨') print(ret) #['风', '日', '丽', '雨'] #re.search的使用也需要两个参数：正则表达式和待匹配的字符串。返回的是第一个满足条件的项 # 使用.group()方法就可以获取到具体的值，需要注意的是，如果没有匹配上，使用.group()会报错 # 所以应该在使用group方法之前做判断 # search(pattern, string, flags=0) ret = re.search('d','a1b2c3') print(ret) #<_sre.SRE_Match object; span=(1, 2), match='1'> 返回一个匹配到了的信息 res = ret.group() #需要借助.group()来返回匹配结果 print(res) # 1 返回匹配到的第一项内容 ret = re.search('a','[a2a3a4]').group() print(ret) #a ret = re.search('[a-z]','12345') print(ret) #None 要匹配的内容不存在时，返回 None res = ret.group() print(res) #报错 AttributeError: 'NoneType' object has no attribute 'group' # 匹配元素不存在时，匹配结果会报错，所以当数据量很大，我们又不知道匹配的元素是否存在时，为了避免报错，对代码优化 ret = re.search('[a-z]','12345') print(ret) if ret: res = ret.group() print(res) #re.match()的使用方法跟search相似，不同的是match方法的正则自带^效果 # match(pattern, string, flags=0) ret = re.match('a','abac') print(ret) #<_sre.SRE_Match object; span=(0, 1), match='a'> res = ret.group() # 借助group() print(res) #a ret = re.match('a','baba') print(ret) #None 匹配字符串的开始，找不到返回None
使用.group()和正则()时，可以给group传参
import re ret = re.search('([a-z])(d)','ab2748cdef14g239') print(ret.group()) # 直接获取正则规则匹配到的项 print(ret.group(2)) # 如果给group传递参数,那么传递的参数能够代表在正则表达式中组的次序 print(ret.group(1)) # 从而获取到对应次序上的值
备注：.groups()方法的使用 ，返回一个元组 接收所有含有在()内的元素 ，没有则返回一个空元组，有几个，就接收几个。
不常用的方法：
import re #split 分割 ret = re.split('[ab]','abcd') print(ret) #['', '', 'cd'] 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割 #sub 替换 ret = re.sub('d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个 print(ret) #evaHegon4yuan4 #subn ret = re.subn('d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次) print(ret) #('evaHegonHyuanH', 3)
re模块的进阶用法
要匹配的数据量非常大时，将正则表达式通过compile转化为正则表达式对象可以提高匹配的效率，节省大量的时间，同过finditer可以返回一个存放匹配结果的迭代器，取值时一个一个的取，可以极大的节省内存。
import re #compile() 返回一个正则表达式对象 当要匹配的数据非常大时，使用comlile 可以提高效率，节省时间 #compile(pattern, flags=0):"Compile a regular expression pattern, returning a pattern object." obj = re.compile('d{3}') #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字 print(obj) #re.compile('\d{3}') ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串 print(ret.group()) #结果 ： 123 #finditer 返回一个存放匹配结果的迭代器 当匹配的数据量很大时，使用finditer 可以节省大量的内存 ret = re.finditer('d', 'ds3sy4784a') #finditer返回一个存放匹配结果的迭代器 print(ret) # <callable_iterator object at 0x10195f940> print(next(ret).group()) #查看第一个结果 3 print(next(ret).group()) #查看第二个结果 4 print([i.group() for i in ret]) #查看剩余的左右结果 ['7', '8', '4']
findall的优先级查询：
import re #findall中正则 () 的使用 ：出现()时仍然按照正则规则去匹配，只不过在显示的时候，只显示分组中的内容 ret = re.findall('[a-z]d','asd2fg5jk6') print(ret) #['d2', 'g5', 'k6'] ret = re.findall('[a-z](d)','asd2fg5jk6') print(ret) #['2', '5', '6'] 对数字加上()后在正则表达式中跟不加()的结果是一样的，但在findall中两者输出结果不一样 ret = re.findall('www.(baidu|hao123).com','www.baidu.com') print(ret) #['baidu'] 这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可,在括号的最前面加:?: ret = re.findall('www.(?:baidu|hao123).com','www.baidu.com') print(ret) #['www.baidu.com'] 加上?:就会取消这个权限
split的优先级查询：
ret=re.split("d+","eva3egon4yuan") print(ret) #结果 ： ['eva', 'egon', 'yuan'] ret=re.split("(d+)","eva3egon4yuan") print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan'] #在匹配部分加上（）之后所切出的结果是不同的， #没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项， #这个在某些需要保留匹配部分的使用过程是非常重要的。
标签的匹配
import re ret = re.search('<w+>w+</w+>','<html>hello</html>') print(ret.group()) #初步实现了匹配标签，当前后<...>的内容不一样时也能匹配，所以约束的不完全 #当我们想要实现前后的标签内容一样时，可以在分组中利用?P<name>的形式给分组起名字(?P(大写的P) ret = re.search('<(?P<name>w+)>w+</(?P=name)>','<html>hello</html>') print(ret.group()) #此时就可以保证匹配的前后标签一样 print(ret.group('name')) #可以直接用group('名字')拿到对应的值 #另一种方法：（不推荐使用） ret = re.search(r"<(w+)>w+</1>","<h1>hello</h1>") #如果不给组起名字，也可以用序号来找到对应的组，表示要找的内容和前面的组内容一致 #获取的匹配结果可以直接用group(序号)拿到对应的值 print(ret.group(1)) #也能实现匹配的前后标签一样 print(ret.group()) #结果 ：<h1>hello</h1>
匹配整数
import re ret=re.findall(r"d+","1-2*(60+(-40.35/5)-(-4*3))") print(ret) #['1', '2', '60', '40', '35', '5', '4', '3'] ret=re.findall(r"-?d+.d*|(-?d+)","1-2*(60+(-40.35/5)-(-4*3))") print(ret) #['1', '-2', '60', '', '5', '-4', '3'] ret.remove("") print(ret) #['1', '-2', '60', '5', '-4', '3']
数字匹配
1、 匹配一段文本中的每行的邮箱 http://blog.csdn.net/make164492212/article/details/51656638 2、 匹配一段文本中的每行的时间字符串，比如：‘1990-07-12’； 分别取出1年的12个月（^(0?[1-9]|1[0-2])$）、 一个月的31天：^((0?[1-9])|((1|2)[0-9])|30|31)$ 3、 匹配qq号。(腾讯QQ号从10000开始) ［1,9］[0,9]{4,} 4、 匹配一个浮点数。 ^(-?d+)(.d+)?$ 或者 -?d+.?d* 5、 匹配汉字。 ^[u4e00-u9fa5]{0,}$ 6、 匹配出所有整数
爬虫的应用
从一个网站上匹配自己需要的信息，添加到一个新的文件中
import requests import re import json def getPage(url): response=requests.get(url) return response.text def parsePage(s): com=re.compile('<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>d+).*?<span class="title">(?P<title>.*?)</span>' '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>',re.S) ret=com.finditer(s) for i in ret: yield { "id":i.group("id"), "title":i.group("title"), "rating_num":i.group("rating_num"), "comment_num":i.group("comment_num"), } def main(num): url='https://movie.douban.com/top250?start=%s&filter='%num response_html=getPage(url) ret=parsePage(response_html) print(ret) f=open("move_info7","a",encoding="utf8") for obj in ret: print(obj) data=json.dumps(obj,ensure_ascii=False) f.write(data+" ") if __name__ == '__main__': count=0 for i in range(10): main(count) count+=25
import re import json from urllib.request import urlopen def getPage(url): response = urlopen(url) return response.read().decode('utf-8') def parsePage(s): com = re.compile( '<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>d+).*?<span class="title">(?P<title>.*?)</span>' '.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>(?P<comment_num>.*?)评价</span>', re.S) ret = com.finditer(s) for i in ret: yield { "id": i.group("id"), "title": i.group("title"), "rating_num": i.group("rating_num"), "comment_num": i.group("comment_num"), } def main(num): url = 'https://movie.douban.com/top250?start=%s&filter=' % num response_html = getPage(url) ret = parsePage(response_html) print(ret) f = open("move_info7", "a", encoding="utf8") for obj in ret: print(obj) data = str(obj) f.write(data + " ") count = 0 for i in range(10): main(count) count += 25
flags的用法：
flags有很多可选值： re.I(IGNORECASE)忽略大小写，括号内是完整的写法 re.M(MULTILINE)多行模式，改变^和$的行为 re.S(DOTALL)点可以匹配任意字符，包括换行符 #这个比较常用 re.L(LOCALE)做本地化识别的匹配，表示特殊字符集 w, W, , B, s, S 依赖于当前环境，不推荐使用 re.U(UNICODE) 使用w W s S d D使用取决于unicode定义的字符属性。在python3中默认使用该flag re.X(VERBOSE)冗长模式，该模式下pattern字符串可以是多行的，忽略空白字符，并可以添加注释
collections模块（扩展数据类型）
在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。
1.namedtuple: 生成可以使用名字来访问元素内容的tuple
2.deque: 双端队列，可以快速的从另外一侧追加和推出对象
3.Counter: 计数器，主要用来计数
4.OrderedDict: 有序字典
5.defaultdict: 带有默认值的字典
1.namedtuple
我们知道tuple可以表示不变集合，例如，一个点的二维坐标就可以表示成：
>>> p = (1, 2)
但是，看到(1, 2)，很难看出这个tuple是用来表示一个坐标的。
这时，namedtuple就派上了用场：
from collections import namedtuple point = namedtuple('Point',['x','y']) p1 = point(1,2) print(p1) #Point(x=1, y=2) #可以很明确的表示数据是什么 print(p1.x,p1.y) #1 2 #取数据的时候不会乱 不管在任何时候从元组中取数据 都可以明确的知道要取的内容
类似的，如果要用坐标和半径表示一个圆，也可以用namedtuple定义：
#namedtuple('名称', [属性list]): Circle = namedtuple('Circle', ['x', 'y', 'r'])
生活中我们也会使用namedtuple来描述一副扑克牌
from collections import namedtuple Card = namedtuple('Card',['colour','value']) Card1 = Card('红桃','A') print(Card1) #Card(colour='红桃', value='A')
2.deque
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
deque是双端队列，就先讲下队列 queue
队列遵循FIFO原则（FIFO =first in first out），也就是先进先出原则，所以火车票购票排队可以采用这个原则，先排队的先出票。
import queue q = queue.Queue() q.put(3) q.put(7) q.put(5) print(q) #<queue.Queue object at 0x00000216E7B1EE48> print(q.get()) #3 先进先出 print(q.get()) #7 print(q.get()) #5
from collections import deque dq = deque() print(dq) #deque([]) 默认一个列表 print(dq.append(4)) #None 无返回值 dq.append(6) dq.append(3) print(dq) #deque([4, 6, 3]) 依次添加 dq.appendleft(7) print(dq) #deque([7, 4, 6, 3]) 在最前面直接添加 print(dq.pop()) # 3 从最后面删除 print(dq.popleft()) # 7 从最左边删除
deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
3.Counter
Counter类的目的是用来跟踪值出现的次数。它是一个无序的容器类型，以字典的键值对形式存储，其中元素作为key，其计数作为value。计数值可以是任意的Interger（包括0和负数）。Counter类和其他语言的bags或multisets很相似。
c = Counter('abcdeabcdabcaba')
print(c)
输出：Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
4.OrderedDict
使用dict时，Key是无序的。在对dict做迭代时，我们无法确定Key的顺序。
如果要保持Key的顺序，可以用OrderedDict：
d = dict([('a', 1), ('b', 2), ('c', 3)]) print(d) #{'a': 1, 'b': 2, 'c': 3} from collections import OrderedDict od = OrderedDict({'a': 1, 'b': 2, 'c': 3}) print(od) #OrderedDict([('a', 1), ('b', 2), ('c', 3)]) od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) print(od) #OrderedDict([('a', 1), ('b', 2), ('c', 3)])
注意，OrderedDict的Key会按照插入的顺序排列，不是Key本身排序：
>>> od = OrderedDict() >>> od['z'] = 1 >>> od['y'] = 2 >>> od['x'] = 3 >>> od.keys() # 按照插入的Key的顺序返回 ['z', 'y', 'x']
5.defaultdict
有如下值集合 [11,22,33,44,55,66,77,88,99,90...]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
即： {'k1': 大于66 , 'k2': 小于66}
values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = {} for value in values: if value>66: if my_dict.has_key('k1'): my_dict['k1'].append(value) else: my_dict['k1'] = [value] else: if my_dict.has_key('k2'): my_dict['k2'].append(value) else: my_dict['k2'] = [value]
现在，我们可以通过模块完成它。
from collections import defaultdict values = [11, 22, 33,44,55,66,77,88,99,90] my_dict = defaultdict(list) for value in values: if value>66: my_dict['k1'].append(value) else: my_dict['k2'].append(value)
在使用defaultdict时，defaultdict（可callable的）括号中必须是可调用的，也就是callable（参数）=True的
from collections import defaultdict ret = defaultdict() print(ret) #defaultdict(None, {}) ret = defaultdict(str) print(ret) #defaultdict(<class 'str'>, {}) print(callable(str)) #True def func(): print(11) ret = defaultdict(func) print(ret) #defaultdict(<function func at 0x000001EC70C43598>, {}) print(callable(func)) #True
使用dict时，如果引用的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'
random模块
>>> import 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]
我们可以利用random生成一个六位数包含数字和字母的随机验证码
import random def code(): list = [] for i in range(6): num = random.randint(0,9) #随机生成一个数字 alpha = chr(random.randint(65,90)) #利用chr()的用法随机输出一个大写字母 alpha_letter = chr(random.randint(97,122)) #同样的随机输出一个小写字母 alpha_add = random.choice([alpha,alpha_letter]) #从大小写字母中随机输出一个，可以保证结果的均衡 add = random.choice([alpha_add,num]) #从数字和字母中随机输出一个，可以保证概率的平衡 list.append(str(add)) #这里必须使用str将随机的数字字符串化，因为join()的分割条件必须全部是字符串 ret = ''.join(list) return ret print(code())
时间模块
和时间有关系的我们就要用到时间模块。在使用模块之前，应该首先导入这个模块：import time
#常用方法
1.time.sleep(secs)
(线程)推迟指定的时间运行。单位为秒。
2.time.time()
获取当前时间戳
表示时间的三种方式
在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
(2)格式化的时间字符串(Format String)： ‘1999-12-06’
python中时间日期格式化符号：
%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 |
首先，我们先导入time模块，来认识一下python中表示时间的几种格式：
#导入时间模块
>>>import time
#时间戳
>>>time.time()
1500875844.800804
#时间字符串
>>>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'
#时间元组: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)
小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的
几种格式之间的转换
#时间戳-->结构化时间
#time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致
#time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
#结构化时间-->时间戳
#time.mktime(结构化时间)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0
#结构化时间-->字符串时间
#time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则现实当前时间
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'
#字符串时间-->结构化时间
#time.strptime(时间字符串,字符串对应格式)
>>>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)
>>>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)
#结构化时间 --> %a %b %d %H:%M:%S %Y串
#time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串
>>>time.asctime(time.localtime(1500000000))
'Fri Jul 14 10:40:00 2017'
>>>time.asctime()
'Mon Jul 24 15:18:33 2017'
#时间戳 --> %a %d %d %H:%M:%S %Y串
#time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串
>>>time.ctime()
'Mon Jul 24 15:19:07 2017'
>>>time.ctime(1500000000)
'Fri Jul 14 10:40:00 2017'
计算时间差：
import time true_time=time.mktime(time.strptime('2018-02-28 08:30:00','%Y-%m-%d %H:%M:%S')) time_now=time.mktime(time.strptime('2017-03-01 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))
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下为" ",Linux下为" " os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' os.system("bash command") 运行shell命令，直接显示 os.popen("bash command).read() 运行shell命令，获取执行结果 os.environ 获取系统环境变量
os.urandom(n) 生成一个随机n位的bytes类型的字节 os.walk('dir') 括号中跟目录路径，生成一个包含该目录下文件的生成器generator
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的大小
注意：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"。在某些系统上（如Unix）是最新的元数据更改的时间，在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。
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)
序列化模块
在计算机中，只有字符串能被写进文件中，同样的计算机的网路传输存储都是bytes类型，bytes类型可以跟字符串转化。所以一个数据要想传输储存，都要转化成字符串的形式来实现，而生活中一些字典列表类型的数据是无法直接存储和传输的，这是我们就需要对它们转化，就是序列化。
定义：序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。
比如，我们在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给？
现在我们能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来。
但是我们都知道，对于文件来说是没有字典这个概念的，所以我们只能将数据转换成字典放到文件中。
你一定会问，将字典转换成一个字符串很简单，就是str(dic)就可以办到了，为什么我们还要学习序列化模块呢？
没错序列化的过程就是从dic 变成str(dic)的过程。现在你可以通过str(dic)，将一个名为dic的字典转换成一个字符串，
但是你要怎么把一个字符串转换成字典呢？
聪明的你肯定想到了eval()，如果我们将一个字符串类型的字典str_dic传给eval，就会得到一个返回的字典类型了。
eval()函数十分强大，但是eval是做什么的？e官方demo解释为：将字符串str当成有效的表达式来求值并返回计算结果。
ＢＵＴ！强大的函数有代价。安全性是其最大的缺点。
想象一下，如果我们从文件中读出的不是一个数据结构，而是一句"删除文件"类似的破坏性语句，那么后果实在不堪设设想。
而使用eval就要担这个风险。
所以，我们并不推荐用eval方法来进行反序列化操作(将str转换成python中的数据结构)
序列化的目的
json
Json模块提供了四个功能：dumps、dump、loads、load。
dumps(序列化)和loads（反序列化）、dump（序列化）和load（反序列化）两两搭配使用
json.dumps(obj) 括号中加要序列化的对象 json.dump(obj,f) 括号中跟序列化对象和一个文件句柄，所以dump和load用于文件的写和读，且load只能反序列化只包含一个数据结构的文件。
注意：使用json序列化数据后，原数据中的引号（不管是''还是""）都会转化为""(双引号)
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic) #序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic) #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json转换完的字符串类型的字典中的字符串是由""表示的
dic2 = json.loads(str_dic) #反序列化：将一个字符串格式的字典转换成一个字典
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
print(type(dic2),dic2) #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]
import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f) #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()
f = open('json_file')
dic2 = json.load(f) #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)
import json
f = open('file','w')
json.dump({'国籍':'中国'},f)
ret = json.dumps({'国籍':'中国'})
f.write(ret+'
')
json.dump({'国籍':'美国'},f,ensure_ascii=False)
ret = json.dumps({'国籍':'美国'},ensure_ascii=False)
f.write(ret+'
')
f.close()
Serialize obj to a JSON formatted str.(字符串表示的json对象)
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的中文即可正常显示。)
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse).
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity).
indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示，否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json
separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError.
sort_keys：将数据根据keys的值进行排序。
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.
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)
当一个文件中包含多个数据结构时，我们可以通过for循环读，每次读一行，通过json.loads（）逐行转化
with open('logger',encoding='utf-8') as f1: for i in f1: print(json.loads(i))
备注：
json序列化时定制支持datetime类型，和到中文让他保留中文形式
json序列化时，可以处理的数据类型有哪些？如何定制支持datetime类型
自定义时间序列化转换器
import json
from json import JSONEncoder
from datetime import datetime
class ComplexEncoder(JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
else:
return super(ComplexEncoder,self).default(obj)
d = { 'name':'alex','data':datetime.now()}
print(json.dumps(d,cls=ComplexEncoder))
# {"name": "alex", "data": "2018-05-18 19:52:05"}
json序列化时遇到中文会默认转换成unicode ，如何让他保留中文形式
import json
a=json.dumps({"ddf":"你好"},ensure_ascii=False)
print(a) #{"ddf": "你好"}
pickle
json & pickle 模块
用于序列化的两个模块
- json，用于字符串 和 python数据类型间进行转换
- pickle，用于python特有的类型 和 python的数据类型间进行转换
pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）
import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic) #一串二进制内容
dic2 = pickle.loads(str_dic)
print(dic2) #字典
import time
struct_time = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()
f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)
这时候机智的你又要说了，既然pickle如此强大，为什么还要学json呢？
这里我们要说明一下，json是一种所有的语言都可以识别的数据结构。
如果我们将一个字典或者序列化成了一个json存在文件里，那么java代码或者js代码也可以拿来用。
但是如果我们用pickle进行序列化，其他语言就不能读懂这是什么了～
所以，如果你序列化的内容是列表或者字典，我们非常推荐你使用json模块
但如果出于某种原因你不得不序列化其他的数据类型，而未来你还会用python对这个数据进行反序列化的话，那么就可以使用pickle
shelve
shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。
shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。
import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'} #直接对文件句柄操作，就可以存入数据
f.close()
import shelve
f1 = shelve.open('shelve_file')
existing = f1['key'] #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)
这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB
import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)
由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存。
import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()
f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()
writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。
hashlib模块
算法介绍
Python的hashlib模块中提供了常见的摘要算法，如MD5，SHA1等等。
什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。
摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。
摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。
我们以常见的摘要算法MD5为例，计算出一个字符串的MD5值：
import hashlib
md5 = hashlib.md5()
md5.update('how to use md5 in python hashlib?')
print md5.hexdigest()
计算结果如下：
d26a53750bc40b38b65a520292f69306
如果数据量很大，可以分块多次调用update()，最后计算的结果是一样的：
md5 = hashlib.md5()
md5.update('how to use md5 in ')
md5.update('python hashlib?')
print md5.hexdigest()
MD5是最常见的摘要算法，速度很快，生成结果是固定的128 bit字节，通常用一个32位的16进制字符串表示。另一种常见的摘要算法是SHA1，调用SHA1和调用MD5完全类似：
import hashlib
sha1 = hashlib.sha1()
sha1.update('how to use sha1 in ')
sha1.update('python hashlib?')
print sha1.hexdigest()
SHA1的结果是160 bit字节，通常用一个40位的16进制字符串表示。比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长。
摘要算法应用
任何允许用户登录的网站都会存储用户登录的用户名和口令。如何存储用户名和口令呢？方法是存到数据库表中：
name | password
--------+----------
michael | 123456
bob | abc999
alice | alice2008
如果以明文保存用户口令，如果数据库泄露，所有用户的口令就落入黑客的手里。此外，网站运维人员是可以访问数据库的，也就是能获取到所有用户的口令。正确的保存口令的方式是不存储用户的明文口令，而是存储用户口令的摘要，比如MD5：
username | password
---------+---------------------------------
michael | e10adc3949ba59abbe56e057f20f883e
bob | 878ef96e86145580c38c87f0410ad153
alice | 99b1c2188db85afee403b1536010c2c9
考虑这么个情况，很多用户喜欢用123456，888888，password这些简单的口令，于是，黑客可以事先计算出这些常用口令的MD5值，得到一个反推表：
'e10adc3949ba59abbe56e057f20f883e': '123456'
'21218cca77804d2ba1922c33e0151105': '888888'
'5f4dcc3b5aa765d61d8327deb882cf99': 'password'
这样，无需破解，只需要对比数据库的MD5，黑客就获得了使用常用口令的用户账号。
对于用户来讲，当然不要使用过于简单的口令。但是，我们能否在程序设计上对简单口令加强保护呢？
由于常用口令的MD5值很容易被计算出来，所以，要确保存储的用户口令不是那些已经被计算出来的常用口令的MD5，这一方法通过对原始口令加一个复杂字符串来实现，俗称“加盐”：
hashlib.md5("salt".encode("utf8"))
经过Salt（盐）处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。
但是如果有两个用户都使用了相同的简单口令比如123456，在数据库中，将存储两条相同的MD5值，这说明这两个用户的口令是一样的。有没有办法让使用相同口令的用户存储不同的MD5呢？
如果假定用户无法修改登录名，就可以通过把登录名作为Salt的一部分来计算MD5，从而实现相同口令的用户也存储不同的MD5。
摘要算法在很多地方都有广泛的应用。要注意摘要算法不是加密算法，不能用于加密（因为无法通过摘要反推明文），只能用于防篡改，但是它的单向计算特性决定了可以在不存储明文口令的情况下验证用户口令。还可以应用于校验文件的一致性，在网络上传和下载，保证多台机器状态的一致。在这些地方我们可以用到摘要算法。
configparser模块
配置文件无处不在，配置文件的格式有很多种，比较常用的有两种：一种是在python中用一个python文件作为配置文件（.py），这种配置文件里面的所有值都不需要转换或者处理，直接就可以当做变量调用，但是它只适用于python中，通用性差。另一种是采用普通的文本格式作为配置文件（.txt），这种配置文件是通用的，但是需要对文件处理，麻烦。当然还有其他的配置文件格式，比如：ini格式。configparser模块适用于配置文件的格式与windows ini文件类似，可以包含一个或多个节/组（section,用[中括号+组名]表示)，每个节可以有多个参数/项(option)（键=值）。
创建文件
来看一个好多软件的常见文档格式如下：
[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
[bitbucket.org]
User = hg
[topsecret.server.com]
Port = 50022
ForwardX11 = no
如果想用python生成一个这样的文档怎么做呢？
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9',
'ForwardX11':'yes'
}
config['bitbucket.org'] = {'User':'hg'}
config['topsecret.server.com'] = {'Host Port':'50022','ForwardX11':'no'}
with open('example.ini', 'w') as configfile:
config.write(configfile)
查找文件
import configparser
config = configparser.ConfigParser()
#---------------------------查找文件内容,基于字典的形式
print(config.sections()) # []
config.read('example.ini')
print(config.sections()) # ['bitbucket.org', 'topsecret.server.com']
print('bytebong.com' in config) # False
print('bitbucket.org' in config) # True
print(config['bitbucket.org']["user"]) # hg
print(config['DEFAULT']['Compression']) #yes
print(config['topsecret.server.com']['ForwardX11']) #no
print(config['bitbucket.org']) #<Section: bitbucket.org>
for key in config['bitbucket.org']: # 注意,有default会默认default的键
print(key)
print(config.options('bitbucket.org')) # 同for循环,找到'bitbucket.org'下所有键
print(config.items('bitbucket.org')) #找到'bitbucket.org'下所有键值对
print(config.get('bitbucket.org','compression')) # yes get方法Section下的key对应的value
增删改操作
import configparser
config = configparser.ConfigParser()
config.read('example.ini')
config.add_section('yuan')
config.remove_section('bitbucket.org')
config.remove_option('topsecret.server.com',"forwardx11")
config.set('topsecret.server.com','k1','11111')
config.set('yuan','k2','22222')
config.write(open('new2.ini', "w"))
logging模块
logging模块是操作日志的模块，使日志的格式更加规范，等级更加鲜明。日志的记录有两种手段：1.显示在显示屏上，更直观。2.记录在文件中，便于查看。
logging模块有两种用法：1.简单的配置用法（要么显示在屏幕上，要么写在文件中，不能同时进行）。2.logger对象配置（两者可以同时进行）
函数式简单配置
import logging
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')
默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG），默认的日志格式为日志级别：Logger名称：用户输出消息。
灵活配置日志级别，日志格式，输出位置:
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='/tmp/test.log',
filemode='w')
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')
配置参数：
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用户输出的消息
logger对象配置
import logging
logger = logging.getLogger()
# 创建一个handler，用于写入日志文件
fh = logging.FileHandler('test.log',encoding='utf-8')
# 再创建一个handler，用于输出到控制台
ch = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
fh.setLevel(logging.DEBUG)
fh.setFormatter(formatter)
ch.setFormatter(formatter)
logger.addHandler(fh) #logger对象可以添加多个fh和ch对象
logger.addHandler(ch)
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')
logging库提供了多个组件：Logger、Handler、Filter、Formatter。Logger对象提供应用程序可直接使用的接口，Handler发送日志到适当的目的地，Filter提供了过滤日志信息的方法，Formatter指定日志显示格式。另外，可以通过：logger.setLevel(logging.Debug)设置级别,当然，也可以通过fh.setLevel(logging.Debug)单对文件流设置某个级别。
shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中，可以部分内容
shutil.copyfile(src, dst)
拷贝文件
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
shutil.copystat(src, dst)
拷贝状态的信息，包括：mode bits, atime, mtime, flags
shutil.copy(src, dst)
拷贝文件和权限
shutil.copy2(src, dst)
拷贝文件和状态信息
shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
递归的去拷贝文件
例如：copytree(source, destination, ignore=ignore_patterns('*.pyc', 'tmp*'))
shutil.rmtree(path[, ignore_errors[, onerror]])
递归的去删除文件
shutil.move(src, dst)
递归的去移动文件
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如：www =>保存至当前路径
如：/Users/wupeiqi/www =>保存至/Users/wupeiqi/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的