常用的基础模块介绍
模塊，是用一堆代碼來實現某個功能的代碼集合
類似于函數式編程和面向過程編程，函數式編程則完成一個功能，其他代碼來調用該功能，提供了代碼的重用性和代碼間的耦合性
而對于一個復雜的功能，可能需要多個函數才能完成，這些文件組成的代碼集合稱為模塊
模塊分為三種：自定義模塊；內置標準模塊；開源模塊
模塊一：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))
View Code
模塊二：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)))
View Code
模塊三：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)))
View Code
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下為"
",Linux下為"
"
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所指向的文件或者目錄的最后修改時間
View Code
模塊四：sys 用來提供解釋器的相關操作
1 import sys #用來提供對解釋器的相關操作
2 print("返回模塊的搜索路徑，初始化時使用環境變量的值：",sys.path)
3 print(sys.argv) #命令行參數list,第一個元素是程序本身路徑
View Code
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 = '%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)
View Code
模塊五：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())
View Code
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())
View 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)
View Code
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)
View Code
模塊七：正則表達式 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,172560199@sina.com"
33 m=re.search("((2[0-4]d|25[0-5]|[01]?dd?).){3}(2[0-4]d|25[0-5]|[01]?dd?)",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_-]+@[a-zA-Z0-9_-]+(.[a-zA-Z0-9_-]+)+",str_ip)
38 print("匹配到的郵箱是：",m2.group())
View Code
模塊八：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"))
View Code
模塊九：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=" ")
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)
View Code
模塊十：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)
View Code
模塊十一：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")
View Code
模塊十二：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()
View Code
總結
- 上一篇： 北斗星13寸轮毂参数？
- 下一篇： AD采样注意的事项（转）