模块，是用一堆代码来实现某个功能的代码集合类似于函数式编程和面向过程编程，函数式编程则完成一个功能，其他代码来调用该功能，提供了代码的重用性和代码间的耦合性而对于一个复杂的功能，可能需要多个函数才能完成，这些文件组成的代码集合称为模块模块分为三种：自定义模块；内置标准模块；开源模块模块一：datetime和time
1 import time
2 print("返回标准时间（含年月日等信息）：",time.asctime())
3 print("返回本地时间的struct time时间格式：",time.localtime())
4 print("返回utc的struct时间对象格式：",time.gmtime(time.time()-800000))
5 print("返回标准时间格式：",time.asctime(time.localtime()))
6 print("返回标准时间格式：",time.ctime())
7 # #
8 # # #将日期字符串转换成时间戳
9 string2_struct=time.strptime("2016/10/22","%Y/%m/%d")
10 print("将日期字符串转换成struct格式：",string2_struct)
11 # #
12 struct_2_stamp=time.mktime(string2_struct)
13 print("将struct转换成时间戳：",struct_2_stamp)
14 # #
15 # # #将时间戳转换为字符串
16 print(time.gmtime(time.time()-86640)) #将utc时间戳转换成structtime格式
17 print(time.altzone)
18 # #
19 # # #将utc struct_time 格式转成指定的字符串格式 格式化时间格式
20 print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()))
21 # #
22 # #
23 # # #datetime
24 import datetime
25 print("返回系统当前时间：",datetime.datetime.now())
26 print("标准格式;",datetime.datetime.fromtimestamp(time.time()))
27 # # #时间加减
28 print("当前时间加三天：",datetime.datetime.now()+datetime.timedelta(3))
29 print("当前时间减三天：",datetime.datetime.now()+datetime.timedelta(-3))
30 print("当前时间加三小时：",datetime.datetime.now()+datetime.timedelta(hours=3))
31 print("当前时间加30分钟：",datetime.datetime.now()+datetime.timedelta(minutes=30))
32 # #
33 # # #时间替换,即对现有时间的修改
34 c_time=datetime.datetime.now()
35 print(c_time.replace(minute=3,hour=2))
模块二：random 随机数
1 import random
2 print(random.randint(1,2))
3 print(random.randrange(1,3))
4 # #
5 # # #生成随机验证码
6 checkcode=""
7 for i in range(4):
8 current=random.randrange(0,4)
9 if current!=i:
10 temp=chr(random.randint(65,90))
11 else:
12 temp=random.randint(0,9)
13 checkcode+=str(temp)
14 print("验证码为：",checkcode)
15 # #
16 # # # print("生成65-90之间的随机数：",random.randint(65,90))
17 # # # print("根据ASCII码转换：",chr(random.randint(65,90)))
模块三：os模块：用于提供系统级别的操作
1 import random
2 print(random.randint(1,2))
3 print(random.randrange(1,3))
4 # #
5 # # #生成随机验证码
6 checkcode=""
7 for i in range(4):
8 current=random.randrange(0,4)
9 if current!=i:
10 temp=chr(random.randint(65,90))
11 else:
12 temp=random.randint(0,9)
13 checkcode+=str(temp)
14 print("验证码为：",checkcode)
15 # #
16 # # # print("生成65-90之间的随机数：",random.randint(65,90))
17 # # # print("根据ASCII码转换：",chr(random.randint(65,90)))
1 os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
2 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd
3 os.curdir 返回当前目录: (‘.‘)
4 os.pardir 获取当前目录的父目录字符串名：(‘..‘)
5 os.makedirs(‘dir1/dir2‘) 可生成多层递归目录
6 os.removedirs(‘dirname1‘) 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推
7 os.mkdir(‘dirname‘) 生成单级目录；相当于shell中mkdir dirname
8 os.rmdir(‘dirname‘) 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname
9 os.listdir(‘dirname‘) 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印
10 os.remove() 删除一个文件
11 os.rename("oldname","new") 重命名文件/目录
12 os.stat(‘path/filename‘) 获取文件/目录信息
13 os.sep 操作系统特定的路径分隔符，win下为"\\",Linux下为"/"
14 os.linesep 当前平台使用的行终止符，win下为"\t\n",Linux下为"\n"
15 os.pathsep 用于分割文件路径的字符串
16 os.name 字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
17 os.system("bash command") 运行shell命令，直接显示
18 os.environ 获取系统环境变量
19 os.path.abspath(path) 返回path规范化的绝对路径
20 os.path.split(path) 将path分割成目录和文件名二元组返回
21 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素
22 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素
23 os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
24 os.path.isabs(path) 如果path是绝对路径，返回True
25 os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False
26 os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False
27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间
29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
模块四：sys 用来提供解释器的相关操作
1 import sys #用来提供对解释器的相关操作
2 print("返回模块的搜索路径，初始化时使用环境变量的值：",sys.path)
3 print(sys.argv) #命令行参数list,第一个元素是程序本身路径
1 import sys 2 import time 3 4 5 def view_bar(num, total): 6 rate = float(num) / float(total) 7 rate_num = int(rate * 100) 8 r = ‘\r%d%%‘ % (rate_num, ) 9 sys.stdout.write(r) 10 sys.stdout.flush() 11 12 13 if __name__ == ‘__main__‘: 14 for i in range(0, 100): 15 time.sleep(0.1) 16 view_bar(i, 100)
模块五：hashlib 用于加密相关的 操作，提供了MD5和Sha模块，主要提供SHA1/SHA224/SHA256/SHA384/SHA512/MD5算法
1 import hashlib
2 m=hashlib.md5()
3 m.update(b"Hello")
4 print("二进制格式加密：",m.digest())
5 print("十六进制加密：",m.hexdigest(),len(m.hexdigest()))
6
7 #sha1
8 s1=hashlib.sha1()
9 s1.update(b"Hello world")
10 print("SHA1:",s1.hexdigest(),len(s1.hexdigest()))
11
12 s2=hashlib.sha224()
13 s2.update(b"Hello world")
14 print("SHA224:",s2.hexdigest(),len(s2.hexdigest()))
15
16 s3=hashlib.sha256()
17 s3.update(b"Hello world")
18 print("SHA256:",s3.hexdigest(),len(s3.hexdigest()))
19
20 s4=hashlib.sha384()
21 s4.update(b"Hello world")
22 print("SHA384:",s4.hexdigest(),len(s4.hexdigest()))
23
24 s5=hashlib.sha512()
25 s5.update(b"Hello world")
26 print("SHA512:",s5.hexdigest(),len(s5.hexdigest()))
27 # # #由上述例子可以看出，不同的加密算法位数是不一样的，随着指数的增大，加密位数越来越多
28 # # #但是上述方法的加密可以通过撞库来反解,可以通过对加密算法添加自定义key来加密
29 m2=hashlib.md5(b"8jindeod098")
30 m2.update(b"Hello")
31 print("自定义参数加密：",m2.hexdigest())
32 # #
33 # # #更加牛逼的加密方式 内部对我们创建key和内容再进行处理后然后再加密
34 import hmac
35 h=hmac.new(b"Eric")
36 h.update(b"Hello world")
37 print("HMac:",h.hexdigest())
1 #生成随机验证码的函数
2 def code():
3 _code = list()
4 for i in range(4):
5 ra = random.randrange(4)
6 if i == ra:
7 _code.append(chr(random.randrange(97, 122)))
8 else:
9 _code.append(str(i))
10 result = ‘‘.join(_code)
11 return result
12 print("123:",code())
模块六：pickle,json
1 import pickle,json
2 data={"k1":123,"k2":"Hello"}
3 # # #pickle.dumps将数据通过特殊的形式转换为只有python语言认识的字符串
4 p_str=pickle.dumps(data)
5 print(p_str)
6 ss=pickle.loads(p_str)
7 print("111",ss)
8 # #
9 # # #pickle.dump将数据通过特殊形式转换为只有python认识的字符串，并写入文件
10 with open("result.pk","w") as f:
11 pickle.dump(data,f)
12 # #
13 import json
14 # # #json.dumps 将数据通过特殊的形式转换为所有程序语言都认识的字符串
15 j_str=json.dumps(data)
16 print(j_str)
17 # #
18 # # #json.dump将数据通过特殊形式转换为只有python认识的字符串，并写入文件
19 with open("result.json","w") as fp:
20 json.dump(data,fp)
1 import json,pickle
2 #json 用于【字符串】和【python】基本数据类型之间的转换
3 #pickle 用于【python特有的类型】和【python基本数据类型之间的转换】
4 data={"k1":123,"k2":"Hello"}
5 p_str=pickle.dumps(data)
6 print("pickle.dumps:",type(p_str),p_str) #转换为字节类型
7 #dump将数据通过特殊的形势转换为只有python语言认识的字符串，并写入文件
8 with open("dump.pk","wb") as fp:
9 pickle.dump(data,fp)
10
11 #json.dumps将数据通过特殊的形式转换为所有语言都认识的字符
12 j_str=json.dumps(data)
13 print("json.dumps:",j_str,type(j_str)) #转换为字符串类型
14
15 #json.dump将数据通过特殊的形式转换为所有语言都认识的字符，并写入文件
16 with open("json.pk","w") as fj: #字符串可以直接写入
17 json.dump(data,fj)
模块七：正则表达式 re
1 import re
2 # # #正则表达式相关操作
3 print()
4 print("--------------------分隔符----------------------")
5 origin = "hel1lo al2ex b1cd ab3cd lge acd 19"
6 r=re.match("\w+",origin) #从头开始匹配，匹配成功返回一个对象，不成功返回NONE
7 print("获取匹配的所有结果：",r.group())
8 #分组：提取匹配成功的指定内容（先匹配成功全部正则，再匹配成功的局部内容提取出来）
9 print("获取匹配的分组结果：",r.groups())
10
11 #浏览整个字符串去匹配第一个，未匹配成功返回None
12 r=re.search("\d+",origin)
13 print("浏览整个字符串，匹配第一个：",r.group())
14 #获取非重复的匹配列表，如果有一组则用列表形式返回
15 r=re.findall("\d+",origin)
16 print(r)
17 #替换匹配成功指定位置的字符串
18 r=re.sub("\d+","8888",origin,1)
19 print("替换匹配成功指定位置的字符串:",r)
20
21 #split 根据正则匹配分割字符串
22 r=re.split("\d+",origin)
23 print("split:",r)
24
25 origin1 = "hello alex bcd alex lge alex acd 19"
26 r1 = re.split("(alex)", origin1, 1)
27 print("用alex来拆分，但是保留Alex：",r1)
28 r2 = re.split("(al(ex))", origin1, 1)
29 print("用alex或ex来拆分，但是均保留：",r2)
30
31 #匹配IP地址
32 str_ip="Hello,222.168.16.60,Welcome,13783417293,[email protected]"
33 m=re.search("((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)",str_ip)
34 print("匹配到的IP是：",m.group())
35 m1=re.search("(1)([358]\d{9})",str_ip)
36 print("匹配到的电话为：",m1.group())
37 m2=re.search("[a-zA-Z0-9_-][email protected][a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+",str_ip)
38 print("匹配到的邮箱是：",m2.group())
模块八：configparser用于处理特定格式的文件，其本质是利用open来操作文件
1 import configparser
2 config=configparser.ConfigParser()
3 config.read("Hello world",encoding="utf-8")
4 ret=config.sections()
5 print("获取所有的节点：",ret)
6
7 #获取指定节点下的键值对
8 ret1=config.items("sections1")
9 print("获取sections1下的键值对：",ret1)
10 #获取制定节点下的所有键
11 ret2=config.options("sections1")
12 print(ret2)
13 #获取指定节点下指定key值
14 v=config.get("section1","k1")
15 print(v)
16
17 # 检查、删除、添加节点
18 has_sec=config.has_section("section1")
19 print("是否存在节点：",has_sec)
20
21 #添加节点
22 config.add_section("sect1")
23 config.write(open("Hello","w"))
24 ret=config.sections()
25 print("查看节点是否添加成功:",ret)
26
27 #删除节点
28 config.remove_section("sect1")
29 config.write(open("Hello","w"))
30 ret=config.sections()
31 print("查看节点是否删除成功:",ret)
32
33 #检查、删除、设置指定组内的键值对
34 #检查是否存在键：k1
35 has_opt=config.has_option("sect1","k1")
36 print(has_opt)
37
38 #删除指定节点下的指定键
39 config.remove_option("sect1","k1")
40 config.write(open("Hello","w"))
41
42 #设置指定节点下的键值对
43 config.set("sect1","k10","123")
44 config.write(open("Hello","w"))
模块九：XML是实现不同语言或程序之间进行数据交换的协议
1 # #XML是实现不同语言或程序之间进行数据交换的协议
2 #1、解析XML
3 from xml.etree import ElementTree as ET
4 #打开文件，读取XML内容,xo为xml文件
5 str_xml=open("xo","r").read()
6 # #将字符串解析成xml特殊对象，root代指xml文件的根节点
7 root=ET.XML(str_xml)
8 print(root)
9 #
10 # #直接解析xml文件
11 tree=ET.parse("xo")
12 # #获取xml文件的根节点
13 root1=tree.getroot()
14 print(root1)
15 #
16 # #遍历xml文档的所有内容
17 # #顶层标签
18 print("获取顶层节点：",root1.tag)
19 #遍历xml文档的第二层
20 for child in root1:
21 #第二层节点的标签名和标签属性
22 print(child.tag,child.attrib)
23 #遍历xml 文档的第三层
24 for i in child:
25 print(i.tag,i.text)
26
27
28 #遍历xml中指定的节点year
29 for node in root1.iter("year"):
30 print(node.tag,node.text)
31
32 #修改节点的内容，由于修改节点时，均是在内存中进行，其不会影响文件中的内容
33 #因此如果需要修改，则需要将重新将内存中的文件写入到文件
34
35 for node in root1.iter("year"):
36 #将year节点中的内容自增1
37 new_year=int(node.text)+1
38 node.text=str(new_year)
39 #设置属性
40 node.set("name","eric")
41 node.set("age","99")
42 #删除属性
43 del node.attrib["name"]
44 #
45 # #保存文件
46 tree=ET.ElementTree(root1)
47 tree.write("newnew.xml",encoding="utf-8")
48 #
49 for country in root1.findall("country"):
50 #获取每一个country节点下rank节点的内容
51 rank=int(country.find("rank").text)
52 print(rank)
53
54 if rank>50:
55 root1.remove(country)
56 #
57 # #保存文件
58 tree=ET.ElementTree(root1)
59 tree.write("new1.xml",encoding="utf-8")
60
61 #创建XML文档
62 #创建根节点
63 root2=ET.Element("family")
64 #创建节点子节点
65 son1=ET.Element("son",{"name":"son1"})
66 son2=ET.Element("son",{"name":"son2"})
67 #在第一个子节点中创建两个孙节点
68 grandson1=ET.Element("grandson",{"name":"111"})
69 grandson2=ET.Element("grandson",{"name":"222"})
70 son1.append(grandson1)
71 son1.append(grandson2)
72
73 #将子节点添加到根节点中
74 root2.append(son1)
75 root2.append(son2)
76
77 tree=ET.ElementTree(root2)
78 tree.write("create1.xml",encoding="utf-8",short_empty_elements=False)
79
80 #创建xml文档方法二
81 root=ET.Element("family")
82 #创建子节点，调用根节点的makeelementff
83 son1=root.makeelement("son1",{"name":"son1"})
84 son2=root.makeelement("son2",{"name":"son2"})
85
86 #在son1中创建两个孙子节点
87 grandson11=son1.makeelement("grandson11",{"name":"555"})
88 grandson12=son1.makeelement("grandson12",{"name":"666"})
89
90 son1.append(grandson11)
91 son1.append(grandson12)
92
93 root.append(son1)
94 root.append(son2)
95
96 tree1=ET.ElementTree(root) #生成文档对象
97 tree1.write("create2.xml",encoding="utf-8",short_empty_elements=False) #将文档对象写入文件
98
99 #创建xml文档方法三
100 #利用ET的SubElement方法进行创建
101 root=ET.Element("family") #创建根节点
102 #创建第一个子节点
103 son1=ET.SubElement(root,"son1",attrib={"name":"son111"})
104 son2=ET.SubElement(root,"son2",attrib={"name":"son222"})
105
106 #在第一个子节点中创建孙节点
107 grandson1=ET.SubElement(son1,"grandson11",attrib={"name":"grandson666"})
108 grandson1.text="孙子"
109 et=ET.ElementTree(root)
110 et.write("test.xml",encoding="utf-8",xml_declaration=True,short_empty_elements=False)
111
112 #由上述例子的执行结果来看，均无法实现xml的缩进，若想要缩进的话，需要修改保存格式
113 from xml.dom import minidom
114 def prettify(elem):
115 """
116 将节点转换成字符串，并添加缩进
117 :param elem:要转换的对象
118 :return:
119 """
120 rough_string=ET.tostring(elem,"utf-8")
121 reparsed=minidom.parseString(rough_string)
122 return reparsed.toprettyxml(indent="\t")
123 #利用ET的SubElement方法进行创建
124 root=ET.Element("family") #创建根节点
125 #创建第一个子节点
126 son1=ET.SubElement(root,"son1",attrib={"name":"son111"})
127 son2=ET.SubElement(root,"son2",attrib={"name":"son222"})
128
129 #在第一个子节点中创建孙节点
130 grandson1=ET.SubElement(son1,"grandson11",attrib={"name":"grandson666"})
131 grandson1.text="孙子"
132
133 raw_str=prettify(root)
134 with open("test2.xml","w",encoding="utf-8") as f:
135 f.write(raw_str)
模块十：urllib和requests
1 import urllib.request
2 #python标准库中提供了：urllib等模块以供http请求，但是，他的API太渣，他是为另一个时代、另一个互联网
3 #创建的，他需要巨量的工作，甚至包括各种方法覆盖，来完成最简单的任务
4 #发送get请求
5 f=urllib.request.urlopen("http://www.qq.com")
6 result=f.read()
7 print(result)
8
9 #发送携带请求头的GET请求
10 req=urllib.request.Request("http://www.qq.com")
11 req.add_header("QQ","http://www.baidu.com")
12 r=urllib.request.urlopen(req)
13 result=r.read()
14 print(result)
15
16 #Requests 是使用 Apache2 Licensed 许可证的 基于Python开发的HTTP 库，其在Python内置模块的基础上进行了高度的封装，从
17 # 而使得Pythoner进行网络请求时，变得美好了许多，使用Requests可以轻而易举的完成浏览器可有的任何操作。
18 #get和post的区别
19 #get:获取服务器的信息，而不进行修改;是安全的和幂等的，例如新闻的读取
20 #post:可能改变服务器上的资源；例如对新闻的评论就是用post
21 import requests
22 ret=requests.get("http://www.qq.com")
23 print(ret.url)
24 print(ret.text)
25
26 payload={"key1":"value1","key2":"value2"}
27 ret=requests.get("http://sports.qq.com/nba/",params=payload)
28 print(ret.url)
29 print(ret.text)
30
31 #基本post实例
32 payload={"key1":"value1","key2":"value2"}
33 ret=requests.post("http://sports.qq.com/a/20161027/023124.htm",data=payload)
34 print(ret.text)
35
36 import json
37 url="http://sports.qq.com/a/20161027/023124.htm"
38 payload={"some":"data"}
39 headers={‘content-type‘: ‘application/json‘}
40 ret=requests.post(url,data=json.dumps(payload),headers=headers)
41 print(ret.text)
42 print(ret.cookies)
43
44 #检测QQ是否在线
45 import urllib
46 import requests
47 from xml.etree import ElementTree as ET
48 r=requests.get("http://www.webxml.com.cn//webservices/qqOnlineWebService.asmx/qqCheckOnline?qqCode=172560199")
49 result=r.text
50 print(result)
51 # #解析xml格式的内容
52 node=ET.XML(result)
53 print(node.text)
54 # #获取内容
55 if node.text=="Y":
56 print("在线")
57 else:
58 print("离线")
59
60 #查看火车停靠信息
61 r=requests.get("http://www.webxml.com.cn/WebServices/TrainTimeWebService.asmx/getDetailInfoByTrainCode?TrainCode=G651&UserID=")
62 result=r.text
63 print(r.text)
64 # #解析xml格式内容
65 root=ET.XML(result)
66 print(root.text)
67 for node in root.iter("TrainDetailInfo"):
68 print(node.find("TrainStation").text)
69 print("到达时间：",node.find("ArriveTime").text,"发车时间：",node.find("StartTime").text)
70
71 #查询手机号归属地
72 r=requests.get("http://ws.webxml.com.cn/WebServices/MobileCodeWS.asmx/getMobileCodeInfo?mobileCode=13783417293&UserID=")
73 result=r.text
74 print(result)
75 node=ET.XML(result)
76 print(node.text)
模块十一：logging 用于便捷记录日志且线程安全的模块
1 import logging
2 logging.basicConfig(filename="log.log",
3 format="%(asctime)s-%(name)s-%(levelname)s-%(module)s:%(message)s",
4 datefmt="%Y-%m-%d %H:%M:%S %p",
5 level=10)
6 logging.debug("debug")
7 logging.info("info")
8 logging.warning("warning")
9 logging.error("error")
10 logging.critical("critical")
11 logging.log(10,"log")
12 #上述记录日志的功能，只能讲日志记录在单文件中，如果想要设置多个日志文件，上述方法无法完成，需要自定义文件和日志操作对象
13 #定义文件
14 file_1=logging.FileHandler("l1.log","a",encoding="utf-8")
15 fmt=logging.Formatter(fmt="%(asctime)s-%(name)s-%(levelname)s-%(module)s:%(message)s")
16 file_1.setFormatter(fmt)
17
18 file_2=logging.FileHandler("l2.log","a",encoding="utf-8")
19 fmt=logging.Formatter()
20 file_2.setFormatter(fmt)
21 #
22 # #定义日志
23 logger1=logging.Logger("s1",level=logging.ERROR)
24 logger1.addHandler(file_1)
25 logger1.addHandler(file_2)
26 #
27 # #写日志
28 logger1.critical("2222")
29
30 file_21=logging.FileHandler("l3.log","a",encoding="utf-8")
31 fmt=logging.Formatter()
32 file_21.setFormatter(fmt)
33
34 logger2=logging.Logger("s2",level=logging.INFO)
35 logger2.addHandler(file_21)
36 logger2.critical("6666")
模块十二：shutil 高级的文件、文件夹、压缩包处理模块
1 import shutil
2 #将一个文件的内容拷贝到另一个文件中
3 shutil.copyfileobj(open("new1.xml","r"),open("new3.xml","w"))
4 #拷贝文件
5 shutil.copyfile("new1.xml","new6.xml")
6
7 #压缩
8 # shutil.make_archive("压缩包的文件名或路径","format 保存的格式，zip,gtar等","root_dir：要压缩的文件夹路径",
9 # "owner:用户","group:组","logger:用于记录日志，通常是logging.Logger对象 ")
10
11 #解压缩 shutil对压缩包的处理是调用ZipFile和TarFile两个模块
12 import zipfile
13 #压缩
14 z=zipfile.ZipFile("aa.zip","w")
15 z.write("aa.log")
16 z.write("data.data")
17 z.close()
18 #解压
19 z=zipfile.ZipFile("aa.zip","r")
20 z.extractall()
21 z.close()
22
23 import tarfile
24
25 # 压缩
26 tar = tarfile.open(‘your.tar‘,‘w‘)
27 tar.add(‘/Users/wupeiqi/PycharmProjects/bbs2.log‘, arcname=‘bbs2.log‘)
28 tar.add(‘/Users/wupeiqi/PycharmProjects/cmdb.log‘, arcname=‘cmdb.log‘)
29 tar.close()
30
31 # 解压
32 tar = tarfile.open(‘your.tar‘,‘r‘)
33 tar.extractall() # 可设置解压地址
34 tar.close()
时间： 2024-10-29 04:32:54