經常使用模塊總結

時間 2019-12-02

標籤經常使用模塊總結简体版

原文原文鏈接

介紹模塊

什麼是模塊？

常見的場景：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴。java

但其實import加載的模塊分爲四個通用類別：　python

　　1 使用python編寫的代碼（.py文件）正則表達式

　　2 已被編譯爲共享庫或DLL的C或C++擴展算法

　　3 包好一組模塊的包shell

　　4 使用C編寫並連接到python解釋器的內置模塊數據庫

爲什麼要使用模塊？

若是你退出python解釋器而後從新進入，那麼你以前定義的函數或者變量都將丟失，所以咱們一般將程序寫到文件中以便永久保存下來，須要時就經過python test.py方式去執行，此時test.py被稱爲腳本script。編程

隨着程序的發展，功能愈來愈多，爲了方便管理，咱們一般將程序分紅一個個的文件，這樣作程序的結構更清晰，方便管理。這時咱們不只僅能夠把這些文件當作腳本去執行，還能夠把他們當作模塊來導入到其餘的模塊中，實現了功能的重複利用。json

經常使用模塊　

時間模塊

在Python中，一般有這三種方式來表示時間：時間戳、元組(struct_time)、格式化的時間字符串：緩存

(1)時間戳(timestamp) ：一般來講，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。咱們運行「type(time.time())」，返回的是float類型。安全

(2)格式化的時間字符串(Format String)： ‘1999-12-06’

%y 兩位數的年份表示（00-99）
%Y 四位數的年份表示（000-9999）
%m 月份（01-12）
%d 月內中的一天（0-31）
%H 24小時制小時數（0-23）
%I 12小時制小時數（01-12）
%M 分鐘數（00=59）
%S 秒（00-59）
%a 本地簡化星期名稱
%A 本地完整星期名稱
%b 本地簡化的月份名稱
%B 本地完整的月份名稱
%c 本地相應的日期表示和時間表示
%j 年內的一天（001-366）
%p 本地A.M.或P.M.的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %號自己

View Code

(3)元組(struct_time) ：struct_time元組共有9個元素共九個元素:(年，月，日，時，分，秒，一年中第幾周，一年中第幾天等）

索引（Index）	屬性（Attribute）	值（Values）
0	tm_year（年）	好比2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（時）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 60
6	tm_wday（weekday）	0 - 6（0表示週一）
7	tm_yday（一年中的第幾天）	1 - 366
8	tm_isdst（是不是夏令時）	默認爲0

首先，咱們先導入time模塊，來認識一下python中表示時間的幾種格式：

#導入時間模塊

>>>import time

#時間戳
>>>time.time()
1500875844.800804

#時間字符串
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 13:54:37'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'

#時間元組:localtime將一個時間戳轉換爲當前時區的struct_time
time.localtime()
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24,
　　　　　　　　　　tm_hour=13, tm_min=59, tm_sec=37, 
                 tm_wday=0, tm_yday=205, tm_isdst=0)

View Code

小結：時間戳是計算機可以識別的時間；時間字符串是人可以看懂的時間；元組則是用來操做時間的

幾種格式之間的轉換

#時間戳-->結構化時間
#time.gmtime(時間戳)    #UTC時間，與英國倫敦當地時間一致
#time.localtime(時間戳) #當地時間。例如咱們如今在北京執行這個方法：與UTC時間相差8小時，UTC時間+8小時 = 北京時間 
>>>time.gmtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)
>>>time.localtime(1500000000)
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0)

#結構化時間-->時間戳　
#time.mktime(結構化時間)
>>>time_tuple = time.localtime(1500000000)
>>>time.mktime(time_tuple)
1500000000.0

#結構化時間-->字符串時間
#time.strftime("格式定義","結構化時間")  結構化時間參數若不傳，則顯示當前時間
>>>time.strftime("%Y-%m-%d %X")
'2017-07-24 14:55:36'
>>>time.strftime("%Y-%m-%d",time.localtime(1500000000))
'2017-07-14'

#字符串時間-->結構化時間

#time.strptime(時間字符串,字符串對應格式)
>>>time.strptime("2017-03-16","%Y-%m-%d")
time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1)
>>>time.strptime("07/24/2017","%m/%d/%Y")
time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)

View Code

import time
true_time=time.mktime(time.strptime('2017-09-11 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2017-09-12 11:00:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('過去了%d年%d月%d天%d小時%d分鐘%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

View Code

random模塊

>>> import random
#隨機小數
>>> random.random()      # 大於0且小於1之間的小數
0.7664338663654585
>>> random.uniform(1,3) #大於1小於3的小數
1.6270147180533838
#恆富：發紅包

#隨機整數
>>> random.randint(1,5)  # 大於等於1且小於等於5之間的整數
>>> random.randrange(1,10,2) # 大於等於1且小於10之間的奇數


#隨機選擇一個返回
>>> random.choice([1,'23',[4,5]])  # #1或者23或者[4,5]
#隨機選擇多個返回，返回的個數爲函數的第二個參數
>>> random.sample([1,'23',[4,5]],2) # #列表元素任意2個組合
[[4, 5], '23']


#打亂列表順序
>>> item=[1,3,5,7,9]
>>> random.shuffle(item) # 打亂次序
>>> item
[5, 1, 3, 7, 9]
>>> random.shuffle(item)
>>> item
[5, 9, 7, 1, 3]

View Code

os模塊

'''
os.getcwd() 獲取當前工做目錄，即當前python腳本工做的目錄路徑
os.chdir("dirname")  改變當前腳本工做目錄；至關於shell下cd
os.curdir  返回當前目錄: ('.')
os.pardir  獲取當前目錄的父目錄字符串名：('..')
os.makedirs('dirname1/dirname2')    可生成多層遞歸目錄
os.removedirs('dirname1')    若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，依此類推
os.mkdir('dirname')    生成單級目錄；至關於shell中mkdir dirname
os.rmdir('dirname')    刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中rmdir dirname
os.listdir('dirname')    列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove()  刪除一個文件
os.rename("oldname","newname")  重命名文件/目錄
os.stat('path/filename')  獲取文件/目錄信息
os.sep    輸出操做系統特定的路徑分隔符，win下爲"\\",Linux下爲"/"
os.linesep    輸出當前平臺使用的行終止符，win下爲"\t\n",Linux下爲"\n"
os.pathsep    輸出用於分割文件路徑的字符串 win下爲;,Linux下爲:
os.name    輸出字符串指示當前使用平臺。win->'nt'; Linux->'posix'
os.system("bash command")  運行shell命令，直接顯示
os.popen("bash command).read()  運行shell命令，獲取執行結果
os.environ  獲取系統環境變量

os.path
os.path.abspath(path) 返回path規範化的絕對路徑 os.path.split(path) 將path分割成目錄和文件名二元組返回 os.path.dirname(path) 返回path的目錄。其實就是os.path.split(path)的第一個元素 os.path.basename(path) 返回path最後的文件名。如何path以／或\結尾，那麼就會返回空值。
                        即os.path.split(path)的第二個元素
os.path.exists(path)  若是path存在，返回True；若是path不存在，返回False
os.path.isabs(path)  若是path是絕對路徑，返回True
os.path.isfile(path)  若是path是一個存在的文件，返回True。不然返回False
os.path.isdir(path)  若是path是一個存在的目錄，則返回True。不然返回False
os.path.join(path1[, path2[, ...]])  將多個路徑組合後返回，第一個絕對路徑以前的參數將被忽略
os.path.getatime(path)  返回path所指向的文件或者目錄的最後訪問時間
os.path.getmtime(path)  返回path所指向的文件或者目錄的最後修改時間
os.path.getsize(path) 返回path的大小

View Code

sys模塊

sys.argv           命令行參數List，第一個元素是程序自己路徑
sys.exit(n)        退出程序，正常退出時exit(0),錯誤退出sys.exit(1)
sys.version        獲取Python解釋程序的版本信息
sys.path           返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值
sys.platform       返回操做系統平臺名稱

序列化模塊

好比，咱們在python代碼中計算的一個數據須要給另一段程序使用，那咱們怎麼給？
如今咱們能想到的方法就是存在文件裏，而後另外一個python程序再從文件裏讀出來。
可是咱們都知道，對於文件來講是沒有字典這個概念的，因此咱們只能將數據轉換成字典放到文件中。
你必定會問，將字典轉換成一個字符串很簡單，就是str(dic)就能夠辦到了，爲何咱們還要學習序列化模塊呢？
沒錯序列化的過程就是從dic 變成str(dic)的過程。如今你能夠經過str(dic)，將一個名爲dic的字典轉換成一個字符串，
可是你要怎麼把一個字符串轉換成字典呢？
聰明的你確定想到了eval()，若是咱們將一個字符串類型的字典str_dic傳給eval，就會獲得一個返回的字典類型了。
eval()函數十分強大，可是eval是作什麼的？e官方demo解釋爲：將字符串str當成有效的表達式來求值並返回計算結果。
ＢＵＴ！強大的函數有代價。安全性是其最大的缺點。
想象一下，若是咱們從文件中讀出的不是一個數據結構，而是一句"刪除文件"相似的破壞性語句，那麼後果實在不堪設設想。
而使用eval就要擔這個風險。
因此，咱們並不推薦用eval方法來進行反序列化操做(將str轉換成python中的數據結構)

View Code

序列化的目的

一、以某種存儲形式使自定義對象持久化；

二、將對象從一個地方傳遞到另外一個地方。

三、使程序更具維護性。

json

Json模塊提供了四個功能：dumps、dump、loads、load

import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)  #序列化：將一個字典轉換成一個字符串
print(type(str_dic),str_dic)  #<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"}
#注意，json轉換完的字符串類型的字典中的字符串是由""表示的

dic2 = json.loads(str_dic)  #反序列化：將一個字符串格式的字典轉換成一個字典
#注意，要用json的loads功能處理的字符串類型的字典中的字符串必須由""表示
print(type(dic2),dic2)  #<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}


list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) #也能夠處理嵌套的數據類型 
print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

View Code

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一個文件句柄，直接將字典轉換成json字符串寫入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一個文件句柄，直接將文件中的json字符串轉換成數據結構返回
f.close()
print(type(dic2),dic2)

View Code

import json
f = open('file','w')
json.dump({'國籍':'中國'},f)
ret = json.dumps({'國籍':'中國'})
f.write(ret+'\n')
json.dump({'國籍':'美國'},f,ensure_ascii=False)
ret = json.dumps({'國籍':'美國'},ensure_ascii=False)
f.write(ret+'\n')
f.close()

View Code

Serialize obj to a JSON formatted str.(字符串表示的json對象) 
Skipkeys：默認值是False，若是dict的keys內的數據不是python的基本類型(str,unicode,int,long,float,bool,None)，設置爲False時，就會報TypeError的錯誤。此時設置成True，則會跳過這類key 
ensure_ascii:，當它爲True的時候，全部非ASCII碼字符顯示爲\uXXXX序列，只需在dump時將ensure_ascii設置爲False便可，此時存入json的中文便可正常顯示。) 
If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
indent：應該是一個非負的整型，若是是0就是頂格分行顯示，若是爲空就是一行最緊湊顯示，不然會換行且按照indent的數值顯示前面的空白分行顯示，這樣打印出來的json數據也叫pretty-printed json 
separators：分隔符，其實是(item_separator, dict_separator)的一個元組，默認的就是(‘,’,’:’)；這表示dictionary內keys之間用「,」隔開，而KEY和value之間用「：」隔開。 
default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
sort_keys：將數據根據keys的值進行排序。 
To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

View Code

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

View Code

pickle

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二進制內容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

import time
struct_time  = time.localtime(1000000000)
print(struct_time)
f = open('pickle_file','wb')
pickle.dump(struct_time,f)
f.close()

f = open('pickle_file','rb')
struct_time2 = pickle.load(f)
print(struct_time2.tm_year)

json & pickle 模塊

用於序列化的兩個模塊

json，用於字符串和 python數據類型間進行轉換
pickle，用於python特有的類型和 python的數據類型間進行轉換

pickle模塊提供了四個功能：dumps、dump(序列化，存）、loads（反序列化，讀）、load （不只能夠序列化字典，列表...能夠把python中任意的數據類型序列化）

這時候機智的你又要說了，既然pickle如此強大，爲何還要學json呢？
這裏咱們要說明一下，json是一種全部的語言均可以識別的數據結構。
若是咱們將一個字典或者序列化成了一個json存在文件裏，那麼java代碼或者js代碼也能夠拿來用。
可是若是咱們用pickle進行序列化，其餘語言就不能讀懂這是什麼了～
因此，若是你序列化的內容是列表或者字典，咱們很是推薦你使用json模塊
但若是出於某種緣由你不得不序列化其餘的數據類型，而將來你還會用python對這個數據進行反序列化的話，那麼就可使用pickle

shelve

shelve也是python提供給咱們的序列化工具，比pickle用起來更簡單一些。
shelve只提供給咱們一個open方法，是用key來訪問的，使用起來和字典相似。

shelve

這個模塊有個限制，它不支持多個應用同一時間往同一個DB進行寫操做。因此當咱們知道咱們的應用若是隻進行讀操做，咱們可讓shelve經過只讀方式打開DB

shelve只讀

因爲shelve在默認狀況下是不會記錄待持久化對象的任何修改的，因此咱們在shelve.open()時候須要修改默認參數，不然對象的修改不會保存。

設置writeback

writeback方式有優勢也有缺點。優勢是減小了咱們出錯的機率，而且讓對象的持久化對用戶更加的透明瞭；但這種方式並非全部的狀況下都須要，首先，使用writeback之後，shelf在open()的時候會增長額外的內存消耗，而且當DB在close()的時候會將緩存中的每個對象都寫入到DB，這也會帶來額外的等待時間。由於shelve沒有辦法知道緩存中哪些對象修改了，哪些對象沒有修改，所以全部的對象都會被寫入。

shutil

高級的文件、文件夾、壓縮包處理模塊

shutil.copyfileobj(fsrc, fdst[, length])
將文件內容拷貝到另外一個文件中

1 import shutil
2  
3 shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w'))

shutil.copyfile(src, dst)
拷貝文件

1 shutil.copyfile('f1.log', 'f2.log') #目標文件無需存在

shutil.copymode(src, dst)
僅拷貝權限。內容、組、用戶均不變

1 shutil.copymode('f1.log', 'f2.log') #目標文件必須存在

shutil.copystat(src, dst)
僅拷貝狀態的信息，包括：mode bits, atime, mtime, flags

1 shutil.copystat('f1.log', 'f2.log') #目標文件必須存在

shutil.copy(src, dst)
拷貝文件和權限

1 import shutil
2  
3 shutil.copy('f1.log', 'f2.log')

shutil.copy2(src, dst)
拷貝文件和狀態信息

1 import shutil
2  
3 shutil.copy2('f1.log', 'f2.log')

shutil.ignore_patterns(*patterns)
shutil.copytree(src, dst, symlinks=False, ignore=None)
遞歸的去拷貝文件夾

1 import shutil
2  
3 shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) #目標目錄不能存在，注意對folder2目錄父級目錄要有可寫權限，ignore的意思是排除

拷貝軟鏈接

shutil.rmtree(path[, ignore_errors[, onerror]])
遞歸的去刪除文件

1 import shutil
2  
3 shutil.rmtree('folder1')

shutil.move(src, dst)
遞歸的去移動文件，它相似mv命令，其實就是重命名。

1 import shutil
2  
3 shutil.move('folder1', 'folder3')

shutil.make_archive(base_name, format,...)

建立壓縮包並返回文件路徑，例如：zip、tar

base_name：壓縮包的文件名，也能夠是壓縮包的路徑。只是文件名時，則保存至當前目錄，不然保存至指定路徑，
如 data_bak =>保存至當前路徑
如：/tmp/data_bak =>保存至/tmp/
format：壓縮包種類，「zip」, 「tar」, 「bztar」，「gztar」
root_dir：要壓縮的文件夾路徑（默認當前目錄）
owner：用戶，默認當前用戶
group：組，默認當前組
logger：用於記錄日誌，一般是logging.Logger對象

1 #將 /data 下的文件打包放置當前程序目錄
2 import shutil
3 ret = shutil.make_archive("data_bak", 'gztar', root_dir='/data')
4   
5   
6 #將 /data下的文件打包放置 /tmp/目錄
7 import shutil
8 ret = shutil.make_archive("/tmp/data_bak", 'gztar', root_dir='/data')

shutil 對壓縮包的處理是調用 ZipFile 和 TarFile 兩個模塊來進行的，詳細：

zipfile壓縮解壓縮

tarfile壓縮解壓縮

XML

    什麼XML:全稱 可擴展標記語言    標記指的是表明某種含義的字符 XML<>
爲何須要XML
    爲可以在不一樣的平臺間繼續數據的交換
    爲了使交換的數據能讓對方看懂 就須要按照必定的語法規範來書寫
XML語法格式:
    1、任何的起始標籤都必須有一個結束標籤。
        <tagname></tagname>
        <tagname></tagname>
        <tagname/>  簡化寫法

    2、能夠採用另外一種簡化語法，能夠在一個標籤中同時表示起始和結束標籤。這種語法是在大於符號以前緊跟一個斜線（/），例如<百度百科詞條/>。XML解析器會將其翻譯成<百度百科詞條></百度百科詞條>。
    3、標籤必須按合適的順序進行嵌套，因此結束標籤必須按鏡像順序匹配起始標籤，例如這是一串百度百科中的樣例字符串。這比如是將起始和結束標籤看做是數學中的左右括號：在沒有關閉全部的內部括號以前，是不能關閉外面的括號的。
        <tag1>
            <tag2>
                <tag3>
                </tag3>
            </tag2>
        </tag1>    大白話  關閉標籤應該從內往外 一層一層關閉 順序不能亂
    4、全部的特性都必須有值。
        特性指的是屬性
        <person name="">
        </person>
    5、全部的特性都必須在值的周圍加上雙引號。

    注意:最外層有且只有一個標籤 這個標籤稱之爲根標籤
         第一行應該有文檔聲明 用於高速計算機怎麼理解
          例如:<?xml version="1.0" encoding="utf-8"?>
          當標籤嵌套的時候會出現層級關係  若是一個標籤不被任何別的標籤包裹 那他就是根標籤(最外層)
    使用場景:
        1.配置文件
        2.常規的數據交換  例如從服務器獲取一段新聞
    與json的區別:        
　　　　　做用是同樣的 都是一種數據格式
        xml比json先誕生
        json的數據比xml小
        目前json是主流

    python中的xml處理
        使用到的模塊
        ElmentTree 表示整個文件的元素樹

        Elment 表示一個節點
            屬性
            1.text      開始標籤和結束標籤中間的文本
            2.attrib    全部的屬性     字典類型
            3.tag       標籤的名字
            方法
                get 獲取某個屬性的值
        1.解析XML
            查找標籤
            find      在子標籤中獲取名字匹配第一個
            findall   在子標籤中獲取名字匹配的全部標籤
            iter(tagname)      在全文中查找[匹配的全部標籤 返回一個迭代器
        2.生成XML
            用ElmentTree
            parse()  解析一個文件
            getroot() 獲取根標籤
            write()  寫入到文件
        3.修改xml
            set 一個屬性
            remove 一個標籤            append 一個標籤
練習：

有一個people.xml文件，遍歷輸出xml文件中的全部數據

import xml.etree.ElementTree as et
tree = et.parse("people.xml")
root = tree.getroot() # Peoples
print(root.tag)
print(root.text)
print(root.attrib['value'])
print(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>")
for i in root: # i 兩個People
    print(i.attrib['flag'])
    print(i.find('name').text)
    print(i.find('age').text)
    print(i.find('gender').text)
    print("----------------------------------------")

View Code

xml文件

<?xml version="1.0" encoding="UTF-8"?>

-<Peoples value="嘉賓">

-<![CDATA[
        <a></a>
    ]]>存放全部嘉賓的xml文件 

-<People flag="一號男嘉賓">

<name>張三</name>

<age>20</age>

<gender>男</gender>

</People>


-<People flag="一號女嘉賓">

<name>李四</name>

<age>18</age>

<gender>女</gender>

</People>

</Peoples>

View Code

總結：

1.標籤:被<>包裹以字母開頭能夠包含合法字符能夠被解析的標記
2.xml中有且只能出現一個根標籤
3.xml中全部標籤都是自定義標籤
4.xml全部標籤都擁有結束標籤
5.xml中標籤能夠擁有屬性,內容與子標籤
6.單雙標籤:單主功能(屬性) 雙主內容(內容與子標籤)

hashlib 　

hash是什麼?
是一種算法用於將任意長度的數據,壓縮映射到一段固定長度的字符 (提取特徵)

hash的特色:
1.輸入數據不一樣,獲得的hash值有可能相同
2.不能經過hash值來獲得輸入的值
3.若是算法相同,不管輸入的數據長度是多少,獲得的hash值長度相同

由於以上特色常將hash算法用於加密和文件校驗
輸入用戶名和密碼在代碼中與數據庫中的判斷是否相同
思考當你的數據須要在網絡中傳遞時就可能會受到網絡攻擊
黑客經過抓包工具就能截獲你發送和接收的數據
因此你的數據若是涉及到隱私就應該先加密在發送
加密的方式有不少
經常使用的MD5就是一種hash算法
經常使用的提高安全性的手段就是加鹽
就是把你加密前的數據作一些改動例如把順序反過來

"""
3.模擬加密過程
        1）帳號密碼由用戶鍵盤輸入
        2）對獲得的帳號密碼進行md5方式加密處理(採起加鹽)
        3）提早創建基本的碰撞測試庫
        4）對於用戶輸入的帳號密碼進行反饋
            -- 解密成功
            -- 解密失敗
"""
import hashlib
usr = input("帳號:")
ps = input("密碼:")
# 加鹽
top = "12345"
bottom = "qwert"
data = top + ps + bottom + usr
# 鎖加密
lock = hashlib.md5()
lock.update(data.encode("utf-8"))
# print(lock.hexdigest())
#8c649136390a2c204c924d3b9a1387e4 5580934aca25f70dc8c874259690a213
lib = ["8c649136390a2c204c924d3b9a1387e4", "5580934aca25f70dc8c874259690a213"]
# 碰撞解密
# for i in lib:
#     if i == lock.hexdigest():
#         print("解密成功")
#         break
# else:
#     print("解密失敗")

tag = "解密失敗"
for i in lib:
    if i == lock.hexdigest():
        tag = "解密成功"
        break
print(tag)

View Code8

RE模塊

簡介

正則表達式自己是一種小型的、高度專業化的編程語言，而在python中，經過內嵌集成re模塊，程序媛們能夠直接調用來實現正則匹配。正則表達式模式被編譯成一系列的字節碼，而後由用C編寫的匹配引擎執行。

普通字符和11個元字符：

普通字符	匹配自身	abc	abc
.	匹配任意除換行符"\n"外的字符(在DOTALL模式中也能匹配換行符	a.c	abc
\	轉義字符，使後一個字符改變原來的意思	a\.c;a\\c	a.c;a\c
*	匹配前一個字符0或屢次	abc*	ab;abccc
+	匹配前一個字符1次或無限次	abc+	abc;abccc
?	匹配一個字符0次或1次	abc?	ab;abc
^	匹配字符串開頭。在多行模式中匹配每一行的開頭	^abc	abc
$	匹配字符串末尾，在多行模式中匹配每一行的末尾	abc$	abc
\|	或。匹配\|左右表達式任意一個，從左到右匹配，若是\|沒有包括在()中，則它的範圍是整個正則表達式	abc\|def	abc def
{}	{m}匹配前一個字符m次，{m,n}匹配前一個字符m至n次，若省略n，則匹配m至無限次	ab{1,2}c	abc abbc
[]	字符集。對應的位置能夠是字符集中任意字符。字符集中的字符能夠逐個列出，也能夠給出範圍，如[abc]或[a-c]。[^abc]表示取反，即非abc。全部特殊字符在字符集中都失去其原有的特殊含義。用\反斜槓轉義恢復特殊字符的特殊含義。	a[bcd]e	abe ace ade
()	被括起來的表達式將做爲分組，從表達式左邊開始沒遇到一個分組的左括號「（」，編號+1. 分組表達式做爲一個總體，能夠後接數量詞。表達式中的\|僅在該組中有效。	(abc){2} a(123\|456)c	abcabc a456c

這裏須要強調一下反斜槓\的做用：

反斜槓後邊跟元字符去除特殊功能；（即將特殊字符轉義成普通字符）
反斜槓後邊跟普通字符實現特殊功能；（即預約義字符）
引用序號對應的字組所匹配的字符串。

二、預約義字符集（能夠寫在字符集[...]中）

\d	數字:[0-9]	a\bc	a1c
\D	非數字:[^\d]	a\Dc	abc
\s	匹配任何空白字符:[<空格>\t\r\n\f\v]	a\sc	a c
\S	非空白字符:[^\s]	a\Sc	abc
\w	匹配包括下劃線在內的任何字字符:[A-Za-z0-9_]	a\wc	abc
\W	匹配非字母字符，即匹配特殊字符	a\Wc	a c
\A	僅匹配字符串開頭,同^	\Aabc	abc
\Z	僅匹配字符串結尾，同$	abc\Z	abc
\b	匹配\w和\W之間，即匹配單詞邊界匹配一個單詞邊界，也就是指單詞和空格間的位置。例如， 'er\b' 能夠匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。	\babc\b a\b!bc	空格abc空格 a!bc
\B	[^\b]	a\Bbc	abc

三、特殊分組用法：

(?P<name>)	分組，除了原有的編號外再指定一個額外的別名	(?P<id>abc){2}	abcabc
(?P=name)	引用別名爲<name>的分組匹配到字符串	(?P<id>\d)abc(?P=id)	1abc1 5abc5
\<number>	引用編號爲<number>的分組匹配到字符串	(\d)abc\1	1abc1 5abc5

3、re模塊中經常使用功能函數

一、compile()

編譯正則表達式模式，返回一個對象的模式。（能夠把那些經常使用的正則表達式編譯成正則表達式對象，這樣能夠提升一點效率。）

格式：

re.compile(pattern,flags=0)

pattern: 編譯時用的表達式字符串。

flags 編譯標誌位，用於修改正則表達式的匹配方式，如：是否區分大小寫，多行匹配等。經常使用的flags有：

標誌	含義
re.S(DOTALL)	使.匹配包括換行在內的全部字符
re.I（IGNORECASE）	使匹配對大小寫不敏感
re.L（LOCALE）	作本地化識別（locale-aware)匹配，法語等
re.M(MULTILINE)	多行匹配，影響^和$
re.X(VERBOSE)	該標誌經過給予更靈活的格式以便將正則表達式寫得更易於理解
re.U	根據Unicode字符集解析字符，這個標誌影響\w,\W,\b,\B

import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*')
print(rr.findall(tt))   #查找全部包含'oo'的單詞
執行結果以下：
['good', 'cool']

二、match()

決定RE是否在字符串剛開始的位置匹配。//注：這個方法並非徹底匹配。當pattern結束時若string還有剩餘字符，仍然視爲成功。想要徹底匹配，能夠在表達式末尾加上邊界匹配符'$'

格式：

re.match(pattern, string, flags=0)

print(re.match('com','comwww.runcomoob').group())
print(re.match('com','Comwww.runcomoob',re.I).group())
執行結果以下：
com
com

三、search()

格式：

re.search(pattern, string, flags=0)

re.search函數會在字符串內查找模式匹配,只要找到第一個匹配而後返回，若是字符串沒有匹配，則返回None。

print(re.search('\dcom','www.4comrunoob.5com').group())
執行結果以下：
4com

*注：match和search一旦匹配成功，就是一個match object對象，而match object對象有如下方法：

group() 返回被 RE 匹配的字符串
start() 返回匹配開始的位置
end() 返回匹配結束的位置
span() 返回一個元組包含匹配 (開始,結束) 的位置
group() 返回re總體匹配的字符串，能夠一次輸入多個組號，對應組號匹配的字符串。

a. group（）返回re總體匹配的字符串，
b. group (n,m) 返回組號爲n，m所匹配的字符串，若是組號不存在，則返回indexError異常
c.groups（）groups() 方法返回一個包含正則表達式中全部小組字符串的元組，從 1 到所含的小組號，一般groups()不須要參數，返回一個元組，元組中的元就是正則表達式中定義的組。

import re
a = "123abc456"
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0))   #123abc456,返回總體
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1))   #123
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2))   #abc
 print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3))   #456
###group(1) 列出第一個括號匹配部分，group(2) 列出第二個括號匹配部分，group(3) 列出第三個括號匹配部分。###

四、findall()

re.findall遍歷匹配，能夠獲取字符串中全部匹配的字符串，返回一個列表。

格式：

re.findall(pattern, string, flags=0)

p = re.compile(r'\d+')
print(p.findall('o1n2m3k4'))
執行結果以下：
['1', '2', '3', '4']

import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*')
print(rr.findall(tt))
print(re.findall(r'(\w)*oo(\w)',tt))#()表示子表達式 
執行結果以下：
['good', 'cool']
[('g', 'd'), ('c', 'l')]

五、finditer()

搜索string，返回一個順序訪問每個匹配結果（Match對象）的迭代器。找到 RE 匹配的全部子串，並把它們做爲一個迭代器返回。

格式：

re.finditer(pattern, string, flags=0)

iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...')
for i in iter:
    print(i)
    print(i.group())
    print(i.span())
執行結果以下：
<_sre.SRE_Match object; span=(0, 2), match='12'>
12
(0, 2)
<_sre.SRE_Match object; span=(8, 10), match='44'>
44
(8, 10)
<_sre.SRE_Match object; span=(24, 26), match='11'>
11
(24, 26)
<_sre.SRE_Match object; span=(31, 33), match='10'>
10
(31, 33)

六、split()

按照可以匹配的子串將string分割後返回列表。

可使用re.split來分割字符串，如：re.split(r'\s+', text)；將字符串按空格分割成一個單詞列表。

格式：

re.split(pattern, string[, maxsplit])

maxsplit用於指定最大分割次數，不指定將所有分割。

print(re.split('\d+','one1two2three3four4five5'))
執行結果以下：
['one', 'two', 'three', 'four', 'five', '']

七、sub()

使用re替換string中每個匹配的子串後返回替換後的字符串。

格式：

re.sub(pattern, repl, string, count)

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r'\s+', '-', text))
執行結果以下：
JGood-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on...

其中第二個函數是替換後的字符串；本例中爲'-'

第四個參數指替換個數。默認爲0，表示每一個匹配項都替換。

re.sub還容許使用函數對匹配項的替換進行復雜的處理。

如：re.sub(r'\s', lambda m: '[' + m.group(0) + ']', text, 0)；將字符串中的空格' '替換爲'[ ]'。

import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r'\s+', lambda m:'['+m.group(0)+']', text,0))
執行結果以下：
JGood[ ]is[ ]a[ ]handsome[ ]boy,[ ]he[ ]is[ ]cool,[ ]clever,[ ]and[ ]so[ ]on...

八、subn()

返回替換次數

格式：

subn(pattern, repl, string, count=0, flags=0)

print(re.subn('[1-2]','A','123456abcdef'))
print(re.sub("g.t","have",'I get A,  I got B ,I gut C'))
print(re.subn("g.t","have",'I get A,  I got B ,I gut C'))
執行結果以下：
('AA3456abcdef', 2)
I have A,  I have B ,I have C
('I have A,  I have B ,I have C', 3)

4、一些注意點

一、re.match與re.search與re.findall的區別：

re.match只匹配字符串的開始，若是字符串開始不符合正則表達式，則匹配失敗，函數返回None；而re.search匹配整個字符串，直到找到一個匹配。

a=re.search('[\d]',"abc33").group()
print(a)
p=re.match('[\d]',"abc33")
print(p)
b=re.findall('[\d]',"abc33")
print(b)
執行結果：
3
None
['3', '3']

二、貪婪匹配與非貪婪匹配

*?,+?,??,{m,n}? 前面的*,+,?等都是貪婪匹配，也就是儘量匹配，後面加?號使其變成惰性匹配

a = re.findall(r"a(\d+?)",'a23b')
print(a)
b = re.findall(r"a(\d+)",'a23b')
print(b)
執行結果：
['2']
['23']

a = re.match('<(.*)>','<H1>title<H1>').group()
print(a)
b = re.match('<(.*?)>','<H1>title<H1>').group()
print(b)
執行結果：
<H1>title<H1>
<H1>

a = re.findall(r"a(\d+)b",'a3333b')
print(a)
b = re.findall(r"a(\d+?)b",'a3333b')
print(b)
執行結果以下：
['3333']
['3333']
#######################
這裏須要注意的是若是先後均有限定條件的時候，就不存在什麼貪婪模式了，非匹配模式失效。

三、用flags時遇到的小坑

print(re.split('a','1A1a2A3',re.I))#輸出結果並未能區分大小寫
這是由於re.split(pattern，string，maxsplit,flags)默認是四個參數，當咱們傳入的三個參數的時候，系統會默認re.I是第三個參數，因此就沒起做用。若是想讓這裏的re.I起做用，寫成flags=re.I便可。

5、正則的小實踐

一、匹配電話號碼

p = re.compile(r'\d{3}-\d{6}')
print(p.findall('010-628888'))

二、匹配IP

re.search(r"(([01]?\d?\d|2[0-4]\d|25[0-5])\.){3}([01]?\d?\d|2[0-4]\d|25[0-5]\.)","192.168.1.1")

subprocess

什麼是進城？

　　正在進行中的程序，每當打開一個進城就會開啓一個新的進程

　　每一個進程包含y運行程序所需的全部資源

　　正常狀況下，進程間不能夠跨進程訪問數據，但有些狀況下就須要訪問別的進程數據，提供一個叫管道的對象專門用於跨進程通信

　　做用是：執行系統命令

經常使用方法、：

　　run：返回一個執行結果的對象

　　call:返回執行的狀態碼

總結：　能夠獲取指令的執行結果

　　　　執行指令時，能夠在子進程中，這樣避免了子進程的卡死

import subprocess
# print(1)
# res = subprocess.run("tasklist",shell=True,stdout=subprocess.PIPE)
#
# print("=====================================================")
# print(res.stdout.decode("gbk"))
#
# print(res.stderr)


# res = subprocess.call("tasklist",shell=True)
# print(res)



#  第一個進程a讀取tasklist的內容   將數據交給另外一個進程b  進程b將數據寫到文件中
res1 = subprocess.Popen("tasklist",stdout=subprocess.PIPE,shell=True,stderr=subprocess.PIPE)
# print("hello")
# print(res1.stdout.read().decode("gbk"))
# print(res1.stderr.read().decode("gbk"))
#
# res2 = subprocess.Popen("findstr cmd",stdout=subprocess.PIPE,shell=True,stderr=subprocess.PIPE,stdin=res1.stdout)
# print(res2.stdout.read().decode("gbk"))

res2 = subprocess.Popen("echo >a.txt", stdout=subprocess.PIPE, shell=True, stderr=subprocess.PIPE,stdin=res1.stdout)
print(res2.stdout.read().decode("gbk"))

res1=subprocess.Popen(r'',shell=True,stdout=subprocess.PIPE)
res=subprocess.Popen('findstr test*',shell=True,stdin=res1.stdout,stdout=subprocess.PIPE)
print(res.stdout.read().decode('gbk'))