python自动化运维之路~DAY5
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.模块的分类
模块，用一砣代码实现了某个功能的代码集合。
类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码用来调用即可，提供了代码的重用性和代码间的耦合。而对于一个复杂的功能来，可能需要多个函数才能完成（函数又可以在不同的.py文件中），n个 .py 文件组成的代码集合就称为模块。
如：os 是系统相关的模块；file是文件操作相关的模块
模块分为三种：
1>.自定义模块:自定义的模块，顾名思义，就是你自己写的python程序，我们知道python的代码都存在一个以".py"结尾的文件中的，我们这样命名一个python脚本，吧后缀去掉就是模块名称，这个就是自定义模块，我举个例子：我写了一个yinzhengjie.py的文件。里面的内容我们可以忽略，如果我们要导入这个模块的话直接导入yinzhengjie这个模块名称就好了；
2>.内置模块：那么问题来了，我们学的cha(),id()等等所有的内置函数是模块吗？答案是否定的！不是！对内置函数不是内置模块，他们只是python解释器自带的一些功能，那么什么是内置模块呢？一会我会再我的博客中提到一些常用的内置模块；
3>.开源模块：这个就很好解释了，python语言的官网提供了一个供应开发人员上传你的代码到服务器上（https://pypi.python.org/pypi），然后客户端只要在命令行中输入安装命令就可以随意的在shell或者cmd的python解释器中调用这个第三方模块，比如：pip install paramiko.
二.内置模块解析：
1.OS模块详解
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import os
7 #1.获取当前工作目录，即当前python脚本工作的目录路径
8 print(os.getcwd())
9 #2.改变当前脚本工作目录；相当于shell下cd,记住，这个是没有返回值的哟！
10 print(os.chdir(r"D:\python\daima\DAY1"))
11 #3.返回当前目录: ('.')
12 print(os.curdir)
13 #4.获取当前目录的父目录字符串名：('..')
14 print(os.pardir)
15 #5.可生成多层递归目录(创建目录),生产完毕后返回一个None值
16 print(os.makedirs("D:\python\daima\DAY10"))
17 #6.若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推（和上面的相反，就是删除目录。）
18 print(os.removedirs("D:\python\daima\DAY10"))
19 #7.生成单级目录；相当于shell中mkdir dirname，如果当前目录已经存在改目录就会报错！
20 print(os.mkdir("DAY10"))
21 #8.删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname,如果当前目录没有改目录就会报错！
22 print(os.rmdir("DAY10"))
23 #9.列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
24 print(os.listdir("D:\python\daima"))
25 #10.删除一个文件
26 # os.remove("locked.txt")
27 #11.重命名文件/目录
28 # os.rename("oldname","newname")
29 #12.os.stat('path/filename') 获取文件/目录信息
30 print(os.stat("D:\python\daima\DAY4"))
31 #13.输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
32 print(os.sep)
33 #14.输出当前平台使用的行终止符，win下为"\r\n",Linux下为"\n"
34 print(os.linesep)
35 #15.输出用于分割文件路径的字符串
36 print(os.pathsep)
37 #16.输出字符串指示当前使用平台。win->'nt'; Linux->'posix'
38 print(os.name)
39 #17.运行shell或者windows命令，直接显示命令的输出结果，可以将这个数据存放在一个变量中哟
40 # print(os.system("dir"))
41 #18.返回path规范化的绝对路径
42 print(os.path.abspath("user_info.txt"))
43 #19.将path分割成目录和文件名二元组返回
44 print(os.path.split(r"D:\python\daima\DAY1\user_info.txt"))
45 #20.返回path的目录。其实就是os.path.split(path)的第一个元素
46 print(os.path.dirname(r"D:\python\daima\DAY1\user_info.txt"))
47 #21.os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
48 print(os.path.basename(r"D:\python\daima\DAY1\user_info.txt"))
49 #22.os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
50 print(os.path.exists(r"D:\python\daima\DAY1\user_info.txt"))
51 #23.os.path.isabs(path) 如果path是绝对路径，返回True
52 print(os.path.isabs(r"D:\python\daima\DAY1\user_info.txt"))
53 #24.os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
54 print(os.path.isfile(r"D:\python\daima\DAY1\user_info.txt"))
55 #25.os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
56 print(os.path.isdir(r"D:\python\daima\DAY1\user_info.txt"))
57 #26.os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
58 print(os.path.join(r"user_info.txt",r"D:\python\daima\DAY1\user_info.txt"))
59 #27.os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
60 print(os.path.getatime(r"D:\python\daima\DAY1\user_info.txt"))
61 #28.os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
62 print(os.path.getmtime(r"D:\python\daima\DAY1\user_info.txt"))
63 '''
64 更多关于os模块的使用方法请参考：https://docs.python.org/2/library/os.html?highlight=os#module-os
65 '''
66
67
68 #以上代码执行结果如下：
69 D:\python\daima\DAY4
70 None
71 .
72 ..
73 None
74 None
75 None
76 None
77 ['.idea', 'DAY1', 'DAY2', 'DAY3', 'DAY4', 'DAY5', '__pycache__']
78 os.stat_result(st_mode=16895, st_ino=22799473113577966, st_dev=839182139, st_nlink=1, st_uid=0, st_gid=0, st_size=4096, st_atime=1487743397, st_mtime=1487743397, st_ctime=1486692902)
79 \
80
81
82 ;
83 nt
84 D:\python\daima\DAY1\user_info.txt
85 ('D:\\python\\daima\\DAY1', 'user_info.txt')
86 D:\python\daima\DAY1
87 user_info.txt
88 True
89 True
90 True
91 False
92 D:\python\daima\DAY1\user_info.txt
93 1483869109.7747889
94 1483869109.7758367
2.sys模块常用方法
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import sys
7 #1.获取Python解释程序的版本信息
8 print(sys.version)
9 #2.返回操作系统平台名称
10 print(sys.platform)
11 #3.返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
12 print(sys.path)
13 #4.退出程序，正常退出时exit(0),如果不写数字的话，默认就是0
14 # print(sys.exit(100))
15 #5.命令行参数List，第一个元素是程序本身路径
16 # path_info = sys.argv[1]
17 #6.显示当前系统最大的Int值
18 print(sys.maxsize)
19
20 '''
21 更多使用方法请参考：https://docs.python.org/2/library/sys.html?highlight=sys#module-sys
22 '''
23
24
25 #以上代码执行结果如下：
26
27 3.5.2 (v3.5.2:4def2a2901a5, Jun 25 2016, 22:01:18) [MSC v.1900 32 bit (Intel)]
28 win32
29 ['D:\\python\\daima\\DAY4', 'D:\\python\\daima', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\python35.zip', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\DLLs', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\lib', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32', 'C:\\Users\\yzj\\AppData\\Local\\Programs\\Python\\Python35-32\\lib\\site-packages']
30 2147483647
3.json和pickle模块详解
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import pickle
7 '''
8 pickle:
9 1.>用于python特有的类型 和 python的数据类型间进行转换
10 2.>pickle模块提供了四个功能：dumps、dump、loads、load.
11 补充说明：将数据通过特殊的形式转换成只有python解释器识别的字符串，这个过程我们叫做序列化，而把哪些python能够识别的字符串转换成我们能看懂的叫做反序列化。
12 '''
13 data_info = {"name":"尹正杰","password":"123"}
14 #1.将数据通过特殊的形式转换为只有python语言知识的字符串并写入文件
15 # pickle_str = pickle.dumps(data_info)
16 # print(pickle_str)
17 # f = open("test.txt","wb")
18 # f.write(pickle_str)
19 #2.上面的写入文件的方法也可以这么玩,看起来更简单
20 # with open("test_1.txt","wb") as fb:
21 # pickle.dump(data_info,fb)
22 #我们知道将数据存入文件，那么我们怎么把存入文件的东西读出来呢？
23 #方法一：
24 # f = open("test_1.txt","rb")
25 # print(pickle.loads(f.read()))
26 #方法二:
27 f = open("test_1.txt","rb")
28 print(pickle.load(f))
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import json
7 '''
8 用于序列化的两个模块
9 1>.json:用于字符串 和 python数据类型间进行转换
10 2>.pickle:用于python特有的类型和python的数据类型间进行转换
11 json模块提供了四个功能：dumps、dump、loads、load
12 pickle模块提供了四个功能：dumps、dump、loads、load
13 '''
14 accounts = {
15 "id":521,
16 "name":"yinzhengjie",
17 "banlance":"9000"
18 }
19 #存数据方式一：
20 # f = open(r"D:\python\daima\DAY4\test_2.txt","w")
21 # json_str = json.dumps(accounts)
22 # f.write(json_str)
23 #存数据方式二：
24 # with open(r"D:\python\daima\DAY4\test_2.txt","w") as fp:
25 # json.dump(accounts,fp)
26 #读取数据的方法一：
27 # f = open("test_2.txt","r")
28 # print(json.loads(f.read()))
29 #方法二:
30 f = open("test_2.txt","r")
31 print(json.load(f))
对比json和pickle的异同：
1>.相同点：都是用于系列化和反序列化的模块。
2>.不同点：json是在所有语言都通用的数据存储格式，而pickle是仅仅只有python语言独有的存储格式。
4.time模块与datetime模块详解
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import time
7 #1.测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来
8 print(time.process_time())
9 #2.返回与utc时间的时间差,以秒计算
10 print(time.altzone)
11 #3.返回默认时间格式
12 print(time.asctime())
13 #4.返回本地时间的struct_time对象格式
14 print(time.localtime())
15 #5.返回utc时间的struc时间对象格式
16 print(time.gmtime(time.time()-800000))
17 #6.返回本地时间格式，
18 print(time.asctime(time.localtime()))
19 #7.返回时间格式，同上
20 print(time.ctime())
21 #8.将日期字符串转成struct时间对象格式
22 string_2_struct = time.strptime("2016/05/22","%Y/%m/%d")
23 print(string_2_struct)
24 #9.将struct时间对象转成时间戳
25 struct_2_stamp = time.mktime(string_2_struct)
26 print(struct_2_stamp)
27 #10.将utc时间戳转换成struct_time格式
28 print(time.gmtime(time.time()-86640))
29 #11.将utc struct_time格式转成指定的字符串格式
30 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import time,datetime
7 #1.打印当前系统时间
8 print(datetime.datetime.now())
9 #2.时间戳直接转成日期格式如：2017-02-22
10 print(datetime.date.fromtimestamp(time.time()))
11 #3.当前时间+3天
12 print(datetime.datetime.now() + datetime.timedelta(3))
13 #4.当前时间-3天
14 print(datetime.datetime.now() + datetime.timedelta(-3))
15 #5.当前时间+3小时
16 print(datetime.datetime.now() + datetime.timedelta(hours=3))
17 #6.当前时间+30分
18 print(datetime.datetime.now() + datetime.timedelta(minutes=30))
19 #7.时间替换
20 c_time = datetime.datetime.now()
21 print(c_time.replace(minute=3,hour=2))
关于时间的一个转换流程图：
测试代码如下：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import time
7 #1.将日期转换成struct_time格式，会以一个tuple的形式打印出来
8 # struct_time = time.strptime("2017/2/22","%Y/%m/%d") #注意分割的符号要保持一致哟，我这里分割的符号是“/”
9 struct_time = time.strptime("2017-2-22 17:29:30","%Y-%m-%d %H:%M:%S") #ye ky 注意分割的符号要保持一致哟，我这里分割的符号是“-”
10 print(struct_time)
11 #2.将struct_time格式转换成时间戳的形式
12 stamp_time = time.mktime(struct_time)
13 print(stamp_time)
14 #3.将时间戳的形式，转换成日期格式
15 date_time = time.gmtime(stamp_time)
16 print(date_time)
17 print(time.strftime("%Y-%m-%d %H:%M:%S",date_time))
关于参数的详细说明如下：
| Directive | Meaning | Notes |
|---|---|---|
%a |
Locale’s abbreviated weekday name. | |
%A |
Locale’s full weekday name. | |
%b |
Locale’s abbreviated month name. | |
%B |
Locale’s full month name. | |
%c |
Locale’s appropriate date and time representation. | |
%d |
Day of the month as a decimal number [01,31]. | |
%H |
Hour (24-hour clock) as a decimal number [00,23]. | |
%I |
Hour (12-hour clock) as a decimal number [01,12]. | |
%j |
Day of the year as a decimal number [001,366]. | |
%m |
Month as a decimal number [01,12]. | |
%M |
Minute as a decimal number [00,59]. | |
%p |
Locale’s equivalent of either AM or PM. | (1) |
%S |
Second as a decimal number [00,61]. | (2) |
%U |
Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0. | (3) |
%w |
Weekday as a decimal number [0(Sunday),6]. | |
%W |
Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0. | (3) |
%x |
Locale’s appropriate date representation. | |
%X |
Locale’s appropriate time representation. | |
%y |
Year without century as a decimal number [00,99]. | |
%Y |
Year with century as a decimal number. | |
%z |
Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59]. | |
%Z |
Time zone name (no characters if no time zone exists). | |
%% |
A literal '%' character. |
5.random模块详解
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import random
7 '''
8 random：
9 是用来生成随机数字的。
10 '''
11 #举例子：
12 print(random.random())
13 print(random.randint(1,20))
14 print(random.randrange(1,10))
15 '''
16 random 都有哪些应用呢？
17 '''
18 #生成随机验证码，版本一：
19 checkcode = ''
20 for i in range(6): #修改后面的数字表示随机生成的数字个数，因为要循环6次
21 current = random.randrange(0,4)
22 if current != i:
23 temp = chr(random.randint(65,90))
24 else:
25 temp = random.randint(0,9)
26 checkcode += str(temp)
27 print(checkcode)
28 #生成随机验证码，版本二
29 import string
30 source = string.digits + string.ascii_lowercase
31 print("".join(random.sample(source,6))) #修改后面的数字表示随机生成的数字个数
6.logging模块
很多程序都有记录日志的需求，并且日志中包含的信息即有正常的程序访问日志，还可能有错误、警告等信息输出，python的logging模块提供了标准的日志接口，你可以通过它存储各种格式的日志，logging的日志可以分为 debug(), info(), warning(), error() and critical() 5个级别，从左往右依次增加告警级别，下面我们看一下怎么用。
看一下这几个日志级别分别代表什么意思
| Level | When it’s used |
|---|---|
DEBUG |
Detailed information, typically of interest only when diagnosing problems. |
INFO |
Confirmation that things are working as expected. |
WARNING |
An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected. |
ERROR |
Due to a more serious problem, the software has not been able to perform some function. |
CRITICAL |
A serious error, indicating that the program itself may be unable to continue running. |
日志格式
%(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 |
用户输出的消息 |
A.简单的logging模块案例演示：
1>.初探logging模块:
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import logging
7 logging.warning("user [尹正杰] attempted wrong password more than 3 times")
8 logging.critical("server is down")
9
10
11 以上代码执行结果如下：
12 WARNING:root:user [尹正杰] attempted wrong password more than 3 times
13 CRITICAL:root:server is down
2>.如果想把日志写到文件里，也很简单:
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import logging
7 logging.basicConfig(filename='yinzhengjie.log', level=logging.INFO)
8 logging.debug('This message should go to the log file')
9 logging.info('So should this')
10 logging.warning('And this, too')
11
12 '''
13 补充说明：
14 logging.basicConfig中的参数level=loggin.INFO意思是，把日志纪录级别设置为INFO，也就是说，只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里，在这个例子，第一条日志是不会被纪录的，如果希望纪录debug的日志，那把日志级别改成DEBUG就行了。
15 '''
16
17
18 #查看'yinzhengjie.log'文件内容如下：
19 INFO:root:So should this
20 WARNING:root:And this, too
B.如果想同时把log打印在屏幕和文件日志里，就需要了解一点复杂的知识了：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 '''
7 Python使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：
8 1>.logger提供了应用程序可以直接使用的接口；
9 2>.handler将(logger创建的)日志记录发送到合适的目的输出；
10 3>.filter提供了细度设备来决定输出哪条日志记录；
11 4>.formatter决定日志记录的最终输出格式。
12 '''
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 '''
7 Python使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：
8 1>.logger提供了应用程序可以直接使用的接口；
9 2>.handler将(logger创建的)日志记录发送到合适的目的输出；
10 3>.filter提供了细度设备来决定输出哪条日志记录；
11 4>.formatter决定日志记录的最终输出格式。
12 '''
13
14
15 #logger
16 '''
17 每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名.
18 #1>.比如聊天工具的图形界面模块可以这样获得它的Logger：
19 LOG=logging.getLogger(”chat.gui”)
20 #2>.而核心模块可以这样：
21 LOG=logging.getLogger(”chat.kernel”)
22 #3>.指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
23 Logger.setLevel(lel)
24 #4>.添加或删除指定的filter
25 Logger.addFilter(filt)、Logger.removeFilter(filt)
26 #5>.增加或删除指定的handler
27 Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)
28 #6>.可以设置的日志级别
29 Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()
30 '''
31
32
33 #handler
34 '''
35 handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
36 #1>.指定被处理的信息级别，低于lel级别的信息将被忽略
37 Handler.setLevel(lel)
38 #2>.给这个handler选择一个格式
39 Handler.setFormatter()
40 #3>.新增或删除一个filter对象
41 Handler.addFilter(filt)、Handler.removeFilter(filt)
42 每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
43 #1>.logging.StreamHandler
44 使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：StreamHandler([strm]),其中strm参数是一个文件对象。默认是sys.stderr
45 2) logging.FileHandler
46 和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：FileHandler(filename[,mode]),filename是文件名，必须指定一个文件名。mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。
47 3) logging.handlers.RotatingFileHandler
48 这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建 一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把 文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]]),其中filename和mode两个参数和FileHandler一样。maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。
49 4) logging.handlers.TimedRotatingFileHandler
50 这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就 自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]]),其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义,interval是时间间隔。when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：(S[秒],M[分],H[小时],D[天],W[每星期（interval==0时代表星期一）],midnight[每天凌晨]
51 '''
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import logging
7 # create logger
8 logger = logging.getLogger('TEST-LOG') #定义报警的标题
9 logger.setLevel(logging.DEBUG) #设置在屏幕中打印的报警级别和写入文件的文件的最低级别这个相当于总开关，下面2个调试都得在这基础之上对告警级别做处理。
10 # create console handler and set level to debug
11 ch = logging.StreamHandler()
12 ch.setLevel(logging.DEBUG) #设置在屏幕中打印的报警级别，（优先权没有第一个权限高）
13 # create file handler and set level to warning #创建文件处理程序并设置告警级别。
14 fh = logging.FileHandler("access.log") #定义保存日志的文件
15 fh.setLevel(logging.WARNING) #定义将报警信息写入文件中的级别（优先权没有第一个权限高））
16 # create formatter #定义输出格式
17 formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
18 # add formatter to ch and fh #添加格式花输出
19 ch.setFormatter(formatter)
20 fh.setFormatter(formatter)
21 # add ch and fh to logger #添加记录器
22 logger.addHandler(ch)
23 logger.addHandler(fh)
24 # 'application' code #定义各种报警级别输出的内容。
25 logger.debug('debug message')
26 logger.info('info message')
27 logger.warn('warn message')
28 logger.error('error message')
29 logger.critical('critical message')
30
31 #屏幕输入内容如下：
32 2017-02-23 10:08:28,184 - TEST-LOG - DEBUG - debug message
33 2017-02-23 10:08:28,185 - TEST-LOG - INFO - info message
34 2017-02-23 10:08:28,185 - TEST-LOG - WARNING - warn message
35 2017-02-23 10:08:28,185 - TEST-LOG - ERROR - error message
36 2017-02-23 10:08:28,185 - TEST-LOG - CRITICAL - critical message
37
38
39 #文件存入内容如下：
40 2017-02-23 10:08:28,185 - TEST-LOG - WARNING - warn message
41 2017-02-23 10:08:28,185 - TEST-LOG - ERROR - error message
42 2017-02-23 10:08:28,185 - TEST-LOG - CRITICAL - critical message
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import logging
7 from logging import handlers
8 logger = logging.getLogger(__name__)
9 log_file = "timelog.log"
10 #fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
11 fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3) #filename定义将信息输入到指定的文件，when指定单位是s(秒),interval是时间间隔的频率,单位是when所指定的哟（所以，你可以理解频率是5s）；backupCount表示备份的文件个数，我这里是指定的3个文件。
12 formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s') #定义输出格式
13 fh.setFormatter(formatter) #添加格式化输出
14 logger.addHandler(fh)
15 logger.warning("test1")
16 logger.warning("test2")
17 logger.warning("test3")
18 logger.warning("test4")
7.shutil模块3
改模块可以处理高级的 文件、文件夹、压缩包
1>.将文件内容拷贝到另一个文件中，可以部分内容
1 def copyfileobj(fsrc, fdst, length=16*1024): #需要制定一个源文件，目标文件，以及每次读取的长度.
2 """copy data from file-like object fsrc to file-like object fdst"""
3 while 1:
4 buf = fsrc.read(length)
5 if not buf:
6 break
7 fdst.write(buf)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 f_1 = open("file_1","r+",encoding="utf-8")
8 f_2 = open("file_2","a+",encoding="utf-8") #如果这里是“r+”的方式打开的话那么在下面调用copyfileobj函数的时候，这个文件会被重定向的哟！（也就是之前的内容会被覆盖掉）
9 shutil.copyfileobj(f_1,f_2) #将f_1文件的内容追加到f_2文件中.
2>.拷贝文件
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def copyfile(src, dst):
7 """Copy data from src to dst"""
8 if _samefile(src, dst):
9 raise Error("`%s` and `%s` are the same file" % (src, dst))
10
11 for fn in [src, dst]:
12 try:
13 st = os.stat(fn)
14 except OSError:
15 # File most likely does not exist
16 pass
17 else:
18 # XXX What about other special files? (sockets, devices...)
19 if stat.S_ISFIFO(st.st_mode):
20 raise SpecialFileError("`%s` is a named pipe" % fn)
21
22 with open(src, 'rb') as fsrc:
23 with open(dst, 'wb') as fdst:
24 copyfileobj(fsrc, fdst)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.copyfile("file_1","file_2") #直接写源文件和目标文件，不需要像上面那样费劲的打开一个文件了，如果没有文件就创建一个，如果有的话就会直接覆盖源文件的内容有哟
3>.仅拷贝权限。内容、组、用户均不变
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def copymode(src, dst):
7 """Copy mode bits from src to dst"""
8 if hasattr(os, 'chmod'):
9 st = os.stat(src)
10 mode = stat.S_IMODE(st.st_mode)
11 os.chmod(dst, mode)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.copymode("file_1","file_3") #首先，这2个文件必须存在，仅仅拷贝的是权限！要注意哟！
4>.拷贝状态的信息，包括：mode bits, atime, mtime, flags
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def copystat(src, dst):
7 """Copy all stat info (mode bits, atime, mtime, flags) from src to dst"""
8 st = os.stat(src)
9 mode = stat.S_IMODE(st.st_mode)
10 if hasattr(os, 'utime'):
11 os.utime(dst, (st.st_atime, st.st_mtime))
12 if hasattr(os, 'chmod'):
13 os.chmod(dst, mode)
14 if hasattr(os, 'chflags') and hasattr(st, 'st_flags'):
15 try:
16 os.chflags(dst, st.st_flags)
17 except OSError, why:
18 for err in 'EOPNOTSUPP', 'ENOTSUP':
19 if hasattr(errno, err) and why.errno == getattr(errno, err):
20 break
21 else:
22 raise
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.copystat("file_1","file_3") #将前面的状态信息拷贝给后面的文件。
5>.拷贝文件和权限
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def copy(src, dst):
7 """Copy data and mode bits ("cp src dst").
8
9 The destination may be a directory.
10
11 """
12 if os.path.isdir(dst):
13 dst = os.path.join(dst, os.path.basename(src))
14 copyfile(src, dst)
15 copymode(src, dst)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.copy("file_1","file_11") #这个就是拷贝一个的内容还有权限一起拷贝
6>.拷贝文件和状态信息
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def copy2(src, dst):
7 """Copy data and all stat info ("cp -p src dst").
8
9 The destination may be a directory.
10
11 """
12 if os.path.isdir(dst):
13 dst = os.path.join(dst, os.path.basename(src))
14 copyfile(src, dst)
15 copystat(src, dst)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.copy2("file_1","file_22") #这个就是拷贝一个的内容还有状态信息也一并拷贝
7>.递归的去拷贝文件
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def ignore_patterns(*patterns):
7 """Function that can be used as copytree() ignore parameter.
8
9 Patterns is a sequence of glob-style patterns
10 that are used to exclude files"""
11 def _ignore_patterns(path, names):
12 ignored_names = []
13 for pattern in patterns:
14 ignored_names.extend(fnmatch.filter(names, pattern))
15 return set(ignored_names)
16 return _ignore_patterns
17
18 def copytree(src, dst, symlinks=False, ignore=None):
19 """Recursively copy a directory tree using copy2().
20
21 The destination directory must not already exist.
22 If exception(s) occur, an Error is raised with a list of reasons.
23
24 If the optional symlinks flag is true, symbolic links in the
25 source tree result in symbolic links in the destination tree; if
26 it is false, the contents of the files pointed to by symbolic
27 links are copied.
28
29 The optional ignore argument is a callable. If given, it
30 is called with the `src` parameter, which is the directory
31 being visited by copytree(), and `names` which is the list of
32 `src` contents, as returned by os.listdir():
33
34 callable(src, names) -> ignored_names
35
36 Since copytree() is called recursively, the callable will be
37 called once for each directory that is copied. It returns a
38 list of names relative to the `src` directory that should
39 not be copied.
40
41 XXX Consider this example code rather than the ultimate tool.
42
43 """
44 names = os.listdir(src)
45 if ignore is not None:
46 ignored_names = ignore(src, names)
47 else:
48 ignored_names = set()
49
50 os.makedirs(dst)
51 errors = []
52 for name in names:
53 if name in ignored_names:
54 continue
55 srcname = os.path.join(src, name)
56 dstname = os.path.join(dst, name)
57 try:
58 if symlinks and os.path.islink(srcname):
59 linkto = os.readlink(srcname)
60 os.symlink(linkto, dstname)
61 elif os.path.isdir(srcname):
62 copytree(srcname, dstname, symlinks, ignore)
63 else:
64 # Will raise a SpecialFileError for unsupported file types
65 copy2(srcname, dstname)
66 # catch the Error from the recursive copytree so that we can
67 # continue with other files
68 except Error, err:
69 errors.extend(err.args[0])
70 except EnvironmentError, why:
71 errors.append((srcname, dstname, str(why)))
72 try:
73 copystat(src, dst)
74 except OSError, why:
75 if WindowsError is not None and isinstance(why, WindowsError):
76 # Copying file access times may fail on Windows
77 pass
78 else:
79 errors.append((src, dst, str(why)))
80 if errors:
81 raise Error, errors
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.copytree(r"D:\python\daima\DAY5",r"D:\python\daima\DAY6\test",ignore=shutil.ignore_patterns("atm","*.log")) #需要输入原路径，目标路径，利用ignore函数可以对需要拷贝的东西进行过滤，我这里过滤掉源目录中所有的包含“atm”，“*log”关键字的目录或者文件。（换句话说，就是新拷贝的路径中，不包含被过滤掉的文件信息。）
8>.递归的去删除文件
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def rmtree(path, ignore_errors=False, onerror=None):
7 """Recursively delete a directory tree.
8
9 If ignore_errors is set, errors are ignored; otherwise, if onerror
10 is set, it is called to handle the error with arguments (func,
11 path, exc_info) where func is os.listdir, os.remove, or os.rmdir;
12 path is the argument to that function that caused it to fail; and
13 exc_info is a tuple returned by sys.exc_info(). If ignore_errors
14 is false and onerror is None, an exception is raised.
15
16 """
17 if ignore_errors:
18 def onerror(*args):
19 pass
20 elif onerror is None:
21 def onerror(*args):
22 raise
23 try:
24 if os.path.islink(path):
25 # symlinks to directories are forbidden, see bug #1669
26 raise OSError("Cannot call rmtree on a symbolic link")
27 except OSError:
28 onerror(os.path.islink, path, sys.exc_info())
29 # can't continue even if onerror hook returns
30 return
31 names = []
32 try:
33 names = os.listdir(path)
34 except os.error, err:
35 onerror(os.listdir, path, sys.exc_info())
36 for name in names:
37 fullname = os.path.join(path, name)
38 try:
39 mode = os.lstat(fullname).st_mode
40 except os.error:
41 mode = 0
42 if stat.S_ISDIR(mode):
43 rmtree(fullname, ignore_errors, onerror)
44 else:
45 try:
46 os.remove(fullname)
47 except os.error, err:
48 onerror(os.remove, fullname, sys.exc_info())
49 try:
50 os.rmdir(path)
51 except os.error:
52 onerror(os.rmdir, path, sys.exc_info())
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.rmtree(r"D:\python\daima\DAY6\test")
9>.递归的去移动文件
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 def move(src, dst):
7 """Recursively move a file or directory to another location. This is
8 similar to the Unix "mv" command.
9
10 If the destination is a directory or a symlink to a directory, the source
11 is moved inside the directory. The destination path must not already
12 exist.
13
14 If the destination already exists but is not a directory, it may be
15 overwritten depending on os.rename() semantics.
16
17 If the destination is on our current filesystem, then rename() is used.
18 Otherwise, src is copied to the destination and then removed.
19 A lot more could be done here... A look at a mv.c shows a lot of
20 the issues this implementation glosses over.
21
22 """
23 real_dst = dst
24 if os.path.isdir(dst):
25 if _samefile(src, dst):
26 # We might be on a case insensitive filesystem,
27 # perform the rename anyway.
28 os.rename(src, dst)
29 return
30
31 real_dst = os.path.join(dst, _basename(src))
32 if os.path.exists(real_dst):
33 raise Error, "Destination path '%s' already exists" % real_dst
34 try:
35 os.rename(src, real_dst)
36 except OSError:
37 if os.path.isdir(src):
38 if _destinsrc(src, dst):
39 raise Error, "Cannot move a directory '%s' into itself '%s'." % (src, dst)
40 copytree(src, real_dst, symlinks=True)
41 rmtree(src)
42 else:
43 copy2(src, real_dst)
44 os.unlink(src)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.move(r"D:\python\daima\DAY5\atm","D:\python\daima\DAY6") #前面是原路径，后面是默认路径
10>.创建压缩包并返回文件路径，例如：zip、tar(改方法其实质上就是调用的zipfile和tarfile函数的，可以了解一下这2个函数的用法)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shutil
7 shutil.make_archive("day5","zip",r"D:\python\daima\DAY5") #第一个参数需要传入归档后的文件名称，可以指定绝对路径，第二个参数表示打包的类型，tar表示归档不压缩，但是zip表示压缩，我这里用了压缩类型，第三个参数传递的是被被压缩的对象。还可以传递所属者，所属组等等。
8 '''
9 补充：
10 base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
11 如：www =>保存至当前路径
12 如：/Users/yinzhengjie/www =>保存至/Users/yinzhengjie/
13 format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
14 root_dir： 要压缩的文件夹路径（默认当前目录）
15 owner： 用户，默认当前用户
16 group： 组，默认当前组
17 logger： 用于记录日志，通常是logging.Logger对象
18 '''
11>.zipfile用法扩充
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 class ZipFile(object):
7 """ Class with methods to open, read, write, close, list zip files.
8
9 z = ZipFile(file, mode="r", compression=ZIP_STORED, allowZip64=False)
10
11 file: Either the path to the file, or a file-like object.
12 If it is a path, the file will be opened and closed by ZipFile.
13 mode: The mode can be either read "r", write "w" or append "a".
14 compression: ZIP_STORED (no compression) or ZIP_DEFLATED (requires zlib).
15 allowZip64: if True ZipFile will create files with ZIP64 extensions when
16 needed, otherwise it will raise an exception when this would
17 be necessary.
18
19 """
20
21 fp = None # Set here since __del__ checks it
22
23 def __init__(self, file, mode="r", compression=ZIP_STORED, allowZip64=False):
24 """Open the ZIP file with mode read "r", write "w" or append "a"."""
25 if mode not in ("r", "w", "a"):
26 raise RuntimeError('ZipFile() requires mode "r", "w", or "a"')
27
28 if compression == ZIP_STORED:
29 pass
30 elif compression == ZIP_DEFLATED:
31 if not zlib:
32 raise RuntimeError,\
33 "Compression requires the (missing) zlib module"
34 else:
35 raise RuntimeError, "That compression method is not supported"
36
37 self._allowZip64 = allowZip64
38 self._didModify = False
39 self.debug = 0 # Level of printing: 0 through 3
40 self.NameToInfo = {} # Find file info given name
41 self.filelist = [] # List of ZipInfo instances for archive
42 self.compression = compression # Method of compression
43 self.mode = key = mode.replace('b', '')[0]
44 self.pwd = None
45 self._comment = ''
46
47 # Check if we were passed a file-like object
48 if isinstance(file, basestring):
49 self._filePassed = 0
50 self.filename = file
51 modeDict = {'r' : 'rb', 'w': 'wb', 'a' : 'r+b'}
52 try:
53 self.fp = open(file, modeDict[mode])
54 except IOError:
55 if mode == 'a':
56 mode = key = 'w'
57 self.fp = open(file, modeDict[mode])
58 else:
59 raise
60 else:
61 self._filePassed = 1
62 self.fp = file
63 self.filename = getattr(file, 'name', None)
64
65 try:
66 if key == 'r':
67 self._RealGetContents()
68 elif key == 'w':
69 # set the modified flag so central directory gets written
70 # even if no files are added to the archive
71 self._didModify = True
72 elif key == 'a':
73 try:
74 # See if file is a zip file
75 self._RealGetContents()
76 # seek to start of directory and overwrite
77 self.fp.seek(self.start_dir, 0)
78 except BadZipfile:
79 # file is not a zip file, just append
80 self.fp.seek(0, 2)
81
82 # set the modified flag so central directory gets written
83 # even if no files are added to the archive
84 self._didModify = True
85 else:
86 raise RuntimeError('Mode must be "r", "w" or "a"')
87 except:
88 fp = self.fp
89 self.fp = None
90 if not self._filePassed:
91 fp.close()
92 raise
93
94 def __enter__(self):
95 return self
96
97 def __exit__(self, type, value, traceback):
98 self.close()
99
100 def _RealGetContents(self):
101 """Read in the table of contents for the ZIP file."""
102 fp = self.fp
103 try:
104 endrec = _EndRecData(fp)
105 except IOError:
106 raise BadZipfile("File is not a zip file")
107 if not endrec:
108 raise BadZipfile, "File is not a zip file"
109 if self.debug > 1:
110 print endrec
111 size_cd = endrec[_ECD_SIZE] # bytes in central directory
112 offset_cd = endrec[_ECD_OFFSET] # offset of central directory
113 self._comment = endrec[_ECD_COMMENT] # archive comment
114
115 # "concat" is zero, unless zip was concatenated to another file
116 concat = endrec[_ECD_LOCATION] - size_cd - offset_cd
117 if endrec[_ECD_SIGNATURE] == stringEndArchive64:
118 # If Zip64 extension structures are present, account for them
119 concat -= (sizeEndCentDir64 + sizeEndCentDir64Locator)
120
121 if self.debug > 2:
122 inferred = concat + offset_cd
123 print "given, inferred, offset", offset_cd, inferred, concat
124 # self.start_dir: Position of start of central directory
125 self.start_dir = offset_cd + concat
126 fp.seek(self.start_dir, 0)
127 data = fp.read(size_cd)
128 fp = cStringIO.StringIO(data)
129 total = 0
130 while total < size_cd:
131 centdir = fp.read(sizeCentralDir)
132 if len(centdir) != sizeCentralDir:
133 raise BadZipfile("Truncated central directory")
134 centdir = struct.unpack(structCentralDir, centdir)
135 if centdir[_CD_SIGNATURE] != stringCentralDir:
136 raise BadZipfile("Bad magic number for central directory")
137 if self.debug > 2:
138 print centdir
139 filename = fp.read(centdir[_CD_FILENAME_LENGTH])
140 # Create ZipInfo instance to store file information
141 x = ZipInfo(filename)
142 x.extra = fp.read(centdir[_CD_EXTRA_FIELD_LENGTH])
143 x.comment = fp.read(centdir[_CD_COMMENT_LENGTH])
144 x.header_offset = centdir[_CD_LOCAL_HEADER_OFFSET]
145 (x.create_version, x.create_system, x.extract_version, x.reserved,
146 x.flag_bits, x.compress_type, t, d,
147 x.CRC, x.compress_size, x.file_size) = centdir[1:12]
148 x.volume, x.internal_attr, x.external_attr = centdir[15:18]
149 # Convert date/time code to (year, month, day, hour, min, sec)
150 x._raw_time = t
151 x.date_time = ( (d>>9)+1980, (d>>5)&0xF, d&0x1F,
152 t>>11, (t>>5)&0x3F, (t&0x1F) * 2 )
153
154 x._decodeExtra()
155 x.header_offset = x.header_offset + concat
156 x.filename = x._decodeFilename()
157 self.filelist.append(x)
158 self.NameToInfo[x.filename] = x
159
160 # update total bytes read from central directory
161 total = (total + sizeCentralDir + centdir[_CD_FILENAME_LENGTH]
162 + centdir[_CD_EXTRA_FIELD_LENGTH]
163 + centdir[_CD_COMMENT_LENGTH])
164
165 if self.debug > 2:
166 print "total", total
167
168
169 def namelist(self):
170 """Return a list of file names in the archive."""
171 l = []
172 for data in self.filelist:
173 l.append(data.filename)
174 return l
175
176 def infolist(self):
177 """Return a list of class ZipInfo instances for files in the
178 archive."""
179 return self.filelist
180
181 def printdir(self):
182 """Print a table of contents for the zip file."""
183 print "%-46s %19s %12s" % ("File Name", "Modified ", "Size")
184 for zinfo in self.filelist:
185 date = "%d-%02d-%02d %02d:%02d:%02d" % zinfo.date_time[:6]
186 print "%-46s %s %12d" % (zinfo.filename, date, zinfo.file_size)
187
188 def testzip(self):
189 """Read all the files and check the CRC."""
190 chunk_size = 2 ** 20
191 for zinfo in self.filelist:
192 try:
193 # Read by chunks, to avoid an OverflowError or a
194 # MemoryError with very large embedded files.
195 with self.open(zinfo.filename, "r") as f:
196 while f.read(chunk_size): # Check CRC-32
197 pass
198 except BadZipfile:
199 return zinfo.filename
200
201 def getinfo(self, name):
202 """Return the instance of ZipInfo given 'name'."""
203 info = self.NameToInfo.get(name)
204 if info is None:
205 raise KeyError(
206 'There is no item named %r in the archive' % name)
207
208 return info
209
210 def setpassword(self, pwd):
211 """Set default password for encrypted files."""
212 self.pwd = pwd
213
214 @property
215 def comment(self):
216 """The comment text associated with the ZIP file."""
217 return self._comment
218
219 @comment.setter
220 def comment(self, comment):
221 # check for valid comment length
222 if len(comment) > ZIP_MAX_COMMENT:
223 import warnings
224 warnings.warn('Archive comment is too long; truncating to %d bytes'
225 % ZIP_MAX_COMMENT, stacklevel=2)
226 comment = comment[:ZIP_MAX_COMMENT]
227 self._comment = comment
228 self._didModify = True
229
230 def read(self, name, pwd=None):
231 """Return file bytes (as a string) for name."""
232 return self.open(name, "r", pwd).read()
233
234 def open(self, name, mode="r", pwd=None):
235 """Return file-like object for 'name'."""
236 if mode not in ("r", "U", "rU"):
237 raise RuntimeError, 'open() requires mode "r", "U", or "rU"'
238 if not self.fp:
239 raise RuntimeError, \
240 "Attempt to read ZIP archive that was already closed"
241
242 # Only open a new file for instances where we were not
243 # given a file object in the constructor
244 if self._filePassed:
245 zef_file = self.fp
246 should_close = False
247 else:
248 zef_file = open(self.filename, 'rb')
249 should_close = True
250
251 try:
252 # Make sure we have an info object
253 if isinstance(name, ZipInfo):
254 # 'name' is already an info object
255 zinfo = name
256 else:
257 # Get info object for name
258 zinfo = self.getinfo(name)
259
260 zef_file.seek(zinfo.header_offset, 0)
261
262 # Skip the file header:
263 fheader = zef_file.read(sizeFileHeader)
264 if len(fheader) != sizeFileHeader:
265 raise BadZipfile("Truncated file header")
266 fheader = struct.unpack(structFileHeader, fheader)
267 if fheader[_FH_SIGNATURE] != stringFileHeader:
268 raise BadZipfile("Bad magic number for file header")
269
270 fname = zef_file.read(fheader[_FH_FILENAME_LENGTH])
271 if fheader[_FH_EXTRA_FIELD_LENGTH]:
272 zef_file.read(fheader[_FH_EXTRA_FIELD_LENGTH])
273
274 if fname != zinfo.orig_filename:
275 raise BadZipfile, \
276 'File name in directory "%s" and header "%s" differ.' % (
277 zinfo.orig_filename, fname)
278
279 # check for encrypted flag & handle password
280 is_encrypted = zinfo.flag_bits & 0x1
281 zd = None
282 if is_encrypted:
283 if not pwd:
284 pwd = self.pwd
285 if not pwd:
286 raise RuntimeError, "File %s is encrypted, " \
287 "password required for extraction" % name
288
289 zd = _ZipDecrypter(pwd)
290 # The first 12 bytes in the cypher stream is an encryption header
291 # used to strengthen the algorithm. The first 11 bytes are
292 # completely random, while the 12th contains the MSB of the CRC,
293 # or the MSB of the file time depending on the header type
294 # and is used to check the correctness of the password.
295 bytes = zef_file.read(12)
296 h = map(zd, bytes[0:12])
297 if zinfo.flag_bits & 0x8:
298 # compare against the file type from extended local headers
299 check_byte = (zinfo._raw_time >> 8) & 0xff
300 else:
301 # compare against the CRC otherwise
302 check_byte = (zinfo.CRC >> 24) & 0xff
303 if ord(h[11]) != check_byte:
304 raise RuntimeError("Bad password for file", name)
305
306 return ZipExtFile(zef_file, mode, zinfo, zd,
307 close_fileobj=should_close)
308 except:
309 if should_close:
310 zef_file.close()
311 raise
312
313 def extract(self, member, path=None, pwd=None):
314 """Extract a member from the archive to the current working directory,
315 using its full name. Its file information is extracted as accurately
316 as possible. `member' may be a filename or a ZipInfo object. You can
317 specify a different directory using `path'.
318 """
319 if not isinstance(member, ZipInfo):
320 member = self.getinfo(member)
321
322 if path is None:
323 path = os.getcwd()
324
325 return self._extract_member(member, path, pwd)
326
327 def extractall(self, path=None, members=None, pwd=None):
328 """Extract all members from the archive to the current working
329 directory. `path' specifies a different directory to extract to.
330 `members' is optional and must be a subset of the list returned
331 by namelist().
332 """
333 if members is None:
334 members = self.namelist()
335
336 for zipinfo in members:
337 self.extract(zipinfo, path, pwd)
338
339 def _extract_member(self, member, targetpath, pwd):
340 """Extract the ZipInfo object 'member' to a physical
341 file on the path targetpath.
342 """
343 # build the destination pathname, replacing
344 # forward slashes to platform specific separators.
345 arcname = member.filename.replace('/', os.path.sep)
346
347 if os.path.altsep:
348 arcname = arcname.replace(os.path.altsep, os.path.sep)
349 # interpret absolute pathname as relative, remove drive letter or
350 # UNC path, redundant separators, "." and ".." components.
351 arcname = os.path.splitdrive(arcname)[1]
352 arcname = os.path.sep.join(x for x in arcname.split(os.path.sep)
353 if x not in ('', os.path.curdir, os.path.pardir))
354 if os.path.sep == '\\':
355 # filter illegal characters on Windows
356 illegal = ':<>|"?*'
357 if isinstance(arcname, unicode):
358 table = {ord(c): ord('_') for c in illegal}
359 else:
360 table = string.maketrans(illegal, '_' * len(illegal))
361 arcname = arcname.translate(table)
362 # remove trailing dots
363 arcname = (x.rstrip('.') for x in arcname.split(os.path.sep))
364 arcname = os.path.sep.join(x for x in arcname if x)
365
366 targetpath = os.path.join(targetpath, arcname)
367 targetpath = os.path.normpath(targetpath)
368
369 # Create all upper directories if necessary.
370 upperdirs = os.path.dirname(targetpath)
371 if upperdirs and not os.path.exists(upperdirs):
372 os.makedirs(upperdirs)
373
374 if member.filename[-1] == '/':
375 if not os.path.isdir(targetpath):
376 os.mkdir(targetpath)
377 return targetpath
378
379 with self.open(member, pwd=pwd) as source, \
380 file(targetpath, "wb") as target:
381 shutil.copyfileobj(source, target)
382
383 return targetpath
384
385 def _writecheck(self, zinfo):
386 """Check for errors before writing a file to the archive."""
387 if zinfo.filename in self.NameToInfo:
388 import warnings
389 warnings.warn('Duplicate name: %r' % zinfo.filename, stacklevel=3)
390 if self.mode not in ("w", "a"):
391 raise RuntimeError, 'write() requires mode "w" or "a"'
392 if not self.fp:
393 raise RuntimeError, \
394 "Attempt to write ZIP archive that was already closed"
395 if zinfo.compress_type == ZIP_DEFLATED and not zlib:
396 raise RuntimeError, \
397 "Compression requires the (missing) zlib module"
398 if zinfo.compress_type not in (ZIP_STORED, ZIP_DEFLATED):
399 raise RuntimeError, \
400 "That compression method is not supported"
401 if not self._allowZip64:
402 requires_zip64 = None
403 if len(self.filelist) >= ZIP_FILECOUNT_LIMIT:
404 requires_zip64 = "Files count"
405 elif zinfo.file_size > ZIP64_LIMIT:
406 requires_zip64 = "Filesize"
407 elif zinfo.header_offset > ZIP64_LIMIT:
408 requires_zip64 = "Zipfile size"
409 if requires_zip64:
410 raise LargeZipFile(requires_zip64 +
411 " would require ZIP64 extensions")
412
413 def write(self, filename, arcname=None, compress_type=None):
414 """Put the bytes from filename into the archive under the name
415 arcname."""
416 if not self.fp:
417 raise RuntimeError(
418 "Attempt to write to ZIP archive that was already closed")
419
420 st = os.stat(filename)
421 isdir = stat.S_ISDIR(st.st_mode)
422 mtime = time.localtime(st.st_mtime)
423 date_time = mtime[0:6]
424 # Create ZipInfo instance to store file information
425 if arcname is None:
426 arcname = filename
427 arcname = os.path.normpath(os.path.splitdrive(arcname)[1])
428 while arcname[0] in (os.sep, os.altsep):
429 arcname = arcname[1:]
430 if isdir:
431 arcname += '/'
432 zinfo = ZipInfo(arcname, date_time)
433 zinfo.external_attr = (st[0] & 0xFFFF) << 16L # Unix attributes
434 if compress_type is None:
435 zinfo.compress_type = self.compression
436 else:
437 zinfo.compress_type = compress_type
438
439 zinfo.file_size = st.st_size
440 zinfo.flag_bits = 0x00
441 zinfo.header_offset = self.fp.tell() # Start of header bytes
442
443 self._writecheck(zinfo)
444 self._didModify = True
445
446 if isdir:
447 zinfo.file_size = 0
448 zinfo.compress_size = 0
449 zinfo.CRC = 0
450 zinfo.external_attr |= 0x10 # MS-DOS directory flag
451 self.filelist.append(zinfo)
452 self.NameToInfo[zinfo.filename] = zinfo
453 self.fp.write(zinfo.FileHeader(False))
454 return
455
456 with open(filename, "rb") as fp:
457 # Must overwrite CRC and sizes with correct data later
458 zinfo.CRC = CRC = 0
459 zinfo.compress_size = compress_size = 0
460 # Compressed size can be larger than uncompressed size
461 zip64 = self._allowZip64 and \
462 zinfo.file_size * 1.05 > ZIP64_LIMIT
463 self.fp.write(zinfo.FileHeader(zip64))
464 if zinfo.compress_type == ZIP_DEFLATED:
465 cmpr = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
466 zlib.DEFLATED, -15)
467 else:
468 cmpr = None
469 file_size = 0
470 while 1:
471 buf = fp.read(1024 * 8)
472 if not buf:
473 break
474 file_size = file_size + len(buf)
475 CRC = crc32(buf, CRC) & 0xffffffff
476 if cmpr:
477 buf = cmpr.compress(buf)
478 compress_size = compress_size + len(buf)
479 self.fp.write(buf)
480 if cmpr:
481 buf = cmpr.flush()
482 compress_size = compress_size + len(buf)
483 self.fp.write(buf)
484 zinfo.compress_size = compress_size
485 else:
486 zinfo.compress_size = file_size
487 zinfo.CRC = CRC
488 zinfo.file_size = file_size
489 if not zip64 and self._allowZip64:
490 if file_size > ZIP64_LIMIT:
491 raise RuntimeError('File size has increased during compressing')
492 if compress_size > ZIP64_LIMIT:
493 raise RuntimeError('Compressed size larger than uncompressed size')
494 # Seek backwards and write file header (which will now include
495 # correct CRC and file sizes)
496 position = self.fp.tell() # Preserve current position in file
497 self.fp.seek(zinfo.header_offset, 0)
498 self.fp.write(zinfo.FileHeader(zip64))
499 self.fp.seek(position, 0)
500 self.filelist.append(zinfo)
501 self.NameToInfo[zinfo.filename] = zinfo
502
503 def writestr(self, zinfo_or_arcname, bytes, compress_type=None):
504 """Write a file into the archive. The contents is the string
505 'bytes'. 'zinfo_or_arcname' is either a ZipInfo instance or
506 the name of the file in the archive."""
507 if not isinstance(zinfo_or_arcname, ZipInfo):
508 zinfo = ZipInfo(filename=zinfo_or_arcname,
509 date_time=time.localtime(time.time())[:6])
510
511 zinfo.compress_type = self.compression
512 if zinfo.filename[-1] == '/':
513 zinfo.external_attr = 0o40775 << 16 # drwxrwxr-x
514 zinfo.external_attr |= 0x10 # MS-DOS directory flag
515 else:
516 zinfo.external_attr = 0o600 << 16 # ?rw-------
517 else:
518 zinfo = zinfo_or_arcname
519
520 if not self.fp:
521 raise RuntimeError(
522 "Attempt to write to ZIP archive that was already closed")
523
524 if compress_type is not None:
525 zinfo.compress_type = compress_type
526
527 zinfo.file_size = len(bytes) # Uncompressed size
528 zinfo.header_offset = self.fp.tell() # Start of header bytes
529 self._writecheck(zinfo)
530 self._didModify = True
531 zinfo.CRC = crc32(bytes) & 0xffffffff # CRC-32 checksum
532 if zinfo.compress_type == ZIP_DEFLATED:
533 co = zlib.compressobj(zlib.Z_DEFAULT_COMPRESSION,
534 zlib.DEFLATED, -15)
535 bytes = co.compress(bytes) + co.flush()
536 zinfo.compress_size = len(bytes) # Compressed size
537 else:
538 zinfo.compress_size = zinfo.file_size
539 zip64 = zinfo.file_size > ZIP64_LIMIT or \
540 zinfo.compress_size > ZIP64_LIMIT
541 if zip64 and not self._allowZip64:
542 raise LargeZipFile("Filesize would require ZIP64 extensions")
543 self.fp.write(zinfo.FileHeader(zip64))
544 self.fp.write(bytes)
545 if zinfo.flag_bits & 0x08:
546 # Write CRC and file sizes after the file data
547 fmt = '<LQQ' if zip64 else '<LLL'
548 self.fp.write(struct.pack(fmt, zinfo.CRC, zinfo.compress_size,
549 zinfo.file_size))
550 self.fp.flush()
551 self.filelist.append(zinfo)
552 self.NameToInfo[zinfo.filename] = zinfo
553
554 def __del__(self):
555 """Call the "close()" method in case the user forgot."""
556 self.close()
557
558 def close(self):
559 """Close the file, and for mode "w" and "a" write the ending
560 records."""
561 if self.fp is None:
562 return
563
564 try:
565 if self.mode in ("w", "a") and self._didModify: # write ending records
566 pos1 = self.fp.tell()
567 for zinfo in self.filelist: # write central directory
568 dt = zinfo.date_time
569 dosdate = (dt[0] - 1980) << 9 | dt[1] << 5 | dt[2]
570 dostime = dt[3] << 11 | dt[4] << 5 | (dt[5] // 2)
571 extra = []
572 if zinfo.file_size > ZIP64_LIMIT \
573 or zinfo.compress_size > ZIP64_LIMIT:
574 extra.append(zinfo.file_size)
575 extra.append(zinfo.compress_size)
576 file_size = 0xffffffff
577 compress_size = 0xffffffff
578 else:
579 file_size = zinfo.file_size
580 compress_size = zinfo.compress_size
581
582 if zinfo.header_offset > ZIP64_LIMIT:
583 extra.append(zinfo.header_offset)
584 header_offset = 0xffffffffL
585 else:
586 header_offset = zinfo.header_offset
587
588 extra_data = zinfo.extra
589 if extra:
590 # Append a ZIP64 field to the extra's
591 extra_data = struct.pack(
592 '<HH' + 'Q'*len(extra),
593 1, 8*len(extra), *extra) + extra_data
594
595 extract_version = max(45, zinfo.extract_version)
596 create_version = max(45, zinfo.create_version)
597 else:
598 extract_version = zinfo.extract_version
599 create_version = zinfo.create_version
600
601 try:
602 filename, flag_bits = zinfo._encodeFilenameFlags()
603 centdir = struct.pack(structCentralDir,
604 stringCentralDir, create_version,
605 zinfo.create_system, extract_version, zinfo.reserved,
606 flag_bits, zinfo.compress_type, dostime, dosdate,
607 zinfo.CRC, compress_size, file_size,
608 len(filename), len(extra_data), len(zinfo.comment),
609 0, zinfo.internal_attr, zinfo.external_attr,
610 header_offset)
611 except DeprecationWarning:
612 print >>sys.stderr, (structCentralDir,
613 stringCentralDir, create_version,
614 zinfo.create_system, extract_version, zinfo.reserved,
615 zinfo.flag_bits, zinfo.compress_type, dostime, dosdate,
616 zinfo.CRC, compress_size, file_size,
617 len(zinfo.filename), len(extra_data), len(zinfo.comment),
618 0, zinfo.internal_attr, zinfo.external_attr,
619 header_offset)
620 raise
621 self.fp.write(centdir)
622 self.fp.write(filename)
623 self.fp.write(extra_data)
624 self.fp.write(zinfo.comment)
625
626 pos2 = self.fp.tell()
627 # Write end-of-zip-archive record
628 centDirCount = len(self.filelist)
629 centDirSize = pos2 - pos1
630 centDirOffset = pos1
631 requires_zip64 = None
632 if centDirCount > ZIP_FILECOUNT_LIMIT:
633 requires_zip64 = "Files count"
634 elif centDirOffset > ZIP64_LIMIT:
635 requires_zip64 = "Central directory offset"
636 elif centDirSize > ZIP64_LIMIT:
637 requires_zip64 = "Central directory size"
638 if requires_zip64:
639 # Need to write the ZIP64 end-of-archive records
640 if not self._allowZip64:
641 raise LargeZipFile(requires_zip64 +
642 " would require ZIP64 extensions")
643 zip64endrec = struct.pack(
644 structEndArchive64, stringEndArchive64,
645 44, 45, 45, 0, 0, centDirCount, centDirCount,
646 centDirSize, centDirOffset)
647 self.fp.write(zip64endrec)
648
649 zip64locrec = struct.pack(
650 structEndArchive64Locator,
651 stringEndArchive64Locator, 0, pos2, 1)
652 self.fp.write(zip64locrec)
653 centDirCount = min(centDirCount, 0xFFFF)
654 centDirSize = min(centDirSize, 0xFFFFFFFF)
655 centDirOffset = min(centDirOffset, 0xFFFFFFFF)
656
657 endrec = struct.pack(structEndArchive, stringEndArchive,
658 0, 0, centDirCount, centDirCount,
659 centDirSize, centDirOffset, len(self._comment))
660 self.fp.write(endrec)
661 self.fp.write(self._comment)
662 self.fp.flush()
663 finally:
664 fp = self.fp
665 self.fp = None
666 if not self._filePassed:
667 fp.close()
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import zipfile
7 z = zipfile.ZipFile("ziptest.zip","w") #创建一个叫”ziptest.zip“的压缩文件
8 z.write(r"D:\python\daima\DAY5\README",arcname="README") #将该文件放入到”ziptest.zip“的压缩文件中,后面的arcname参数的意思是指压缩这个文件的即可，不用压缩这个文件的所在的绝对路径。如果不加这个参数的话，会把该文件的当前位置的绝对路径都一起压缩了
9 z.write(r"D:\python\daima\DAY3\modify.txt",arcname="modify.txt") #同上
10 z.write("day5.zip") #将当前路径的文件压缩到”ziptest.zip“的压缩文件中
11 z.close() #关闭压缩文件，这个时候就可以将文件存入进去了。
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import zipfile
7 z = zipfile.ZipFile("ziptest.zip","r")
8 z.extract("README") #进行解压一个叫“README”的文件
9 z.extractall(path=r"D:\python\daima\DAY5\test_1") #将z这个压缩包的内容全部解压出来，path表示执行解压后的存放路径
10 z.extractall(members=["modify.txt"]) #表示将z这个压缩包全部解压出来，出了列表中的文件，注意不支持模糊匹配哟！
11 z.close()
12>.tarfile用法扩充
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 class TarFile(object):
7 """The TarFile Class provides an interface to tar archives.
8 """
9
10 debug = 0 # May be set from 0 (no msgs) to 3 (all msgs)
11
12 dereference = False # If true, add content of linked file to the
13 # tar file, else the link.
14
15 ignore_zeros = False # If true, skips empty or invalid blocks and
16 # continues processing.
17
18 errorlevel = 1 # If 0, fatal errors only appear in debug
19 # messages (if debug >= 0). If > 0, errors
20 # are passed to the caller as exceptions.
21
22 format = DEFAULT_FORMAT # The format to use when creating an archive.
23
24 encoding = ENCODING # Encoding for 8-bit character strings.
25
26 errors = None # Error handler for unicode conversion.
27
28 tarinfo = TarInfo # The default TarInfo class to use.
29
30 fileobject = ExFileObject # The default ExFileObject class to use.
31
32 def __init__(self, name=None, mode="r", fileobj=None, format=None,
33 tarinfo=None, dereference=None, ignore_zeros=None, encoding=None,
34 errors=None, pax_headers=None, debug=None, errorlevel=None):
35 """Open an (uncompressed) tar archive `name'. `mode' is either 'r' to
36 read from an existing archive, 'a' to append data to an existing
37 file or 'w' to create a new file overwriting an existing one. `mode'
38 defaults to 'r'.
39 If `fileobj' is given, it is used for reading or writing data. If it
40 can be determined, `mode' is overridden by `fileobj's mode.
41 `fileobj' is not closed, when TarFile is closed.
42 """
43 modes = {"r": "rb", "a": "r+b", "w": "wb"}
44 if mode not in modes:
45 raise ValueError("mode must be 'r', 'a' or 'w'")
46 self.mode = mode
47 self._mode = modes[mode]
48
49 if not fileobj:
50 if self.mode == "a" and not os.path.exists(name):
51 # Create nonexistent files in append mode.
52 self.mode = "w"
53 self._mode = "wb"
54 fileobj = bltn_open(name, self._mode)
55 self._extfileobj = False
56 else:
57 if name is None and hasattr(fileobj, "name"):
58 name = fileobj.name
59 if hasattr(fileobj, "mode"):
60 self._mode = fileobj.mode
61 self._extfileobj = True
62 self.name = os.path.abspath(name) if name else None
63 self.fileobj = fileobj
64
65 # Init attributes.
66 if format is not None:
67 self.format = format
68 if tarinfo is not None:
69 self.tarinfo = tarinfo
70 if dereference is not None:
71 self.dereference = dereference
72 if ignore_zeros is not None:
73 self.ignore_zeros = ignore_zeros
74 if encoding is not None:
75 self.encoding = encoding
76
77 if errors is not None:
78 self.errors = errors
79 elif mode == "r":
80 self.errors = "utf-8"
81 else:
82 self.errors = "strict"
83
84 if pax_headers is not None and self.format == PAX_FORMAT:
85 self.pax_headers = pax_headers
86 else:
87 self.pax_headers = {}
88
89 if debug is not None:
90 self.debug = debug
91 if errorlevel is not None:
92 self.errorlevel = errorlevel
93
94 # Init datastructures.
95 self.closed = False
96 self.members = [] # list of members as TarInfo objects
97 self._loaded = False # flag if all members have been read
98 self.offset = self.fileobj.tell()
99 # current position in the archive file
100 self.inodes = {} # dictionary caching the inodes of
101 # archive members already added
102
103 try:
104 if self.mode == "r":
105 self.firstmember = None
106 self.firstmember = self.next()
107
108 if self.mode == "a":
109 # Move to the end of the archive,
110 # before the first empty block.
111 while True:
112 self.fileobj.seek(self.offset)
113 try:
114 tarinfo = self.tarinfo.fromtarfile(self)
115 self.members.append(tarinfo)
116 except EOFHeaderError:
117 self.fileobj.seek(self.offset)
118 break
119 except HeaderError, e:
120 raise ReadError(str(e))
121
122 if self.mode in "aw":
123 self._loaded = True
124
125 if self.pax_headers:
126 buf = self.tarinfo.create_pax_global_header(self.pax_headers.copy())
127 self.fileobj.write(buf)
128 self.offset += len(buf)
129 except:
130 if not self._extfileobj:
131 self.fileobj.close()
132 self.closed = True
133 raise
134
135 def _getposix(self):
136 return self.format == USTAR_FORMAT
137 def _setposix(self, value):
138 import warnings
139 warnings.warn("use the format attribute instead", DeprecationWarning,
140 2)
141 if value:
142 self.format = USTAR_FORMAT
143 else:
144 self.format = GNU_FORMAT
145 posix = property(_getposix, _setposix)
146
147 #--------------------------------------------------------------------------
148 # Below are the classmethods which act as alternate constructors to the
149 # TarFile class. The open() method is the only one that is needed for
150 # public use; it is the "super"-constructor and is able to select an
151 # adequate "sub"-constructor for a particular compression using the mapping
152 # from OPEN_METH.
153 #
154 # This concept allows one to subclass TarFile without losing the comfort of
155 # the super-constructor. A sub-constructor is registered and made available
156 # by adding it to the mapping in OPEN_METH.
157
158 @classmethod
159 def open(cls, name=None, mode="r", fileobj=None, bufsize=RECORDSIZE, **kwargs):
160 """Open a tar archive for reading, writing or appending. Return
161 an appropriate TarFile class.
162
163 mode:
164 'r' or 'r:*' open for reading with transparent compression
165 'r:' open for reading exclusively uncompressed
166 'r:gz' open for reading with gzip compression
167 'r:bz2' open for reading with bzip2 compression
168 'a' or 'a:' open for appending, creating the file if necessary
169 'w' or 'w:' open for writing without compression
170 'w:gz' open for writing with gzip compression
171 'w:bz2' open for writing with bzip2 compression
172
173 'r|*' open a stream of tar blocks with transparent compression
174 'r|' open an uncompressed stream of tar blocks for reading
175 'r|gz' open a gzip compressed stream of tar blocks
176 'r|bz2' open a bzip2 compressed stream of tar blocks
177 'w|' open an uncompressed stream for writing
178 'w|gz' open a gzip compressed stream for writing
179 'w|bz2' open a bzip2 compressed stream for writing
180 """
181
182 if not name and not fileobj:
183 raise ValueError("nothing to open")
184
185 if mode in ("r", "r:*"):
186 # Find out which *open() is appropriate for opening the file.
187 for comptype in cls.OPEN_METH:
188 func = getattr(cls, cls.OPEN_METH[comptype])
189 if fileobj is not None:
190 saved_pos = fileobj.tell()
191 try:
192 return func(name, "r", fileobj, **kwargs)
193 except (ReadError, CompressionError), e:
194 if fileobj is not None:
195 fileobj.seek(saved_pos)
196 continue
197 raise ReadError("file could not be opened successfully")
198
199 elif ":" in mode:
200 filemode, comptype = mode.split(":", 1)
201 filemode = filemode or "r"
202 comptype = comptype or "tar"
203
204 # Select the *open() function according to
205 # given compression.
206 if comptype in cls.OPEN_METH:
207 func = getattr(cls, cls.OPEN_METH[comptype])
208 else:
209 raise CompressionError("unknown compression type %r" % comptype)
210 return func(name, filemode, fileobj, **kwargs)
211
212 elif "|" in mode:
213 filemode, comptype = mode.split("|", 1)
214 filemode = filemode or "r"
215 comptype = comptype or "tar"
216
217 if filemode not in ("r", "w"):
218 raise ValueError("mode must be 'r' or 'w'")
219
220 stream = _Stream(name, filemode, comptype, fileobj, bufsize)
221 try:
222 t = cls(name, filemode, stream, **kwargs)
223 except:
224 stream.close()
225 raise
226 t._extfileobj = False
227 return t
228
229 elif mode in ("a", "w"):
230 return cls.taropen(name, mode, fileobj, **kwargs)
231
232 raise ValueError("undiscernible mode")
233
234 @classmethod
235 def taropen(cls, name, mode="r", fileobj=None, **kwargs):
236 """Open uncompressed tar archive name for reading or writing.
237 """
238 if mode not in ("r", "a", "w"):
239 raise ValueError("mode must be 'r', 'a' or 'w'")
240 return cls(name, mode, fileobj, **kwargs)
241
242 @classmethod
243 def gzopen(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
244 """Open gzip compressed tar archive name for reading or writing.
245 Appending is not allowed.
246 """
247 if mode not in ("r", "w"):
248 raise ValueError("mode must be 'r' or 'w'")
249
250 try:
251 import gzip
252 gzip.GzipFile
253 except (ImportError, AttributeError):
254 raise CompressionError("gzip module is not available")
255
256 try:
257 fileobj = gzip.GzipFile(name, mode, compresslevel, fileobj)
258 except OSError:
259 if fileobj is not None and mode == 'r':
260 raise ReadError("not a gzip file")
261 raise
262
263 try:
264 t = cls.taropen(name, mode, fileobj, **kwargs)
265 except IOError:
266 fileobj.close()
267 if mode == 'r':
268 raise ReadError("not a gzip file")
269 raise
270 except:
271 fileobj.close()
272 raise
273 t._extfileobj = False
274 return t
275
276 @classmethod
277 def bz2open(cls, name, mode="r", fileobj=None, compresslevel=9, **kwargs):
278 """Open bzip2 compressed tar archive name for reading or writing.
279 Appending is not allowed.
280 """
281 if mode not in ("r", "w"):
282 raise ValueError("mode must be 'r' or 'w'.")
283
284 try:
285 import bz2
286 except ImportError:
287 raise CompressionError("bz2 module is not available")
288
289 if fileobj is not None:
290 fileobj = _BZ2Proxy(fileobj, mode)
291 else:
292 fileobj = bz2.BZ2File(name, mode, compresslevel=compresslevel)
293
294 try:
295 t = cls.taropen(name, mode, fileobj, **kwargs)
296 except (IOError, EOFError):
297 fileobj.close()
298 if mode == 'r':
299 raise ReadError("not a bzip2 file")
300 raise
301 except:
302 fileobj.close()
303 raise
304 t._extfileobj = False
305 return t
306
307 # All *open() methods are registered here.
308 OPEN_METH = {
309 "tar": "taropen", # uncompressed tar
310 "gz": "gzopen", # gzip compressed tar
311 "bz2": "bz2open" # bzip2 compressed tar
312 }
313
314 #--------------------------------------------------------------------------
315 # The public methods which TarFile provides:
316
317 def close(self):
318 """Close the TarFile. In write-mode, two finishing zero blocks are
319 appended to the archive.
320 """
321 if self.closed:
322 return
323
324 if self.mode in "aw":
325 self.fileobj.write(NUL * (BLOCKSIZE * 2))
326 self.offset += (BLOCKSIZE * 2)
327 # fill up the end with zero-blocks
328 # (like option -b20 for tar does)
329 blocks, remainder = divmod(self.offset, RECORDSIZE)
330 if remainder > 0:
331 self.fileobj.write(NUL * (RECORDSIZE - remainder))
332
333 if not self._extfileobj:
334 self.fileobj.close()
335 self.closed = True
336
337 def getmember(self, name):
338 """Return a TarInfo object for member `name'. If `name' can not be
339 found in the archive, KeyError is raised. If a member occurs more
340 than once in the archive, its last occurrence is assumed to be the
341 most up-to-date version.
342 """
343 tarinfo = self._getmember(name)
344 if tarinfo is None:
345 raise KeyError("filename %r not found" % name)
346 return tarinfo
347
348 def getmembers(self):
349 """Return the members of the archive as a list of TarInfo objects. The
350 list has the same order as the members in the archive.
351 """
352 self._check()
353 if not self._loaded: # if we want to obtain a list of
354 self._load() # all members, we first have to
355 # scan the whole archive.
356 return self.members
357
358 def getnames(self):
359 """Return the members of the archive as a list of their names. It has
360 the same order as the list returned by getmembers().
361 """
362 return [tarinfo.name for tarinfo in self.getmembers()]
363
364 def gettarinfo(self, name=None, arcname=None, fileobj=None):
365 """Create a TarInfo object for either the file `name' or the file
366 object `fileobj' (using os.fstat on its file descriptor). You can
367 modify some of the TarInfo's attributes before you add it using
368 addfile(). If given, `arcname' specifies an alternative name for the
369 file in the archive.
370 """
371 self._check("aw")
372
373 # When fileobj is given, replace name by
374 # fileobj's real name.
375 if fileobj is not None:
376 name = fileobj.name
377
378 # Building the name of the member in the archive.
379 # Backward slashes are converted to forward slashes,
380 # Absolute paths are turned to relative paths.
381 if arcname is None:
382 arcname = name
383 drv, arcname = os.path.splitdrive(arcname)
384 arcname = arcname.replace(os.sep, "/")
385 arcname = arcname.lstrip("/")
386
387 # Now, fill the TarInfo object with
388 # information specific for the file.
389 tarinfo = self.tarinfo()
390 tarinfo.tarfile = self
391
392 # Use os.stat or os.lstat, depending on platform
393 # and if symlinks shall be resolved.
394 if fileobj is None:
395 if hasattr(os, "lstat") and not self.dereference:
396 statres = os.lstat(name)
397 else:
398 statres = os.stat(name)
399 else:
400 statres = os.fstat(fileobj.fileno())
401 linkname = ""
402
403 stmd = statres.st_mode
404 if stat.S_ISREG(stmd):
405 inode = (statres.st_ino, statres.st_dev)
406 if not self.dereference and statres.st_nlink > 1 and \
407 inode in self.inodes and arcname != self.inodes[inode]:
408 # Is it a hardlink to an already
409 # archived file?
410 type = LNKTYPE
411 linkname = self.inodes[inode]
412 else:
413 # The inode is added only if its valid.
414 # For win32 it is always 0.
415 type = REGTYPE
416 if inode[0]:
417 self.inodes[inode] = arcname
418 elif stat.S_ISDIR(stmd):
419 type = DIRTYPE
420 elif stat.S_ISFIFO(stmd):
421 type = FIFOTYPE
422 elif stat.S_ISLNK(stmd):
423 type = SYMTYPE
424 linkname = os.readlink(name)
425 elif stat.S_ISCHR(stmd):
426 type = CHRTYPE
427 elif stat.S_ISBLK(stmd):
428 type = BLKTYPE
429 else:
430 return None
431
432 # Fill the TarInfo object with all
433 # information we can get.
434 tarinfo.name = arcname
435 tarinfo.mode = stmd
436 tarinfo.uid = statres.st_uid
437 tarinfo.gid = statres.st_gid
438 if type == REGTYPE:
439 tarinfo.size = statres.st_size
440 else:
441 tarinfo.size = 0L
442 tarinfo.mtime = statres.st_mtime
443 tarinfo.type = type
444 tarinfo.linkname = linkname
445 if pwd:
446 try:
447 tarinfo.uname = pwd.getpwuid(tarinfo.uid)[0]
448 except KeyError:
449 pass
450 if grp:
451 try:
452 tarinfo.gname = grp.getgrgid(tarinfo.gid)[0]
453 except KeyError:
454 pass
455
456 if type in (CHRTYPE, BLKTYPE):
457 if hasattr(os, "major") and hasattr(os, "minor"):
458 tarinfo.devmajor = os.major(statres.st_rdev)
459 tarinfo.devminor = os.minor(statres.st_rdev)
460 return tarinfo
461
462 def list(self, verbose=True):
463 """Print a table of contents to sys.stdout. If `verbose' is False, only
464 the names of the members are printed. If it is True, an `ls -l'-like
465 output is produced.
466 """
467 self._check()
468
469 for tarinfo in self:
470 if verbose:
471 print filemode(tarinfo.mode),
472 print "%s/%s" % (tarinfo.uname or tarinfo.uid,
473 tarinfo.gname or tarinfo.gid),
474 if tarinfo.ischr() or tarinfo.isblk():
475 print "%10s" % ("%d,%d" \
476 % (tarinfo.devmajor, tarinfo.devminor)),
477 else:
478 print "%10d" % tarinfo.size,
479 print "%d-%02d-%02d %02d:%02d:%02d" \
480 % time.localtime(tarinfo.mtime)[:6],
481
482 print tarinfo.name + ("/" if tarinfo.isdir() else ""),
483
484 if verbose:
485 if tarinfo.issym():
486 print "->", tarinfo.linkname,
487 if tarinfo.islnk():
488 print "link to", tarinfo.linkname,
489 print
490
491 def add(self, name, arcname=None, recursive=True, exclude=None, filter=None):
492 """Add the file `name' to the archive. `name' may be any type of file
493 (directory, fifo, symbolic link, etc.). If given, `arcname'
494 specifies an alternative name for the file in the archive.
495 Directories are added recursively by default. This can be avoided by
496 setting `recursive' to False. `exclude' is a function that should
497 return True for each filename to be excluded. `filter' is a function
498 that expects a TarInfo object argument and returns the changed
499 TarInfo object, if it returns None the TarInfo object will be
500 excluded from the archive.
501 """
502 self._check("aw")
503
504 if arcname is None:
505 arcname = name
506
507 # Exclude pathnames.
508 if exclude is not None:
509 import warnings
510 warnings.warn("use the filter argument instead",
511 DeprecationWarning, 2)
512 if exclude(name):
513 self._dbg(2, "tarfile: Excluded %r" % name)
514 return
515
516 # Skip if somebody tries to archive the archive...
517 if self.name is not None and os.path.abspath(name) == self.name:
518 self._dbg(2, "tarfile: Skipped %r" % name)
519 return
520
521 self._dbg(1, name)
522
523 # Create a TarInfo object from the file.
524 tarinfo = self.gettarinfo(name, arcname)
525
526 if tarinfo is None:
527 self._dbg(1, "tarfile: Unsupported type %r" % name)
528 return
529
530 # Change or exclude the TarInfo object.
531 if filter is not None:
532 tarinfo = filter(tarinfo)
533 if tarinfo is None:
534 self._dbg(2, "tarfile: Excluded %r" % name)
535 return
536
537 # Append the tar header and data to the archive.
538 if tarinfo.isreg():
539 with bltn_open(name, "rb") as f:
540 self.addfile(tarinfo, f)
541
542 elif tarinfo.isdir():
543 self.addfile(tarinfo)
544 if recursive:
545 for f in os.listdir(name):
546 self.add(os.path.join(name, f), os.path.join(arcname, f),
547 recursive, exclude, filter)
548
549 else:
550 self.addfile(tarinfo)
551
552 def addfile(self, tarinfo, fileobj=None):
553 """Add the TarInfo object `tarinfo' to the archive. If `fileobj' is
554 given, tarinfo.size bytes are read from it and added to the archive.
555 You can create TarInfo objects using gettarinfo().
556 On Windows platforms, `fileobj' should always be opened with mode
557 'rb' to avoid irritation about the file size.
558 """
559 self._check("aw")
560
561 tarinfo = copy.copy(tarinfo)
562
563 buf = tarinfo.tobuf(self.format, self.encoding, self.errors)
564 self.fileobj.write(buf)
565 self.offset += len(buf)
566
567 # If there's data to follow, append it.
568 if fileobj is not None:
569 copyfileobj(fileobj, self.fileobj, tarinfo.size)
570 blocks, remainder = divmod(tarinfo.size, BLOCKSIZE)
571 if remainder > 0:
572 self.fileobj.write(NUL * (BLOCKSIZE - remainder))
573 blocks += 1
574 self.offset += blocks * BLOCKSIZE
575
576 self.members.append(tarinfo)
577
578 def extractall(self, path=".", members=None):
579 """Extract all members from the archive to the current working
580 directory and set owner, modification time and permissions on
581 directories afterwards. `path' specifies a different directory
582 to extract to. `members' is optional and must be a subset of the
583 list returned by getmembers().
584 """
585 directories = []
586
587 if members is None:
588 members = self
589
590 for tarinfo in members:
591 if tarinfo.isdir():
592 # Extract directories with a safe mode.
593 directories.append(tarinfo)
594 tarinfo = copy.copy(tarinfo)
595 tarinfo.mode = 0700
596 self.extract(tarinfo, path)
597
598 # Reverse sort directories.
599 directories.sort(key=operator.attrgetter('name'))
600 directories.reverse()
601
602 # Set correct owner, mtime and filemode on directories.
603 for tarinfo in directories:
604 dirpath = os.path.join(path, tarinfo.name)
605 try:
606 self.chown(tarinfo, dirpath)
607 self.utime(tarinfo, dirpath)
608 self.chmod(tarinfo, dirpath)
609 except ExtractError, e:
610 if self.errorlevel > 1:
611 raise
612 else:
613 self._dbg(1, "tarfile: %s" % e)
614
615 def extract(self, member, path=""):
616 """Extract a member from the archive to the current working directory,
617 using its full name. Its file information is extracted as accurately
618 as possible. `member' may be a filename or a TarInfo object. You can
619 specify a different directory using `path'.
620 """
621 self._check("r")
622
623 if isinstance(member, basestring):
624 tarinfo = self.getmember(member)
625 else:
626 tarinfo = member
627
628 # Prepare the link target for makelink().
629 if tarinfo.islnk():
630 tarinfo._link_target = os.path.join(path, tarinfo.linkname)
631
632 try:
633 self._extract_member(tarinfo, os.path.join(path, tarinfo.name))
634 except EnvironmentError, e:
635 if self.errorlevel > 0:
636 raise
637 else:
638 if e.filename is None:
639 self._dbg(1, "tarfile: %s" % e.strerror)
640 else:
641 self._dbg(1, "tarfile: %s %r" % (e.strerror, e.filename))
642 except ExtractError, e:
643 if self.errorlevel > 1:
644 raise
645 else:
646 self._dbg(1, "tarfile: %s" % e)
647
648 def extractfile(self, member):
649 """Extract a member from the archive as a file object. `member' may be
650 a filename or a TarInfo object. If `member' is a regular file, a
651 file-like object is returned. If `member' is a link, a file-like
652 object is constructed from the link's target. If `member' is none of
653 the above, None is returned.
654 The file-like object is read-only and provides the following
655 methods: read(), readline(), readlines(), seek() and tell()
656 """
657 self._check("r")
658
659 if isinstance(member, basestring):
660 tarinfo = self.getmember(member)
661 else:
662 tarinfo = member
663
664 if tarinfo.isreg():
665 return self.fileobject(self, tarinfo)
666
667 elif tarinfo.type not in SUPPORTED_TYPES:
668 # If a member's type is unknown, it is treated as a
669 # regular file.
670 return self.fileobject(self, tarinfo)
671
672 elif tarinfo.islnk() or tarinfo.issym():
673 if isinstance(self.fileobj, _Stream):
674 # A small but ugly workaround for the case that someone tries
675 # to extract a (sym)link as a file-object from a non-seekable
676 # stream of tar blocks.
677 raise StreamError("cannot extract (sym)link as file object")
678 else:
679 # A (sym)link's file object is its target's file object.
680 return self.extractfile(self._find_link_target(tarinfo))
681 else:
682 # If there's no data associated with the member (directory, chrdev,
683 # blkdev, etc.), return None instead of a file object.
684 return None
685
686 def _extract_member(self, tarinfo, targetpath):
687 """Extract the TarInfo object tarinfo to a physical
688 file called targetpath.
689 """
690 # Fetch the TarInfo object for the given name
691 # and build the destination pathname, replacing
692 # forward slashes to platform specific separators.
693 targetpath = targetpath.rstrip("/")
694 targetpath = targetpath.replace("/", os.sep)
695
696 # Create all upper directories.
697 upperdirs = os.path.dirname(targetpath)
698 if upperdirs and not os.path.exists(upperdirs):
699 # Create directories that are not part of the archive with
700 # default permissions.
701 os.makedirs(upperdirs)
702
703 if tarinfo.islnk() or tarinfo.issym():
704 self._dbg(1, "%s -> %s" % (tarinfo.name, tarinfo.linkname))
705 else:
706 self._dbg(1, tarinfo.name)
707
708 if tarinfo.isreg():
709 self.makefile(tarinfo, targetpath)
710 elif tarinfo.isdir():
711 self.makedir(tarinfo, targetpath)
712 elif tarinfo.isfifo():
713 self.makefifo(tarinfo, targetpath)
714 elif tarinfo.ischr() or tarinfo.isblk():
715 self.makedev(tarinfo, targetpath)
716 elif tarinfo.islnk() or tarinfo.issym():
717 self.makelink(tarinfo, targetpath)
718 elif tarinfo.type not in SUPPORTED_TYPES:
719 self.makeunknown(tarinfo, targetpath)
720 else:
721 self.makefile(tarinfo, targetpath)
722
723 self.chown(tarinfo, targetpath)
724 if not tarinfo.issym():
725 self.chmod(tarinfo, targetpath)
726 self.utime(tarinfo, targetpath)
727
728 #--------------------------------------------------------------------------
729 # Below are the different file methods. They are called via
730 # _extract_member() when extract() is called. They can be replaced in a
731 # subclass to implement other functionality.
732
733 def makedir(self, tarinfo, targetpath):
734 """Make a directory called targetpath.
735 """
736 try:
737 # Use a safe mode for the directory, the real mode is set
738 # later in _extract_member().
739 os.mkdir(targetpath, 0700)
740 except EnvironmentError, e:
741 if e.errno != errno.EEXIST:
742 raise
743
744 def makefile(self, tarinfo, targetpath):
745 """Make a file called targetpath.
746 """
747 source = self.extractfile(tarinfo)
748 try:
749 with bltn_open(targetpath, "wb") as target:
750 copyfileobj(source, target)
751 finally:
752 source.close()
753
754 def makeunknown(self, tarinfo, targetpath):
755 """Make a file from a TarInfo object with an unknown type
756 at targetpath.
757 """
758 self.makefile(tarinfo, targetpath)
759 self._dbg(1, "tarfile: Unknown file type %r, " \
760 "extracted as regular file." % tarinfo.type)
761
762 def makefifo(self, tarinfo, targetpath):
763 """Make a fifo called targetpath.
764 """
765 if hasattr(os, "mkfifo"):
766 os.mkfifo(targetpath)
767 else:
768 raise ExtractError("fifo not supported by system")
769
770 def makedev(self, tarinfo, targetpath):
771 """Make a character or block device called targetpath.
772 """
773 if not hasattr(os, "mknod") or not hasattr(os, "makedev"):
774 raise ExtractError("special devices not supported by system")
775
776 mode = tarinfo.mode
777 if tarinfo.isblk():
778 mode |= stat.S_IFBLK
779 else:
780 mode |= stat.S_IFCHR
781
782 os.mknod(targetpath, mode,
783 os.makedev(tarinfo.devmajor, tarinfo.devminor))
784
785 def makelink(self, tarinfo, targetpath):
786 """Make a (symbolic) link called targetpath. If it cannot be created
787 (platform limitation), we try to make a copy of the referenced file
788 instead of a link.
789 """
790 if hasattr(os, "symlink") and hasattr(os, "link"):
791 # For systems that support symbolic and hard links.
792 if tarinfo.issym():
793 if os.path.lexists(targetpath):
794 os.unlink(targetpath)
795 os.symlink(tarinfo.linkname, targetpath)
796 else:
797 # See extract().
798 if os.path.exists(tarinfo._link_target):
799 if os.path.lexists(targetpath):
800 os.unlink(targetpath)
801 os.link(tarinfo._link_target, targetpath)
802 else:
803 self._extract_member(self._find_link_target(tarinfo), targetpath)
804 else:
805 try:
806 self._extract_member(self._find_link_target(tarinfo), targetpath)
807 except KeyError:
808 raise ExtractError("unable to resolve link inside archive")
809
810 def chown(self, tarinfo, targetpath):
811 """Set owner of targetpath according to tarinfo.
812 """
813 if pwd and hasattr(os, "geteuid") and os.geteuid() == 0:
814 # We have to be root to do so.
815 try:
816 g = grp.getgrnam(tarinfo.gname)[2]
817 except KeyError:
818 g = tarinfo.gid
819 try:
820 u = pwd.getpwnam(tarinfo.uname)[2]
821 except KeyError:
822 u = tarinfo.uid
823 try:
824 if tarinfo.issym() and hasattr(os, "lchown"):
825 os.lchown(targetpath, u, g)
826 else:
827 if sys.platform != "os2emx":
828 os.chown(targetpath, u, g)
829 except EnvironmentError, e:
830 raise ExtractError("could not change owner")
831
832 def chmod(self, tarinfo, targetpath):
833 """Set file permissions of targetpath according to tarinfo.
834 """
835 if hasattr(os, 'chmod'):
836 try:
837 os.chmod(targetpath, tarinfo.mode)
838 except EnvironmentError, e:
839 raise ExtractError("could not change mode")
840
841 def utime(self, tarinfo, targetpath):
842 """Set modification time of targetpath according to tarinfo.
843 """
844 if not hasattr(os, 'utime'):
845 return
846 try:
847 os.utime(targetpath, (tarinfo.mtime, tarinfo.mtime))
848 except EnvironmentError, e:
849 raise ExtractError("could not change modification time")
850
851 #--------------------------------------------------------------------------
852 def next(self):
853 """Return the next member of the archive as a TarInfo object, when
854 TarFile is opened for reading. Return None if there is no more
855 available.
856 """
857 self._check("ra")
858 if self.firstmember is not None:
859 m = self.firstmember
860 self.firstmember = None
861 return m
862
863 # Read the next block.
864 self.fileobj.seek(self.offset)
865 tarinfo = None
866 while True:
867 try:
868 tarinfo = self.tarinfo.fromtarfile(self)
869 except EOFHeaderError, e:
870 if self.ignore_zeros:
871 self._dbg(2, "0x%X: %s" % (self.offset, e))
872 self.offset += BLOCKSIZE
873 continue
874 except InvalidHeaderError, e:
875 if self.ignore_zeros:
876 self._dbg(2, "0x%X: %s" % (self.offset, e))
877 self.offset += BLOCKSIZE
878 continue
879 elif self.offset == 0:
880 raise ReadError(str(e))
881 except EmptyHeaderError:
882 if self.offset == 0:
883 raise ReadError("empty file")
884 except TruncatedHeaderError, e:
885 if self.offset == 0:
886 raise ReadError(str(e))
887 except SubsequentHeaderError, e:
888 raise ReadError(str(e))
889 break
890
891 if tarinfo is not None:
892 self.members.append(tarinfo)
893 else:
894 self._loaded = True
895
896 return tarinfo
897
898 #--------------------------------------------------------------------------
899 # Little helper methods:
900
901 def _getmember(self, name, tarinfo=None, normalize=False):
902 """Find an archive member by name from bottom to top.
903 If tarinfo is given, it is used as the starting point.
904 """
905 # Ensure that all members have been loaded.
906 members = self.getmembers()
907
908 # Limit the member search list up to tarinfo.
909 if tarinfo is not None:
910 members = members[:members.index(tarinfo)]
911
912 if normalize:
913 name = os.path.normpath(name)
914
915 for member in reversed(members):
916 if normalize:
917 member_name = os.path.normpath(member.name)
918 else:
919 member_name = member.name
920
921 if name == member_name:
922 return member
923
924 def _load(self):
925 """Read through the entire archive file and look for readable
926 members.
927 """
928 while True:
929 tarinfo = self.next()
930 if tarinfo is None:
931 break
932 self._loaded = True
933
934 def _check(self, mode=None):
935 """Check if TarFile is still open, and if the operation's mode
936 corresponds to TarFile's mode.
937 """
938 if self.closed:
939 raise IOError("%s is closed" % self.__class__.__name__)
940 if mode is not None and self.mode not in mode:
941 raise IOError("bad operation for mode %r" % self.mode)
942
943 def _find_link_target(self, tarinfo):
944 """Find the target member of a symlink or hardlink member in the
945 archive.
946 """
947 if tarinfo.issym():
948 # Always search the entire archive.
949 linkname = "/".join(filter(None, (os.path.dirname(tarinfo.name), tarinfo.linkname)))
950 limit = None
951 else:
952 # Search the archive before the link, because a hard link is
953 # just a reference to an already archived file.
954 linkname = tarinfo.linkname
955 limit = tarinfo
956
957 member = self._getmember(linkname, tarinfo=limit, normalize=True)
958 if member is None:
959 raise KeyError("linkname %r not found" % linkname)
960 return member
961
962 def __iter__(self):
963 """Provide an iterator object.
964 """
965 if self._loaded:
966 return iter(self.members)
967 else:
968 return TarIter(self)
969
970 def _dbg(self, level, msg):
971 """Write debugging output to sys.stderr.
972 """
973 if level <= self.debug:
974 print >> sys.stderr, msg
975
976 def __enter__(self):
977 self._check()
978 return self
979
980 def __exit__(self, type, value, traceback):
981 if type is None:
982 self.close()
983 else:
984 # An exception occurred. We must not call close() because
985 # it would try to write end-of-archive blocks and padding.
986 if not self._extfileobj:
987 self.fileobj.close()
988 self.closed = True
989 # class TarFile
990
991 TarFile
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import tarfile
7 tar = tarfile.open("yinzhengjie.tar","w")
8 tar.add(r"D:\python\daima\DAY5\day5.zip",arcname="day5.zip")
9 tar.add(r"D:\python\daima\DAY3\学生信息.xlsx",arcname="test_11") #相当于将“学生信息.xlsx”这个文件重命名为"test_11"并添加到压缩文件“yinzhengjie.tar”中
10 tar.close()
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import tarfile
7 tar = tarfile.open("yinzhengjie.tar","r") #注意解压的时候，打开的模式应该是"r"，而不是"w"哟!
8 tar.extractall(path=r"D:\python\daima\DAY6\test") #其中的path表示设置的解压后的存放地址
9 tar.close()
8.shelve模块
它是对pickle的上层封装，比pickle用起来更简单，shelve模块是一个简单的k,v将内存数据通过文件持久化的模块，可以持久化任何pickle可支持的python数据格式。
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shelve
7 f = shelve.open('shelve_test') # 打开一个文件
8 class Test(object):
9 def __init__(self, n):
10 self.n = n
11 def func():
12 print("my name is yinzhengjie!")
13 t = Test(123)
14 name = ["yinzhengjie", "lijing", "test"]
15 f["first"] = name # 序列化列表
16 f["second"] = t # 序列化类，注意只是序列化的类名，如果想要在新的操作系统中调用的话，需要导入哟！
17 f["third"] = func #序列化函数，注意只是序列化的函数名，如果想要在新的操作系统中调用的话，需要导入哟！
18 f.close()
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import shelve
7 f = shelve.open('shelve_test')
8 for i in f.keys():
9 print(i)
10 print(f.get("first")) #相当于load，取得里面的数据，但是如果要读取类或者函数的话需要导入相应的模块哟！
11
12
13 #以上代码执行结果如下：
14 first
15 second
16 third
17 ['yinzhengjie', 'lijing', 'test']
9.xml模块
xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。
xml的格式如下，就是通过<>节点来区别数据结构的:
1 <?xml version="1.0"?>
2 <data>
3 <country name="Liechtenstein">
4 <rank updated="yes">2</rank>
5 <year>2008</year>
6 <gdppc>141100</gdppc>
7 <neighbor name="Austria" direction="E"/>
8 <neighbor name="Switzerland" direction="W"/>
9 <hotspots>
10 <test1>维也纳</test1>
11 <test2>萨尔斯堡</test2>
12 </hotspots>
13 </country>
14 <country name="Singapore">
15 <rank updated="yes">5</rank>
16 <year>2011</year>
17 <gdppc>59900</gdppc>
18 <neighbor name="Malaysia" direction="N"/>
19 </country>
20 <country name="Panama">
21 <rank updated="yes">69</rank>
22 <year>2011</year>
23 <gdppc>13600</gdppc>
24 <neighbor name="Costa Rica" direction="W"/>
25 <neighbor name="Colombia" direction="E"/>
26 </country>
27 </data>
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import xml.etree.ElementTree as ET
7 tree = ET.parse("xmltest.xml") #解析（可以理解为打开一个文件）
8 root = tree.getroot() #找到根节点
9 print(root.tag) #打印根节点的名字
10 # 遍历xml文档
11 print("*"*50,"我是分割线","*"*50)
12 for child in root:
13 print(child.tag, child.attrib) #打印前者子节点的名字“country”，并打印其属性。
14 for i in child:
15 print(i.tag, i.text,i.attrib) #打印子节点的参数名，已经其所对应的值,最后打印其属性。
16 # 只遍历year 节点
17 print("*" * 50, "我是分割线", "*" * 50)
18 for node in root.iter('year'):
19 print(node.tag, node.text)
20
21 # 只遍历country节点
22 print("*" * 50, "我是分割线", "*" * 50)
23 for node in root.iter('country'):
24 print(node.tag, node.text,node.attrib)
25
26 print("*" * 50, "我是分割线", "*" * 50)
27 for node in root.iter('test1'):
28 print(node.tag, node.text,node.attrib)
29
30
31 #以上代码执行结果如下：
32 data
33 ************************************************** 我是分割线 **************************************************
34 country {'name': 'Liechtenstein'}
35 rank 2 {'updated': 'yes'}
36 year 2008 {}
37 gdppc 141100 {}
38 neighbor None {'direction': 'E', 'name': 'Austria'}
39 neighbor None {'direction': 'W', 'name': 'Switzerland'}
40 hotspots
41 {}
42 country {'name': 'Singapore'}
43 rank 5 {'updated': 'yes'}
44 year 2011 {}
45 gdppc 59900 {}
46 neighbor None {'direction': 'N', 'name': 'Malaysia'}
47 country {'name': 'Panama'}
48 rank 69 {'updated': 'yes'}
49 year 2011 {}
50 gdppc 13600 {}
51 neighbor None {'direction': 'W', 'name': 'Costa Rica'}
52 neighbor None {'direction': 'E', 'name': 'Colombia'}
53 ************************************************** 我是分割线 **************************************************
54 year 2008
55 year 2011
56 year 2011
57 ************************************************** 我是分割线 **************************************************
58 country
59 {'name': 'Liechtenstein'}
60 country
61 {'name': 'Singapore'}
62 country
63 {'name': 'Panama'}
64 ************************************************** 我是分割线 **************************************************
65 test1 维也纳 {}
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import xml.etree.ElementTree as ET
7 tree = ET.parse("xmltest.xml")
8 root = tree.getroot()
9 # 修改
10 for node in root.iter('year'): #表示操作的对象是“year”字段
11 new_year = int(node.text) + 1 #将年份加“1”
12 node.text = str(new_year) #把数字转换成字符串
13 node.set("updated", "yes") #set是更改属性，增加了一个属性updated="yes"
14 tree.write("xmltest2.xml",encoding="utf-8") #将修改后的内容写入xml文件中。
1 <data>
2 <country name="Liechtenstein">
3 <rank updated="yes">2</rank>
4 <year updated="yes">2009</year>
5 <gdppc>141100</gdppc>
6 <neighbor direction="E" name="Austria" />
7 <neighbor direction="W" name="Switzerland" />
8 <hotspots>
9 <test1>维也纳</test1>
10 <test2>萨尔斯堡</test2>
11 </hotspots>
12 </country>
13 <country name="Singapore">
14 <rank updated="yes">5</rank>
15 <year updated="yes">2012</year>
16 <gdppc>59900</gdppc>
17 <neighbor direction="N" name="Malaysia" />
18 </country>
19 <country name="Panama">
20 <rank updated="yes">69</rank>
21 <year updated="yes">2012</year>
22 <gdppc>13600</gdppc>
23 <neighbor direction="W" name="Costa Rica" />
24 <neighbor direction="E" name="Colombia" />
25 </country>
26 </data>
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import xml.etree.ElementTree as ET
7 tree = ET.parse("xmltest.xml")
8 root = tree.getroot()
9 # 删除node
10 for country in root.findall('country'):
11 rank = int(country.find('rank').text)
12 if rank > 50: #如果国家排名大于50就删除这个国家
13 root.remove(country)
14 tree.write('output.xml',encoding="utf-8")
1 <data>
2 <country name="Liechtenstein">
3 <rank updated="yes">2</rank>
4 <year>2008</year>
5 <gdppc>141100</gdppc>
6 <neighbor direction="E" name="Austria" />
7 <neighbor direction="W" name="Switzerland" />
8 <hotspots>
9 <test1>维也纳</test1>
10 <test2>萨尔斯堡</test2>
11 </hotspots>
12 </country>
13 <country name="Singapore">
14 <rank updated="yes">5</rank>
15 <year>2011</year>
16 <gdppc>59900</gdppc>
17 <neighbor direction="N" name="Malaysia" />
18 </country>
19 </data>
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import xml.etree.ElementTree as ET
7 new_xml = ET.Element("namelist") #生成一个根节点
8 name = ET.SubElement(new_xml, "name", attrib={"enrolled": "yes"}) #SubElement创建了一个子节点，其中名字叫“name”，属性是{"enrolled": "yes"}
9 age = ET.SubElement(name, "age", attrib={"checked": "no"}) #在name下又创建了一个子节点
10 sex = ET.SubElement(name, "sex")
11 sex.text = '33'
12
13 name2 = ET.SubElement(new_xml, "name", attrib={"enrolled": "no"})
14 age = ET.SubElement(name2, "age")
15 age.text = '19'
16 et = ET.ElementTree(new_xml) # 生成文档对象
17 et.write("test.xml", encoding="utf-8", xml_declaration=True)
18 # ET.dump(new_xml) # 打印生成的格式
1 <?xml version='1.0' encoding='utf-8'?>
2 <namelist>
3 <name enrolled="yes">
4 <age checked="no" />
5 <sex>33</sex></name>
6 <name enrolled="no">
7 <age>19</age>
8 </name>
9 </namelist>
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import xml.etree.ElementTree as ET
7 tree = ET.parse("xmltest.xml")
8 root = tree.getroot()
9 for country in root.findall('country'):
10 rank = int(country.find('rank').text)
11 if rank > 50:
12 root.remove(country)
13 else:
14 sub_ele = ET.SubElement(country,"population",attrib={"enrolled":"yes"}) #创建一个新的“population”
15 sub_ele.text = str(100000000000)
16 tree.write('output2.xml')
1 <data>
2 <country name="Liechtenstein">
3 <rank updated="yes">2</rank>
4 <year>2008</year>
5 <gdppc>141100</gdppc>
6 <neighbor direction="E" name="Austria" />
7 <neighbor direction="W" name="Switzerland" />
8 <hotspots>
9 <test1>维也纳</test1>
10 <test2>萨尔斯堡</test2>
11 </hotspots>
12 <population enrolled="yes">100000000000</population></country>
13 <country name="Singapore">
14 <rank updated="yes">5</rank>
15 <year>2011</year>
16 <gdppc>59900</gdppc>
17 <neighbor direction="N" name="Malaysia" />
18 <population enrolled="yes">100000000000</population></country>
19 </data>
10.PyYAML模块
请参考官网：http://pyyaml.org/wiki/PyYAMLDocumentation
saltstack自动化运维工具的配置文件就是要ongodb这种格式写的。
11.ConfigParser模块
用于生成和修改常见配置文档，当前模块的名称在 python 3.x 版本中变更为 configparser。类似于apache和mysql的配置文件就用这个模块生成的。
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import configparser
7 config = configparser.ConfigParser() #生成一个根节点实例
8 config["DEFAULT"] = {'ServerAliveInterval': '45',
9 'Compression': 'yes',
10 'CompressionLevel': '9'}
11 config['bitbucket.org'] = {} #生成一个空的字典·
12 config['bitbucket.org']['User'] = 'yinzhengjie' #往这个空字典中添加信息
13 config['topsecret.server.com'] = {} #通过config实例生成一个叫“topsecret.server.com”的空节点
14 topsecret = config['topsecret.server.com'] #找到上面那个空节点然后赋值给一个变量，之后可以往里面赋值参数
15 topsecret['Host Port'] = '50022' # mutates the parser
16 topsecret['ForwardX11'] = 'no' # same here
17 config['DEFAULT']['ForwardX11'] = 'yes' #给“DEFAULT”字段赋值
18 with open('example.ini', 'w') as configfile: #最终将数据写入到“example.ini”文件中.
19 config.write(configfile)
1 [DEFAULT]
2 compressionlevel = 9
3 serveraliveinterval = 45
4 compression = yes
5 forwardx11 = yes
6
7 [bitbucket.org]
8 user = yinzhengjie
9
10 [topsecret.server.com]
11 host port = 50022
12 forwardx11 = no
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import configparser
7 config = configparser.ConfigParser() #生成一个实例
8 print(config.sections()) #打印出有多少个子配置实例
9 print("*"*50,"我是分割线","*"*50)
10 print(config.read('example.ini')) #读取这个文件
11 print("*"*50,"我是分割线","*"*50)
12 print(config.sections()) #打印出有多少个子配置实例，当read到数据之后，就可以看到相关的子实例，并且默认不打印“[DEFAULT]”这个子实例。
13 print("*"*50,"我是分割线","*"*50)
14 print('bitbucket.org' in config) #取布尔值，判断bitbucket.org是否在config这个实例中。
15 print('bytebong.com' in config)
16 print("*"*50,"我是分割线","*"*50)
17 print(config['bitbucket.org']['User']) #取“config['bitbucket.org']"子实例中的'User'变量所对应的值
18 print("*"*50,"我是分割线","*"*50)
19 print(config['DEFAULT']['Compression'])
20 topsecret = config['topsecret.server.com']
21 print(topsecret['ForwardX11'])
22 print("*"*50,"我是分割线","*"*50)
23 for key in config['bitbucket.org']: #遍历出'bitbucket.org'子实例中的变量
24 print(key)
25 print(config['bitbucket.org']['ForwardX11'])
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import configparser
7 config = configparser.ConfigParser() #生成一个实例
8 config.read('example.ini') #读取这个文件，注意，如果缺少这个步骤，无法进行修改或者读取哟！
9 config.set("bitbucket.org","name","Yinzhengjie") #在bitbucket.org的sections添加"name"的值为"Yinzhengjie"
10 config.set("bitbucket.org","user","尹正杰") #在bitbucket.org的sections修改"user"的值为"尹正杰"
11 config.write(open("test_1.cfg","w",encoding="utf-8"))
1 [DEFAULT]
2 compressionlevel = 9
3 serveraliveinterval = 45
4 compression = yes
5 forwardx11 = yes
6
7 [bitbucket.org]
8 user = 尹正杰
9 name = Yinzhengjie
10
11 [topsecret.server.com]
12 host port = 50022
13 forwardx11 = no
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import configparser
7 config = configparser.ConfigParser() #生成一个实例
8 config.read('example.ini')
9 config.remove_section("bitbucket.org") #删除整个section！
10 config.remove_option("DEFAULT","forwardx11") #删除某个section的一个子项，
11 config.write(open("test_rm.ini","w",encoding="utf-8")) #如果有汉子的话需要制定编码格式才能正常打印汉子哟~
1 [DEFAULT]
2 compressionlevel = 9
3 serveraliveinterval = 45
4 compression = yes
5
6 [topsecret.server.com]
7 host port = 50022
8 forwardx11 = no
12.hashlib模块
用于加密相关的操作，3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法.
1>.MD5算法参数详解：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.md5()
8 m.update(b"hello") #字节格式输入
9 print(m.hexdigest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.hexdigest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.md5()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.hexdigest())
17
18 '''
19 扩展：
20 MD5值是无法被反解的，网上有人说能破解是骗人的，之所以能破解，是因为他们已经将算好的md5值存入到数据库中，然后跟你你输入的MD5值给你返回一个明文的字符串。
21 '''
22
23
24 #以上代码执行结果如下：
25 5d41402abc4b2a76b9719d911017c592
26 1c7bdaafeb36ea7e3236d01afeee39cf
27 1d19d8f2d5037b0f3e9a2d020930ba91
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.md5()
8 m.update(b"hello") #字节格式输入
9 print(m.digest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.digest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.md5()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.digest())
17
18 '''
19 扩展：
20 MD5值是无法被反解的，网上有人说能破解是骗人的，之所以能破解，是因为他们已经将算好的md5值存入到数据库中，然后跟你你输入的MD5值给你返回一个明文的字符串。
21 '''
22
23 #以上代码执行结果如下：
24 b']A@*\xbcK*v\xb9q\x9d\x91\x10\x17\xc5\x92'
25 b'\x1c{\xda\xaf\xeb6\xea~26\xd0\x1a\xfe\xee9\xcf'
26 b'\x1d\x19\xd8\xf2\xd5\x03{\x0f>\x9a-\x02\t0\xba\x91'
2>.sha1算法参数详解：
Google已经将改算法破解了，只是还没有公布，目前很少人用这种算法了！
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.sha1()
8 m.update(b"hello") #字节格式输入
9 print(m.digest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.digest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.sha1()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.digest())
17
18 '''
19 扩展：
20 MD5值是无法被反解的，网上有人说能破解是骗人的，之所以能破解，是因为他们已经将算好的md5值存入到数据库中，然后跟你你输入的MD5值给你返回一个明文的字符串。
21 '''
22
23 #以上代码执行结果如下：
24 b'\xaa\xf4\xc6\x1d\xdc\xc5\xe8\xa2\xda\xbe\xde\x0f;H,\xd9\xae\xa9CM'
25 b'p\xff\xe5<\x08\xb9D?\xabJ\xcdC2f\x84\xa07\xd6\xc2c'
26 b'\xad\x06\x8b\x91)\x1c \x99\x82*6D^\xb2DA\x12_3\xa6'
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.sha1()
8 m.update(b"hello") #字节格式输入
9 print(m.hexdigest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.hexdigest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.sha1()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.hexdigest())
17
18 '''
19 扩展：
20 MD5值是无法被反解的，网上有人说能破解是骗人的，之所以能破解，是因为他们已经将算好的md5值存入到数据库中，然后跟你你输入的MD5值给你返回一个明文的字符串。
21 '''
22
23
24 #以上代码执行结果如下：
25 aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d
26 70ffe53c08b9443fab4acd43326684a037d6c263
27 ad068b91291c2099822a36445eb24441125f33a6
3>.sha256算法参数详解：
这个是没有被破解的，连谷歌破解的仅仅是sha1,而256加密后的明显字节变成啊，有木有。
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.sha256()
8 m.update(b"hello") #字节格式输入
9 print(m.digest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.digest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.sha256()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.digest())
17
18
19 #以上代码执行结果如下：
20 b',\xf2M\xba_\xb0\xa3\x0e&\xe8;*\xc5\xb9\xe2\x9e\x1b\x16\x1e\\\x1f\xa7B^s\x043b\x93\x8b\x98$'
21 b'\xec\xf6\x8e\x01\x17\xac!:\xb9<\xe4\xab\xee\x13\x03\xcc\xe4r\xb0\xdc\xfb\xcbm\xd4\xec\xa2\xc9P\x02\xfdi\xb7'
22 b'\xf4\x9d\xe7o\xe3\x01A\xf28\xd0\xc1b4\xa0\xbf\x01\x88\xbf\x9a4\xb4\xe8\xdd\xb6\\P\x8c&\xd5\xb1\xaf\x06'
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.sha256()
8 m.update(b"hello") #字节格式输入
9 print(m.hexdigest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.hexdigest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.sha256()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.hexdigest())
17
18
19 #以上代码执行结果如下：
20 2cf24dba5fb0a30e26e83b2ac5b9e29e1b161e5c1fa7425e73043362938b9824
21 ecf68e0117ac213ab93ce4abee1303cce472b0dcfbcb6dd4eca2c95002fd69b7
22 f49de76fe30141f238d0c16234a0bf0188bf9a34b4e8ddb65c508c26d5b1af06
4>.sha512算法参数详解：
这个也没有破解，明显的效果就是加密后的值变的比256还要长呢!
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.sha512()
8 m.update(b"hello") #字节格式输入
9 print(m.digest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.digest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.sha512()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.digest())
17
18
19 #以上代码执行结果如下：
20 b'\x9bq\xd2$\xbdb\xf3x]\x96\xd4j\xd3\xea=s1\x9b\xfb\xc2\x89\x0c\xaa\xda\xe2\xdf\xf7%\x19g<\xa7##\xc3\xd9\x9b\xa5\xc1\x1d|z\xccn\x14\xb8\xc5\xda\x0cFcG\\.\\:\xde\xf4os\xbc\xde\xc0C'
21 b"7\x8fb\xe6'\x11\xcc\xa8I\x9b\x89=\xcf\xac\x06\xdc\xbc\xb7GyG\x96\xd9=\xfc\xa7r\xc6\xba\x9ep\x96\xd7X\x05\x82\xbd\x87\xae\x94\x90UD\xdd\xdf\x94-\xa5\xcd\xf9o\x89\xdc\xcf\x85pr\x9ekvE\x12\xcc\x0f"
22 b'\xea\x1b\xda\xce3r>\x83\x98\x94\xd7\x7fp\xad}\x84w\xb3o\xd2\xf4ZMB\xb6\xb9c|t]\xa5\xf7]*\xb2v\xf10\xa8&\x19\xeb\xc7\xe5;\x9d0\x92o\x9b\xa8\x91v\xc5\x03\xd4\x82Z\xb3;\xea[\x01h'
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hashlib
7 m = hashlib.sha512()
8 m.update(b"hello") #字节格式输入
9 print(m.hexdigest()) #用十六进制输出一段md5值,注意，只要输入的值不变，这个值就不会变的！
10 m.update(b"my name is yinzhengjie")
11 print(m.hexdigest())
12
13 #注意，将上面两个字段拼接起来，其中的MD5值也是会发生变化的
14 m2 = hashlib.sha512()
15 m2.update(b"hello my name is yinzhengjie")
16 print(m2.hexdigest())
17
18
19 #以上代码执行结果如下：
20 9b71d224bd62f3785d96d46ad3ea3d73319bfbc2890caadae2dff72519673ca72323c3d99ba5c11d7c7acc6e14b8c5da0c4663475c2e5c3adef46f73bcdec043
21 378f62e62711cca8499b893dcfac06dcbcb747794796d93dfca772c6ba9e7096d7580582bd87ae94905544dddf942da5cdf96f89dccf8570729e6b764512cc0f
22 ea1bdace33723e839894d77f70ad7d8477b36fd2f45a4d42b6b9637c745da5f75d2ab276f130a82619ebc7e53b9d30926f9ba89176c503d4825ab33bea5b0168
5>.hmac模块
如果你觉得以上的加密方法还是不够安全~厉害了，你的安全感可真低啊，看来是伤的不轻，一定是一个有故事的人，不过针对你这种人呢~还有一种算法为你特别定制hmac，等你成为了一个开发大神，你可以自己写一个算法，因为你毕竟只相信你自己嘛，哈哈~
散列消息鉴别码，简称HMAC，是一种基于消息鉴别码MAC（Message Authentication Code）的鉴别机制。使用HMAC时,消息通讯的双方，通过验证消息中加入的鉴别密钥K来鉴别消息的真伪；一般用于网络通信中消息加密，前提是双方先要约定好key,就像接头暗号一样，然后消息发送把用key把消息加密，接收方用key ＋ 消息明文再加密，拿加密后的值 跟 发送者的相对比是否相等，这样就能验证消息的真实性，及发送者的合法性了。（它内部对我们创建 key 和 内容 再进行处理然后再加密）
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import hmac
7 h = hmac.new("我本有心向明月".encode("utf-8"), "奈何明月照沟渠".encode("utf-8"),) #"我本有心向明月"这就好比双方(A,B)已经约定好了的key，（类似于我们第一次登录linux服务器，使用ssh登陆方式都会提示你，让你输入"yes"后才能输入密码。），接受者(A)接收到了"奈何明月照沟渠"这个明文消息和加密后的字符“489f9932949514ab24894559150088c0”，然后用定义好的key和去加密"奈何明月照沟渠"这个明文字符，如果加密后生成的字符是“489f9932949514ab24894559150088c0”就证明这个消息是发送者(B)发送过来的数据，它只能验证消息的合法来源。如果中间人截获了明文消息加以修改的，就会被发现！
8 print(h.hexdigest())
9
10
11 #以上代码执行结果如下：
12 489f9932949514ab24894559150088c0
13.subproces模块
subproces基本上就是为了取代os.system和os.spawn*模块的。
1>.subprocess.run调用shell命令，只能保存执行后的状态，不能保存命令的执行结果！
1 #不含参数的调用linux命令的方法
2 >>> a = subprocess.run("df")
3 Filesystem 1K-blocks Used Available Use% Mounted on
4 /dev/sda2 8854456 4170968 4227040 50% /
5 tmpfs 502172 228 501944 1% /dev/shm
6 /dev/sda1 289293 28463 245470 11% /boot
7
8 #含参数的调用linux命令的方法
9 >>> a = subprocess.run(["df","-h"])
10 Filesystem Size Used Avail Use% Mounted on
11 /dev/sda2 8.5G 3.8G 4.3G 48% /
12 tmpfs 491M 228K 491M 1% /dev/shm
13 /dev/sda1 283M 28M 240M 11% /boot
14 >>>
15
16
17
18 #调用复杂的linux命令的方法，需要加“shell=True”，表示将前面引号的内容放在一个终端(terminal)去执行，需要注意的是这个不能保存命令输出的结果，而是保存命令执行的结果哟！一般非“0”就表示命令没有执行成功，而结果是“0”表示执行命令实成功的，但是命令的输出结果是无法保存的！切记！
19 >>> a = subprocess.run("df -h | grep /dev/sda1",shell=True)
20 /dev/sda1 283M 28M 240M 11% /boot
21 >>> a.returncode
22 0
2>.执行命令，返回命令的执行状态,“0” or 非 “0”
1 #执行命令，返回命令执行状态 ， 0 or 非0
2 >>> retcode = subprocess.call(["ls", "-l"])
3 total 96
4 -rw-------. 1 root root 3321 Oct 13 10:26 anaconda-ks.cfg
5 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Desktop
6 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Documents
7 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Downloads
8 -rw-r--r--. 1 root root 41433 Oct 13 10:26 install.log
9 -rw-r--r--. 1 root root 9154 Oct 13 10:24 install.log.syslog
10 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Music
11 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Pictures
12 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Public
13 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Templates
14 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Videos
15 >>>
16
17
18 #执行命令，如果命令结果为0，就正常返回，否则抛异常
19 >>> subprocess.check_call(["ls", "-l"])
20 total 96
21 -rw-------. 1 root root 3321 Oct 13 10:26 anaconda-ks.cfg
22 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Desktop
23 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Documents
24 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Downloads
25 -rw-r--r--. 1 root root 41433 Oct 13 10:26 install.log
26 -rw-r--r--. 1 root root 9154 Oct 13 10:24 install.log.syslog
27 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Music
28 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Pictures
29 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Public
30 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Templates
31 drwxr-xr-x. 2 root root 4096 Oct 13 22:03 Videos
32 0
33 >>>
3>.接收字符串格式命令，返回元组形式，第1个元素是执行状态，第2个是命令结果
1 >>> subprocess.getstatusoutput('ls /bin/pwd')
2 (0, '/bin/pwd')
3 >>>
4>.接收字符串格式命令，并返回结果
1 >>> subprocess.getoutput('ifconfig | grep eth0')
2 'eth0 Link encap:Ethernet HWaddr 00:0C:29:D4:DB:87 '
3 >>>
5>.执行命令，并返回结果，注意是返回结果，不是打印，下例结果返回给res
1 >>> res=subprocess.check_output(['pwd'])
2 >>> res
3 b'/root\n'
4 >>>
6>.上面那些方法，底层都是封装的subprocess.Popen
1 >>> p = subprocess.Popen("df -h|grep /dev/sda1",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, shell=True)
2 >>> p.stdout.read()
3 b'/dev/sda1 283M 28M 240M 11% /boot\n'
4 >>>
5
6 “”“
7 注意：
8 我们来对第一行的进行讲解一下
9 subprocess.Popen表示打开一个终端（只是启动一个进程），stdin=subprocess.PIPE表示输入通过subprocess.PIPE这个管道传输，stdout=subprocess.PIPE表示输出也通过subprocess.PIPE这个管道传输，stderr=subprocess.PIPE同理。
10 ”“”
7>.检查命令是否执行完毕
1 >>> p = subprocess.Popen("top -bn 5",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, shell=True)
2 >>> p.poll()
3 >>> p.poll()
4 >>> p.poll()
5 >>> p.poll()
6 >>> p.poll()
7 >>> p.poll()
8 0
9 >>> p.poll()
10 0
11 >>>
12 ‘’‘
13 poll()
14 Check if child process has terminated. Returns returncode
15 ’‘’
1 >>> p = subprocess.Popen("top -bn 5",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, shell=True)
2 >>> p.wait()
3 0
4 >>>
5
6 '''
7 wait()
8 Wait for child process to terminate. Returns returncode attribute.
9 '''
1 >>> p = subprocess.Popen("top -bn 5",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, shell=True)
2 >>> p.poll()
3 >>> p.terminate()
4 >>> p.poll()
5 143
6
7 '''
8 terminate() 杀掉所启动进程,此时p.poll返回值应该是非“0”，因为不是正常结束的！没有执行完毕就被杀掉了。
9 '''
1 >>> p = subprocess.Popen("df -h;sleep 100",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, shell=True)
2 >>> p.poll()
3 >>> p.poll()
4 >>> p.communicate(timeout=2)
5 Traceback (most recent call last):
6 File "<stdin>", line 1, in <module>
7 File "/usr/local/lib/python3.5/subprocess.py", line 1068, in communicate
8 stdout, stderr = self._communicate(input, endtime, timeout)
9 File "/usr/local/lib/python3.5/subprocess.py", line 1699, in _communicate
10 self._check_timeout(endtime, orig_timeout)
11 File "/usr/local/lib/python3.5/subprocess.py", line 1094, in _check_timeout
12 raise TimeoutExpired(self.args, orig_timeout)
13 subprocess.TimeoutExpired: Command 'df -h;sleep 100' timed out after 2 seconds
14 >>>
15
16 ‘’‘
17 communicate() 等待任务结束，我们需要在里面添加一个参数，默认单位是“s”，如果程序执行时间超过指定的时间就会抛出一个“TimeoutExpired”的字样哟，不过我们可以用异常处理来吧这个错误解决掉！
18 ’‘’
1 >>> def name():
2 ... print("my name is yinzhengjie!")
3 ...
4 >>> p = subprocess.Popen("pwd",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE, preexec_fn=name) >>> p.stdout.read()
5 b'my name is yinzhengjie!\n/root\n'
6 >>>
7
8 ‘’‘
9 preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进程运行之前被调用，运行结果见上例。
10 ’‘’
1 >>> p = subprocess.Popen("pwd",cwd="/usr/local",stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE)
2 >>> p.stdout.read()
3 b'/usr/local\n'
4 >>>
5
6 '''
7 cwd：用于设置子进程的当前目录
8 '''
1 >>> p = subprocess.Popen("echo $name_str",cwd="/usr/local",shell=True,stdin=subprocess.PIPE,stdout=subprocess.PIPE,stderr=subprocess.PIPE,env={"name_str":"yinzhengjie"})
2 >>> p.stdout.read()
3 b'yinzhengjie\n'
4 >>>
5 ‘’‘
6 提示：
7 env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
8 ’‘’
14.re模块
正在表达式主要是用于模糊匹配，Python中的正则用法比较简单，但是规则比较麻烦，你可以根据你的需求配置不同的规则
常用正则表达式符号：
1 '\A' 只从字符开头匹配，re.search("\Yin","yinzhengjie") 是匹配不到的
2 '\Z' 匹配字符结尾，同$
3 '\d' 匹配数字0-9
4 '\D' 匹配非数字
5 '\w' 匹配[A-Za-z0-9]
6 '\W' 匹配非[A-Za-z0-9]
7 's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
1 re.match 从头开始匹配
2 re.search 匹配包含
3 re.findall 把所有匹配到的字符放到以列表中的元素返回
4 re.splitall 以匹配到的字符当做列表分隔符
5 re.sub 匹配字符并替换
1>.'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.match("yin","yinzhengjie")) #精确匹配，前面是条件，后面是内容
8 print(re.match(".","yinzhengjie")) #模糊匹配单个字符
9 print(re.match("...","yinzhengjie"))
10 print(re.match("....","yin\nzhengjie")) #从开头开始模糊匹配4个字符，无法识别换行符"\n",
11
12
13 #以上代码执行结果如下：
14 <_sre.SRE_Match object; span=(0, 3), match='yin'>
15 <_sre.SRE_Match object; span=(0, 1), match='y'>
16 <_sre.SRE_Match object; span=(0, 3), match='yin'>
17 None
2>.'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.match("^Y","Yinzhengjie"))
8 print(re.match("jie","Yinzhengjie")) #表示从头开始匹配
9 print(re.search("jie","yinzhengjie")) #表示匹配包含
10
11
12
13 #以上代码执行结果如下：
14 <_sre.SRE_Match object; span=(0, 1), match='Y'>
15 None
16 <_sre.SRE_Match object; span=(8, 11), match='jie'>
3>.'$' 匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("jie$","Yinzhengjie")) #匹配包含，不从开头开始匹配哟
8
9
10 #以上代码执行结果如下：
11 <_sre.SRE_Match object; span=(8, 11), match='jie'>
4>.'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.match(".+","Yinzhengjie")) #表示从头开始匹配
8 print(re.match("^.+","Yinzhengjie"))
9 print(re.match(".+","Yinzheng\njie")) #表示匹配包含
10
11
12
13 #以上代码执行结果如下：
14 <_sre.SRE_Match object; span=(0, 11), match='Yinzhengjie'>
15 <_sre.SRE_Match object; span=(0, 11), match='Yinzhengjie'>
16 <_sre.SRE_Match object; span=(0, 8), match='Yinzheng'>
5>.'*' 匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("Y*","Yinzhengjie"))
8 print(re.search("jie*","Yinzhengjie"))
9 print(re.search("e*","Yinzhengjie"))
10
11
12 #以上代码执行结果如下：
13 <_sre.SRE_Match object; span=(0, 1), match='Y'>
14 <_sre.SRE_Match object; span=(8, 11), match='jie'>
15 <_sre.SRE_Match object; span=(0, 0), match=''>
6>.'?' 匹配前一个字符1次或0次
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("Y?","Yinzhengjie"))
8 print(re.search("jie?","Yinzhengjie"))
9 print(re.search("e?","Yinzhengjieee"))
10
11
12 #以上代码执行结果如下:
13 <_sre.SRE_Match object; span=(0, 1), match='Y'>
14 <_sre.SRE_Match object; span=(8, 11), match='jie'>
15 <_sre.SRE_Match object; span=(0, 0), match=''>
7>.'{m}' 匹配前一个字符m次
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("jie{1}","Yinzhengjiejie"))
8 print(re.search("(jie){2}","Yinzhengjiejie"))
9 print(re.search("e{3}","Yinzhengjieee"))
10
11 #以上代码执行结果如下：
12 <_sre.SRE_Match object; span=(8, 11), match='jie'>
13 <_sre.SRE_Match object; span=(8, 14), match='jiejie'>
14 <_sre.SRE_Match object; span=(10, 13), match='eee'>
8>.'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("e{1,3}","Yinzhengjieee"))
8 print(re.search("e{2,3}","Yinzhengjieee"))
9 print(re.search("e{3,10}","Yinzhengjieee"))
10
11
12 #以上代码执行结果如下：
13 <_sre.SRE_Match object; span=(5, 6), match='e'>
14 <_sre.SRE_Match object; span=(10, 13), match='eee'>
15 <_sre.SRE_Match object; span=(10, 13), match='eee'>
9>.'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("e|E","YinzhengjiE"))
8 print(re.search("e|E","YinzhEngjie"))
9
10 #以上代码执行结果如下：
11 <_sre.SRE_Match object; span=(5, 6), match='e'>
12 <_sre.SRE_Match object; span=(5, 6), match='E'>
10>.'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("\d","612401199607237057")) #匹配一个数字
8 print(re.search("\d+","612401199607237057")) #匹配数字一次或者多次，一般是贪婪匹配，会尽量把匹配最长的数字给你打印出来
9 print(re.search("\d...","612401199607237057")) #匹配一个数字和3个任意字符
10 print(re.search("\d{4}","612401199607237057")) #匹配4个数字
11 print(re.search("[0-9]{4}","612401199607237057")) #[0-9]其实就是等效于\d
12 print(re.search("(\d{3})(\d{3})(\d...(3))","612401199607237057")) #这个有点绕，我当时弄了好久才研究明白，给大家分享一下如何去看，前2个“(\d{3})”表示匹配三个数字类型的字符，也就是要匹配6个数字，“(\d...(3))”这个的意思是：匹配一个数字和三个任意字符，而且最后结尾标识符必须是数字“3”。
13 print(re.search("(\d{3})(\d{3})(\d(7))","612401199607237057")) #表示匹配以数字“7”结尾前面加七个数字[(\d{3})(\d{3})是6个数字后面还有个\d所以总共是7个数字，后面的(3)我们可以理解是以“3”结尾即可。如果你看懂我上面的例子下面这个就不是事情啦！]
14 print(re.search("(\d{3})(\d{3})(\d...(3))","612401199607237057").group()) #取到值的结果
15 print(re.search("(\d{3})(\d{3})(\d...(3))","612401199607237057").groups()) #将取到的结果进行分组，这样大家就能看明白上面我举的那个例子啦
16 number = re.search("(\d{3})(\d{3})(\d...(3))","612401199607237057").groups() #我们也可以将分组的信息赋值给一个变量，便于取值，如下：
17 print(number[0])
18 print(number[3])
19
20
21 #以上代码执行结果如下：
22 <_sre.SRE_Match object; span=(0, 1), match='6'>
23 <_sre.SRE_Match object; span=(0, 18), match='612401199607237057'>
24 <_sre.SRE_Match object; span=(0, 4), match='6124'>
25 <_sre.SRE_Match object; span=(0, 4), match='6124'>
26 <_sre.SRE_Match object; span=(0, 4), match='6124'>
27 <_sre.SRE_Match object; span=(3, 14), match='40119960723'>
28 <_sre.SRE_Match object; span=(4, 12), match='01199607'>
29 40119960723
30 ('401', '199', '60723', '3')
31 401
32 3
11>.'\d','\D','\w','\W' 用法：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("\D","！Yinzhengjie612401199607237057jie!!!!")) #匹配一个非数字
8 print(re.search("\D+","Yinzhengjie612401199607237057jie!!!!")) #匹配多个非数字，
9 print(re.search("\D+\d+","Yinzhengjie612401199607237057jie!!!!")) #匹配非数字和数字（注意，不会匹配到“jie!!!!”，因为它不是数字）
10 print(re.search("\D+\d+\D+","Yinzhengjie612401199607237057jie!!!!")) #都会被匹配到哟
11 print(re.search("\w+","Yinzhengjie612401199607237057jie!!!!")) #匹配[A-Za-z0-9]
12 print(re.search("\W+","Yinzhengjie612401199607237057jie!!!!")) #匹配非字母大小写和数字，即不匹配[A-Za-z0-9]，用于匹配特殊字符
13
14
15 #以上代码执行结果如下：
16 <_sre.SRE_Match object; span=(0, 1), match='！'>
17 <_sre.SRE_Match object; span=(0, 11), match='Yinzhengjie'>
18 <_sre.SRE_Match object; span=(0, 29), match='Yinzhengjie612401199607237057'>
19 <_sre.SRE_Match object; span=(0, 36), match='Yinzhengjie612401199607237057jie!!!!'>
20 <_sre.SRE_Match object; span=(0, 32), match='Yinzhengjie612401199607237057jie'>
21 <_sre.SRE_Match object; span=(32, 36), match='!!!!'>
12>.'s' 与'(?P<name>...)' 分组匹配用法：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("\s+","！Yinzhengjie612401199607237057 !!!!")) #可以匹配空格
8 print(re.search("\s+","！Yinzhengjie612401199607237057 \t !!!!")) #可以匹配\t
9 print(re.search("\s+","！Yinzhengjie612401199607237057 \n !!!!")) #可以匹配\n
10 print(re.search("\s+","！Yinzhengjie612401199607237057 \r !!!!")) #可以匹配\r
11 print(re.search("\s+","！Yinzhengjie612401199607237057 \r\n !!!!")) #可以匹配\r\n
12 print(re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","612401199907237057").groupdict() ) #这个看起来很复杂，其实挺简单的，这个比'(...)'分组匹配[是将结果放入一个tuple中]要简单的多，而咱们这个是将其变成一个字典，我们先看第一部分(?P<province>[0-9]{4})，就是让“province”为key,让“[0-9]{4}”为value，后面2个(?P<city>[0-9]{2})与(?P<birthday>[0-9]{4})也是一样的道理
13 a = re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","612401199907237057").groupdict() #同意，我们分组后可以对其进行取值
14 print(a.get("birthday"))
15 print(a.get("province"))
13>.findall的用法：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.findall("[a-z]","Yinzhengjie612401199607237057jie!!!!\n6666\r@@@\t")) #只匹配小写字母并将结果返回为一个列表
8 print(re.findall("[A-z]","Yinzhengjie612401199607237057jie!!!!\n6666\r@@@\t")) #只匹配大写和小写的字母
9 print(re.findall("[0-9]","Yinzhengjie612401199607237057jie!!!!\n6666\r@@@\t")) #只匹配数字
10 print(re.findall("\w","Yinzhengjie612401199607237057jie!!!!\n6666\r@@@\t")) #只匹配数字和字母
11 print(re.findall("\W","Yinzhengjie612401199607237057jie!!!!\n6666\r@@@\t")) #只匹配特殊字符
12
13
14
15 #以上代码执行结果如下：
16 ['i', 'n', 'z', 'h', 'e', 'n', 'g', 'j', 'i', 'e', 'j', 'i', 'e']
17 ['Y', 'i', 'n', 'z', 'h', 'e', 'n', 'g', 'j', 'i', 'e', 'j', 'i', 'e']
18 ['6', '1', '2', '4', '0', '1', '1', '9', '9', '6', '0', '7', '2', '3', '7', '0', '5', '7', '6', '6', '6', '6']
19 ['Y', 'i', 'n', 'z', 'h', 'e', 'n', 'g', 'j', 'i', 'e', '6', '1', '2', '4', '0', '1', '1', '9', '9', '6', '0', '7', '2', '3', '7', '0', '5', '7', 'j', 'i', 'e', '6', '6', '6', '6']
20 ['!', '!', '!', '!', '\n', '\r', '@', '@', '@', '\t']
14>.split用法
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.split("\W","172.30.1.2")) #取以特殊字符为分隔符取值
8 print(re.split("\W","192.168@2!24")) #同上
9
10
11
12 #以上代码执行结果如下：
13 ['172', '30', '1', '2']
14 ['192', '168', '2', '24']
15>.sub用法：
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.sub("\d{4}","2017","I was born in 1991-05-19,alex was born in 1937-9-15",count=1)) #表示对"I was born in 1991-05-19"这个字符串进行匹配"\d{4}"前4个数字，然后将匹配的到的数据用"2017"去替换掉,注意：count=1表示只匹配1次，如果不指定的话会默认匹配所有的连续的数字哟！
8 print(re.sub("\d{4}","2017","I was born in 1991-05-19,alex was born in 1937-9-15",count=2)) #默认匹配2次
9 print(re.sub("\d{4}","2017","I was born in 1991-05-19,alex was born in 1937-9-15",)) #默认全部匹配
10
11
12 #以上代码执行结果如下：
13 I was born in 2017-05-19,alex was born in 1937-9-15
14 I was born in 2017-05-19,alex was born in 2017-9-15
15 I was born in 2017-05-19,alex was born in 2017-9-15
16>.反斜杠的困扰
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 '''
8 与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
9 '''
10
11 print(re.search("\\d","\database")) #表示匹配数字
12 print(re.search(r"\\d","\database")) #表示匹配字母“d”(可以把一些特殊的符号匹配出来如：”\D“，”\Z“等等)，法一
13 print(re.search("\\\\d","\database")) #表示匹配字母“d”，法二
14
15
16
17 #以上代码执行结果如下：
18 None
19 <_sre.SRE_Match object; span=(0, 2), match='\\d'>
20 <_sre.SRE_Match object; span=(0, 2), match='\\d'>
17>.仅需了解几个匹配模式
1 #！/usr/bin/env python
2 #_*_coding:utf-8_*_
3 #@author :yinzhengjie
4 #blog:http://www.cnblogs.com/yinzhengjie/tag/python%E8%87%AA%E5%8A%A8%E5%8C%96%E8%BF%90%E7%BB%B4%E4%B9%8B%E8%B7%AF/
5 #EMAIL:y1053419035@qq.com
6 import re
7 print(re.search("[a-z]{2}","My Name Is Yinzhengjie",flags=re.I)) #忽略大小写
8 print(re.search(".+","My Name Is\r\n Yinzhengjie",flags=re.S)) #点任意匹配模式，改变'.'的行为，可以匹配"\n","\r","\r\n"等等。
9 print(re.search("^M","\nMy Name Is Yinzhengjie",flags=re.I))
10 print(re.search("^M","\nMy Name Is Yinzhengjie",flags=re.M)) #匹配以M开头，可以过滤掉换行符，用“flags=re.M”实现。
11
12
13 #以上代码执行结果如下：
14 <_sre.SRE_Match object; span=(0, 2), match='My'>
15 <_sre.SRE_Match object; span=(0, 24), match='My Name Is\r\n Yinzhengjie'>
16 None
17 <_sre.SRE_Match object; span=(1, 2), match='M'>