部分模塊
什麽是模塊?
常見的場景:一個模塊就是一個包含了python定義和聲明的文件,文件名就是模塊名字加上.py的後綴。
但其實import加載的模塊分為四個通用類別:
1 使用python編寫的代碼(.py文件)
2 已被編譯為共享庫或DLL的C或C++擴展
3 包好一組模塊的包
4 使用C編寫並鏈接到python解釋器的內置模塊
為何要使用模塊?
如果你退出python解釋器然後重新進入,那麽你之前定義的函數或者變量都將丟失,因此我們通常將程序寫到文件中以便永久保存下來,需要時就通過python test.py方式去執行,此時test.py被稱為腳本script。
隨著程序的發展,功能越來越多,為了方便管理,我們通常將程序分成一個個的文件,這樣做程序的結構更清晰,方便管理。這時我們不僅僅可以把這些文件當做腳本去執行,還可以把他們當做模塊來導入到其他的模塊中,實現了功能的重復利用,
常用模塊
時間模塊
和時間有關系的我們就要用到時間模塊。在使用模塊之前,應該首先導入這個模塊。
#常用方法 1.time.sleep(secs) (線程)推遲指定的時間運行。單位為秒。 2.time.time() 獲取當前時間戳
表示時間的三種方式
在Python中,通常有這三種方式來表示時間:時間戳、元組(struct_time)、格式化的時間字符串:
(1)時間戳(timestamp) :通常來說,時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。我們運行“type(time.time())”,返回的是float類型。
(2)格式化的時間字符串(Format String): ‘1999-12-06’
(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‘ #2017年7月24號13點55分04秒 #時間元組:localtime將一個時間戳轉換為當前時區的struct_time time.localtime() time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=13, tm_min=59, tm_sec=37, tm_wday=0, tm_yday=205, tm_isdst=0)
小結:時間戳是計算機能夠識別的時間;時間字符串是人能夠看懂的時間;元組則是用來操作時間的
幾種格式之間的轉換
#時間戳-->結構化時間 #time.gmtime(時間戳) #UTC時間,格林威治時間,地球的0時區,標準時間 #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) print(time.mktime(time_tuple)) 1500000000.0
#結構化時間-->字符串時間 #time.strftime("格式定義","結構化時間") 結構化時間參數若不傳,則現實當前時間 time.strftime("%Y-%m-%d %X") ‘2017-07-24 14:55:36‘ time.strftime("%Y-%m-%d",time.localtime(1500000000)) ‘2017-07-14‘ #字符串時間-->結構化時間 #time.strptime(時間字符串,字符串對應格式) time.strptime("2017-03-16","%Y-%m-%d") time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1) time.strptime("07/24/2017","%m/%d/%Y") time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
#結構化時間 --> %a %b %d %H:%M:%S %Y串 #time.asctime(結構化時間) 如果不傳參數,直接返回當前時間的格式化串 time.asctime(time.localtime(1500000000)) ‘Fri Jul 14 10:40:00 2017‘ time.asctime() ‘Mon Jul 24 15:18:33 2017‘ #%a %d %d %H:%M:%S %Y串 --> 結構化時間 #time.ctime(時間戳) 如果不傳參數,直接返回當前時間的格式化串 time.ctime() ‘Mon Jul 24 15:19:07 2017‘ time.ctime(1500000000) ‘Fri Jul 14 10:40:00 2017‘
計算時間差的標準公式
import time
true_time=time.mktime(time.strptime(‘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))
random模塊
import random #隨機小數 random.random() # 大於0且小於1之間的小數 0.7664338663654585 random.uniform(1,5) #大於1小於5的小數,括號裏的數字是元素範圍 1.6270147180533838 #隨機整數
random.randint(1,5) # 大於等於1且小於等於5之間的整數 random.randrange(1,10,2) # 大於等於1且小於10之間的奇數,後面的2是隨機步長 #隨機選擇一個返回 random.choice([1,‘23‘,[4,5]]) # #1或者23或者[4,5] #隨機選擇多個返回,返回的個數為函數的第二個參數 random.sample([1,‘23‘,[4,5]],2) # #列表元素任意2個組合,後面的2是組合數量 [[4, 5], ‘23‘] #打亂列表順序 l1=[1,3,5,7,9] random.shuffle(l1) # 打亂次序 print(61) # [5, 1, 3, 7, 9] random.shuffle(l1) print(l1) [5, 9, 7, 1, 3]
生成隨機驗證碼
import random
def v_code(): code = ‘‘ for i in range(5): num=random.randint(0,9) alf=chr(random.randint(65,90)) add=random.choice([num,alf]) code="".join([code,str(add)]) return code print(v_code())
os模塊
os模塊 死記硬背就行
os模塊是與操作系統交互的一個接口
‘‘‘ os.getcwd() 獲取當前工作目錄,即當前python腳本工作的目錄路徑 os.chdir("dirname") 改變當前腳本工作目錄;相當於shell下cd os.curdir 返回當前目錄: (‘.‘) os.pardir 獲取當前目錄的父目錄字符串名:(‘..‘) os.makedirs(‘dirname1/dirname2‘) 可生成多層遞歸目錄 os.removedirs(‘dirname1‘) 若目錄為空,則刪除,並遞歸到上一級目錄,如若也為空,則刪除,依此類推 os.mkdir(‘dirname‘) 生成單級目錄;相當於shell中mkdir dirname os.rmdir(‘dirname‘) 刪除單級空目錄,若目錄不為空則無法刪除,報錯;相當於shell中rmdir dirname os.listdir(‘dirname‘) 列出指定目錄下的所有文件和子目錄,包括隱藏文件,並以列表方式打印 os.remove() 刪除一個文件 os.rename("oldname","newname") 重命名文件/目錄 os.stat(‘path/filename‘) 獲取文件/目錄信息 os.sep 輸出操作系統特定的路徑分隔符,win下為"\\",Linux下為"/" os.linesep 輸出當前平臺使用的行終止符,win下為"\t\n",Linux下為"\n" os.pathsep 輸出用於分割文件路徑的字符串 win下為;,Linux下為: os.name 輸出字符串指示當前使用平臺。win->‘nt‘; Linux->‘posix‘ os.system("bash command") 運行shell命令,直接顯示 os.popen("bash command) 運行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的大小 ‘‘‘
註意:os.stat(‘path/filename‘) 獲取文件/目錄信息 的結構說明
stat 結構: st_mode: inode 保護模式 st_ino: inode 節點號。 st_dev: inode 駐留的設備。 st_nlink: inode 的鏈接數。 st_uid: 所有者的用戶ID。 st_gid: 所有者的組ID。 st_size: 普通文件以字節為單位的大小;包含等待某些特殊文件的數據。 st_atime: 上次訪問的時間。 st_mtime: 最後一次修改的時間。 st_ctime: 由操作系統報告的"ctime"。在某些系統上(如Unix)是最新的元數據更改的時間,在其它系統上(如Windows)是創建時間(詳細信息參見平臺的文檔)。
sys模塊
sys.argv 命令行參數List,第一個元素是程序本身路徑 sys.exit(n) 退出程序,正常退出時exit(0),錯誤退出sys.exit(1) sys.version 獲取Python解釋程序的版本信息 sys.path 返回模塊的搜索路徑,初始化時使用PYTHONPATH環境變量的值 sys.platform 返回操作系統平臺名稱
異常處理和status
import sys try: sys.exit(1) except SystemExit as e: print(e)
序列化模塊
什麽叫序列化——將原本的字典、列表等內容轉換成一個字符串的過程就叫做序列化。
為什麽要有序列化模塊
比如,我們在python代碼中計算的一個數據需要給另外一段程序使用,那我們怎麽給? 現在我們能想到的方法就是存在文件裏,然後另一個python程序再從文件裏讀出來。 但是我們都知道,對於文件來說是沒有字典這個概念的,所以我們只能將數據轉換成字典放到文件中。 你一定會問,將字典轉換成一個字符串很簡單,就是str(dic)就可以辦到了,為什麽我們還要學習序列化模塊呢? 沒錯序列化的過程就是從dic 變成str(dic)的過程。現在你可以通過str(dic),將一個名為dic的字典轉換成一個字符串, 但是你要怎麽把一個字符串轉換成字典呢? 聰明的你肯定想到了eval(),如果我們將一個字符串類型的字典str_dic傳給eval,就會得到一個返回的字典類型了。 eval()函數十分強大,但是eval是做什麽的?e官方demo解釋為:將字符串str當成有效的表達式來求值並返回計算結果。 BUT!強大的函數有代價。安全性是其最大的缺點。 想象一下,如果我們從文件中讀出的不是一個數據結構,而是一句"刪除文件"類似的破壞性語句,那麽後果實在不堪設設想。 而使用eval就要擔這個風險。 所以,我們並不推薦用eval方法來進行反序列化操作(將str轉換成python中的數據結構)
序列化的目的
1、以某種存儲形式使自定義對象持久化; 2、將對象從一個地方傳遞到另一個地方。 3、使程序更具維護性。json
Json模塊提供了四個功能:dumps、dump、loads、load
loads和dumps
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‘}]
load和dump
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)
ensure_ascii關鍵字參數
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()
pickle
json & pickle 模塊
用於序列化的兩個模塊
- json,用於字符串 和 python數據類型間進行轉換
- pickle,用於python特有的類型 和 python的數據類型間進行轉換
pickle模塊提供了四個功能:dumps、dump(序列化,存)、loads(反序列化,讀)、load (不僅可以序列化字典,
列表...可以把python中任意的數據類型序列化)
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)
這時候機智的你又要說了,既然pickle如此強大,為什麽還要學json呢?
這裏我們要說明一下,json是一種所有的語言都可以識別的數據結構。
如果我們將一個字典或者序列化成了一個json存在文件裏,那麽java代碼或者js代碼也可以拿來用。
但是如果我們用pickle進行序列化,其他語言就不能讀懂這是什麽了~
所以,如果你序列化的內容是列表或者字典,我們非常推薦你使用json模塊
但如果出於某種原因你不得不序列化其他的數據類型,而未來你還會用python對這個數據進行反序列化的話,那麽就可以使用pickle
shelve
shelve也是python提供給我們的序列化工具,比pickle用起來更簡單一些。
shelve只提供給我們一個open方法,是用key來訪問的,使用起來和字典類似。
shelve
import shelve f = shelve.open(‘shelve_file‘) f[‘key‘] = {‘int‘:10, ‘float‘:9.5, ‘string‘:‘Sample data‘} #直接對文件句柄操作,就可以存入數據 f.close() import shelve f1 = shelve.open(‘shelve_file‘) existing = f1[‘key‘] #取出數據的時候也只需要直接用key獲取即可,但是如果key不存在會報錯 f1.close() print(existing)
這個模塊有個限制,它不支持多個應用同一時間往同一個DB進行寫操作。所以當我們知道我們的應用如果只進行讀操作,我們可以讓shelve通過只讀方式打開DB
shelve只讀
import shelve f = shelve.open(‘shelve_file‘, flag=‘r‘) existing = f[‘key‘] f.close() print(existing)
由於shelve在默認情況下是不會記錄待持久化對象的任何修改的,所以我們在shelve.open()時候需要修改默認參數,否則對象的修改不會保存。
設置writeback
import shelve f1 = shelve.open(‘shelve_file‘) print(f1[‘key‘]) f1[‘key‘][‘new_value‘] = ‘this was not here before‘ f1.close() f2 = shelve.open(‘shelve_file‘, writeback=True) print(f2[‘key‘]) f2[‘key‘][‘new_value‘] = ‘this was not here before‘ f2.close()writeback方式有優點也有缺點。優點是減少了我們出錯的概率,並且讓對象的持久化對用戶更加的透明了;但這種方式並不是所有的情況下都需要,首先,使用writeback以後,shelf在open()的時候會增加額外的內存消耗,並且當DB在close()的時候會將緩存中的每一個對象都寫入到DB,這也會帶來額外的等待時間。因為shelve沒有辦法知道緩存中哪些對象修改了,哪些對象沒有修改,因此所有的對象都會被寫入
re模塊
講正題之前我們先來看一個例子:https://reg.jd.com/reg/person?ReturnUrl=https%3A//www.jd.com/
這是京東的註冊頁面,打開頁面我們就看到這些要求輸入個人信息的提示。
假如我們隨意的在手機號碼這一欄輸入一個11111111111,它會提示我們格式有誤。
這個功能是怎麽實現的呢?
假如現在你用python寫一段代碼,類似:
phone_number = input(‘please input your phone number : ‘)
你怎麽判斷這個phone_number是合法的呢?
根據手機號碼一共11位並且是只以13、14、15、18開頭的數字這些特點,我們用python寫了如下代碼:
判斷手機號碼是否合法
while True: phone_number = input(‘please input your phone number : ‘) if len(phone_number) == 11 and phone_number.isdigit() and (phone_number.startswith(‘13‘) or phone_number.startswith(‘14‘) or phone_number.startswith(‘15‘) or phone_number.startswith(‘18‘)): print(‘是合法的手機號碼‘) else: print(‘不是合法的手機號碼‘)
這是你的寫法,現在我要展示一下我的寫法:
import re phone_number = input(‘please input your phone number : ‘) if re.match(‘^(13|14|15|18)[0-9]{9}$‘,phone_number): print(‘是合法的手機號碼‘) else: print(‘不是合法的手機號碼‘)
對比上面的兩種寫法,此時此刻,我要問你你喜歡哪種方法呀?你肯定還是會說第一種,為什麽呢?因為第一種不用學呀!
但是如果現在有一個文件,我讓你從整個文件裏匹配出所有的手機號碼。你用python給我寫個試試?
但是學了今天的技能之後,分分鐘幫你搞定!
今天我們要學習python裏的re模塊和正則表達式,學會了這個就可以幫我們解決剛剛的疑問。正則表達式不僅在python領域,在整個編程屆都占有舉足輕重的地位
不管以後你是不是去做python開發,只要你是一個程序員就應該了解正則表達式的基本使用。如果未來你要在爬蟲領域發展,你就更應該好好學習這方面的知識。 但是你要知道,re模塊本質上和正則表達式沒有一毛錢的關系。re模塊和正則表達式的關系 類似於 time模塊和時間的關系 你沒有學習python之前,也不知道有一個time模塊,但是你已經認識時間了 12:30就表示中午十二點半(這個時間可好,一般這會兒就該下課了)。 時間有自己的格式,年月日時分秒,12個月,365天......已經成為了一種規則。你也早就牢記於心了。time模塊只不過是python提供給我們的可以方便我們操作時間的一個工具而已
正則表達式本身也和python沒有什麽關系,就是匹配字符串內容的一種規則。
官方定義:正則表達式是對字符串操作的一種邏輯公式,就是用事先定義好的一些特定字符、及這些特定字符的組合,組成一個“規則字符串”,這個“規則字符串”用來表達對字符串的一種過濾邏輯。
正則表達式
一說規則我已經知道你很暈了,現在就讓我們先來看一些實際的應用。在線測試工具 http://tool.chinaz.com/regex/
首先你要知道的是,談到正則,就只和字符串相關了。在我給你提供的工具中,你輸入的每一個字都是一個字符串。
其次,如果在一個位置的一個值,不會出現什麽變化,那麽是不需要規則的。
比如你要用"1"去匹配"1",或者用"2"去匹配"2",直接就可以匹配上。這連python的字符串操作都可以輕松做到。
那麽在之後我們更多要考慮的是在同一個位置上可以出現的字符的範圍。
字符組 : [字符組] 在同一個位置可能出現的各種字符組成了一個字符組,在正則表達式中用[]表示 字符分為很多類,比如數字、字母、標點等等。 假如你現在要求一個位置"只能出現一個數字",那麽這個位置上的字符只能是0、1、2...9這10個數之一。
正則 |
待匹配字符 |
匹配 |
說明 |
[0123456789] |
8 |
True |
在一個字符組裏枚舉合法的所有字符,字符組裏的任意一個字符 |
[0123456789] |
a |
False |
由於字符組中沒有"a"字符,所以不能匹配 |
[0-9] |
7 |
True |
也可以用-表示範圍,[0-9]就和[0123456789]是一個意思 |
[a-z] |
s |
True |
同樣的如果要匹配所有的小寫字母,直接用[a-z]就可以表示 |
[A-Z] |
B |
True |
[A-Z]就表示所有的大寫字母 |
[0-9a-fA-F] |
e |
True |
可以匹配數字,大小寫形式的a~f,用來驗證十六進制字符 |
字符:
元字符 |
匹配內容 |
. | 匹配除換行符以外的任意字符 |
\w | 匹配字母或數字或下劃線 |
\s | 匹配任意的空白符 |
\d | 匹配數字 |
\n | 匹配一個換行符 |
\t | 匹配一個制表符 |
\b | 匹配一個單詞的結尾 |
^ | 匹配字符串的開始 |
$ | 匹配字符串的結尾 |
\W |
匹配非字母或數字或下劃線 |
\D |
匹配非數字 |
\S |
匹配非空白符 |
a|b |
匹配字符a或字符b |
() |
匹配括號內的表達式,也表示一個組 |
[...] |
匹配字符組中的字符 |
[^...] |
匹配除了字符組中字符的所有字符 |
量詞:
量詞 |
用法說明 |
* | 重復零次或更多次 |
+ | 重復一次或更多次 |
? | 重復零次或一次 |
{n} | 重復n次 |
{n,} | 重復n次或更多次 |
{n,m} | 重復n到m次 |
. ^ $
正則 | 待匹配字符 | 匹配 結果 |
說明 |
海. | 海燕海嬌海東 | 海燕海嬌海東 | 匹配所有"海."的字符 |
^海. | 海燕海嬌海東 | 海燕 | 只從開頭匹配"海." |
海.$ | 海燕海嬌海東 | 海東 | 只匹配結尾的"海.$" |
* + ? { }
正則 | 待匹配字符 | 匹配 結果 |
說明 |
李.? | 李傑和李蓮英和李二棍子 |
李傑 |
?表示重復零次或一次,即只匹配"李"後面一個任意字符 |
李.* | 李傑和李蓮英和李二棍子 | 李傑和李蓮英和李二棍子 |
*表示重復零次或多次,即匹配"李"後面0或多個任意字符 |
李.+ | 李傑和李蓮英和李二棍子 | 李傑和李蓮英和李二棍子 |
+表示重復一次或多次,即只匹配"李"後面1個或多個任意字符 |
李.{1,2} | 李傑和李蓮英和李二棍子 |
李傑和 |
{1,2}匹配1到2次任意字符 |
註意:前面的*,+,?等都是貪婪匹配,也就是盡可能匹配,後面加?號使其變成惰性匹配
正則 | 待匹配字符 | 匹配 結果 |
說明 |
李.*? | 李傑和李蓮英和李二棍子 | 李 李 李 |
惰性匹配 |
字符集[][^]
正則 | 待匹配字符 | 匹配 結果 |
說明 |
李[傑蓮英二棍子]* | 李傑和李蓮英和李二棍子 |
李傑 |
表示匹配"李"字後面[傑蓮英二棍子]的字符任意次 |
李[^和]* | 李傑和李蓮英和李二棍子 |
李傑 |
表示匹配一個不是"和"的字符任意次 |
[\d] | 456bdha3 |
4 |
表示匹配任意一個數字,匹配到4個結果 |
[\d]+ | 456bdha3 |
456 |
表示匹配任意個數字,匹配到2個結果 |
分組 ()與 或 |[^]
身份證號碼是一個長度為15或18個字符的字符串,如果是15位則全部???數字組成,首位不能為0;如果是18位,則前17位全部是數字,末位可能是數字或x,下面我們嘗試用正則來表示:
正則 | 待匹配字符 | 匹配 結果 |
說明 |
^[1-9]\d{13,16}[0-9x]$ | 110101198001017032 |
110101198001017032 |
表示可以匹配一個正確的身份證號 |
^[1-9]\d{13,16}[0-9x]$ | 1101011980010170 |
1101011980010170 |
表示也可以匹配這串數字,但這並不是一個正確的身份證號碼,它是一個16位的數字 |
^[1-9]\d{14}(\d{2}[0-9x])?$ | 1101011980010170 |
False |
現在不會匹配錯誤的身份證號了 |
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$ | 110105199812067023 |
110105199812067023 |
表示先匹配[1-9]\d{16}[0-9x]如果沒有匹配上就匹配[1-9]\d{14} |
轉義符 \
在正則表達式中,有很多有特殊意義的是元字符,比如\d和\s等,如果要在正則中匹配正常的"\d"而不是"數字"就需要對"\"進行轉義,變成‘\\‘。
在python中,無論是正則表達式,還是待匹配的內容,都是以字符串的形式出現的,在字符串中\也有特殊的含義,本身還需要轉義。所以如果匹配一次"\d",字符串中要寫成‘\\d‘,那麽正則裏就要寫成"\\\\d",這樣就太麻煩了。這個時候我們就用到了r‘\d‘這個概念,此時的正則是r‘\\d‘就可以了。
正則 | 待匹配字符 | 匹配 結果 |
說明 |
\d | \d | False |
因為在正則表達式中\是有特殊意義的字符,所以要匹配\d本身,用表達式\d無法匹配 |
\\d | \d | True |
轉義\之後變成\\,即可匹配 |
"\\\\d" | ‘\\d‘ | True |
如果在python中,字符串中的‘\‘也需要轉義,所以每一個字符串‘\‘又需要轉義一次 |
r‘\\d‘ | r‘\d‘ | True |
在字符串之前加r,讓整個字符串不轉義 |
貪婪匹配
貪婪匹配:在滿足匹配時,匹配盡可能長的字符串,默認情況下,采用貪婪匹配
正則 | 待匹配字符 | 匹配 結果 |
說明 |
<.*> |
<script>...<script> |
<script>...<script> |
默認為貪婪匹配模式,會匹配盡量長的字符串 |
<.*?> | r‘\d‘ |
<script> |
加上?為將貪婪匹配模式轉為非貪婪匹配模式,會匹配盡量短的字符串 |
幾個常用的非貪婪匹配Pattern
*? 重復任意次,但盡可能少重復 +? 重復1次或更多次,但盡可能少重復 ?? 重復0次或1次,但盡可能少重復 {n,m}? 重復n到m次,但盡可能少重復 {n,}? 重復n次以上,但盡可能少重復
.*?的用法
. 是任意字符 * 是取 0 至 無限長度 ? 是非貪婪模式。 何在一起就是 取盡量少的任意字符,一般不會這麽單獨寫,他大多用在: .*?x 就是取前面任意長度的字符,直到一個x出現
re模塊下的常用方法
import re ret = re.findall(‘a‘, ‘eva egon yuan‘) # 返回所有滿足匹配條件的結果,放在列表裏 print(ret) #結果 : [‘a‘, ‘a‘] ret = re.search(‘a‘, ‘eva egon yuan‘).group() print(ret) #結果 : ‘a‘ # 函數會在字符串內查找模式匹配,只到找到第一個匹配然後返回一個包含匹配信息的對象,該對象可以 # 通過調用group()方法得到匹配的字符串,如果字符串沒有匹配,則返回None。 ret = re.match(‘a‘, ‘abc‘).group() # 同search,不過盡在字符串開始處進行匹配 print(ret) #結果 : ‘a‘ ret = re.split(‘[ab]‘, ‘abcd‘) # 先按‘a‘分割得到‘‘和‘bcd‘,在對‘‘和‘bcd‘分別按‘b‘分割 print(ret) # [‘‘, ‘‘, ‘cd‘] ret = re.sub(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘, 1)#將數字替換成‘H‘,參數1表示只替換1個 print(ret) #evaHegon4yuan4 ret = re.subn(‘\d‘, ‘H‘, ‘eva3egon4yuan4‘)#將數字替換成‘H‘,返回元組(替換的結果,替換了多少次) print(ret) obj = re.compile(‘\d{3}‘) #將正則表達式編譯成為一個 正則表達式對象,規則要匹配的是3個數字 ret = obj.search(‘abc123eeee‘) #正則表達式對象調用search,參數為待匹配的字符串 print(ret.group()) #結果 : 123 import re ret = re.finditer(‘\d‘, ‘ds3sy4784a‘) #finditer返回一個存放匹配結果的叠代器 print(ret) # <callable_iterator object at 0x10195f940> print(next(ret).group()) #查看第一個結果 print(next(ret).group()) #查看第二個結果 print([i.group() for i in ret]) #查看剩余的左右結果
註意:
1 findall的優先級查詢:
import re ret = re.findall(‘www.(baidu|oldboy).com‘, ‘www.oldboy.com‘) print(ret) # [‘oldboy‘] 這是因為findall會優先把匹配結果組裏內容返回,如果想要匹配結果,取消權限即可 ret = re.findall(‘www.(?:baidu|oldboy).com‘, ‘www.oldboy.com‘) print(ret) # [‘www.oldboy.com‘]
2 split的優先級查詢
ret=re.split("\d+","eva3egon4yuan") print(ret) #結果 : [‘eva‘, ‘egon‘, ‘yuan‘] ret=re.split("(\d+)","eva3egon4yuan") print(ret) #結果 : [‘eva‘, ‘3‘, ‘egon‘, ‘4‘, ‘yuan‘] #在匹配部分加上()之後所切出的結果是不同的, #沒有()的沒有保留所匹配的項,但是有()的卻能夠保留了匹配的項, #這個在某些需要保留匹配部分的使用過程是非常重要的。
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‘}]
部分模塊