認識模塊

什麼是模塊

一個模塊就是一個包含了Python定義和聲明的文件，文件名就是模塊名字加上.py 的後綴。

import 加載的模塊分爲四個通用類別：

1. 使用Python編寫的代碼（.py文件）

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

3. 包好一組模塊的包

4. 使用C編寫並連接到Python解釋器的內置模塊

爲什麼要使用模塊？

如果退出python解釋器然後重新進入，那麼你之前定義的函數或者變量都將丟失，因此我們通常將程序寫到文件中以便永久保存下來，需要是就通過python test.py方式去執行，此時test.py被稱爲腳本。

隨着程序的發展，功能越來越多，爲了方便管理，我們通常將程序分成一個個的文件，這樣做程序的結構更清晰，方便管理。這時我們不僅可以把這些文件當做腳本去執行，還可以把他們當做模塊來導入到其他模塊中，實現了功能的重複利用。

模塊的導入和使用

常用模塊一

collections模塊

在內置數據類型（dict、tuple、list、set）的基礎上，collections模塊還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict等。

1. namedtuple:生成可以用名字來訪問元素內容的tuple

2. deque:雙端隊列，可以快速的從另外一側追加和推出對象。

3. Counter：計數器，主要用於計數

4. OrderedDict:有序字典

5. defaultdict:帶有默認值的字典

namedtuple

我們知道tuple可以表示不變集合，例如，一個點的二維座標就可以表示成：

p = (1,2)

但是，看到（1,2），很難看出這個tuple是用來表示一個座標的。

這時，namedtuple就派上了用場

from collections import namedtuple
point = namedtuple('point',['x','y'])
p = point(1,2)
print(p.x)
print(p.y)

類似的，如果要用座標和半徑表示一個圓，也可以用namedtuple定義

#namedtuple('名稱',[屬性list])
Circle = namedtuple('Circle',['x','y','r'])

deque

使用list存儲數據時，按索引方向訪問元素很快，但是插入和刪除元素就很慢了，因爲list是線性存儲，數據量大的時候，插入和刪除效率很低。

deque是爲了高效實現插入和刪除操作的雙相列表，適合於隊列和棧：

from collections import deque
q = deque(['a','b','c'])
q.append('x')
q.appendleft('y')
print(q)  #執行結果：deque(['y', 'a', 'b', 'c', 'x'])

deque除了實現list的append()和pop()外還支持appendleft()和popleft(),這樣就可以非常高效的往頭部添加或刪除元素。

OderedDict

使用dict時，Key是無序的，在對dict做迭代時，我們無法確定Key的順序。

如果要保持Key的順序，可以用OrderedDict:

from collections import OrderedDict
d = dict([('a',1),('b',2),('c',3)])
print(d) #執行結果：{'a': 1, 'c': 3, 'b': 2}
od = OrderedDict([('a',1),('b',2),('c',3)])
print(od) #執行結果：OrderedDict([('a', 1), ('b', 2), ('c', 3)])

注意,OrderedDict會按照插入的順序排列，不是key本身排序：

from collections import OrderedDict
odd = OrderedDict()
odd['z'] = 1
odd['y'] = 2
odd['x'] = 3
print(odd.keys())#按照插入key的順序返回-->odict_keys(['z', 'y', 'x'])

Defaultdict

有如下集合[11,22,33,44,55,66,77,88,99,90...],將所有大於66的值保存至字典的第一個key中，將小於66得知保存至第二個key的值中。

即：{‘k1’:大於66，‘k2’:小於66}

from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99,90]

my_dict = defaultdict(list)

for value in values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(my_dict) #defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})

使用dict時，如果key不存在，就會拋出KeyError.如果希望key不存在時，返回一個默認值，就可以用defaultdict

d1 = defaultdict(lambda: 'N/A')
d1['key1'] = 'abc'
print(d1['key1']) #key1存在，返回abc
print(d1['key2']) #key2不存在，返回默認值：N/A

Counter

Counter類的目的是用來追蹤值出現的次數。它是一個無序的容器類型，以字典的餓鍵值對形式存儲，其中元素作爲key,其計數作爲value.計數值可以是任意的Interger(包括0 和負數)。Counter類和其他語言的bags或multisets很相似。

from collections import Counter
c = Counter('ahsdjahsjdhwyeaehjd')
print(c) 
#打印結果：Counter({'h': 4, 'j': 3, 'a': 3, 'd': 3, 'e': 2, 's': 2, 'y': 1, 'w': 1})

時間模塊

與時間有關的就要用到時間模塊。

常用方法：

1. time.sleep(secs)

(線程)推遲指定的時間運行，單位爲秒

2.time.time()

獲取當前時間戳

表示時間的三種方式

在python中，通常有這三種方式表示時間：時間戳、元組（struct_time）、格式化的時間字符串：

時間戳（timestamp）:通常來說，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量。我們運行“type(time.time())”返回的是float類型
格式化的時間字符串（Format String）: ‘1990-11-15’

%y 兩位數的年份表示
%Y 四位數的年份表示
%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 年內的一天（011-365）
%p 本地A.M或P.M的等價符
%U 一年中的星期數（00-53）星期天爲星期的開始
%w 星期（0-6），星期天爲星期的開始
%W 一年中的星期數（00-53）星期一爲星期的開始
%x 本地相應的日期表示
%X 本地相應的時間表示
%Z 當前時區的名稱
%% %本身

元組（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

實例：

import time
#時間戳
# print(time.time()) #執行結果：1530597152.4538252
#
# #時間字符串
# print(time.strftime("%y-%m-%d %X")) #執行結果：18-07-03 13:53:50
# print(time.strftime("%Y-%m-%d %H:%M:%S")) #執行結果：2018-07-03 13:55:12

#時間元組：localtime將一個時間戳轉換爲當前時區的struct_time

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

幾種格式之間的轉換

#時間戳-->結構化時間
#time.gmtime(時間戳) #UTC時間，與英國倫敦當地時間一致
#time.localtime(時間戳) #當地時間。例如我們現在正在北京執行這個方法：與UTC時間相差8小時，UTC時間+8小時 = 北京時間
print(time.gmtime(150000000))
#執行結果：time.struct_time(tm_year=1974, tm_mon=10, tm_mday=3, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=3,
 tm_yday=276, tm_isdst=0)
print(time.localtime(150000000))
#執行結果：time.struct_time(tm_year=1974, tm_mon=10, tm_mday=3, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=3, 
tm_yday=276, tm_isdst=0)

#結構化時間-->時間戳
#time.mktime(結構化時間）
time_tuple = time.localtime(150000000)
print(time.mktime(time_tuple))
#執行結果：150000000.0

#結構化時間-->字符串時間
#time.strftime("格式定義","結構化時間") 結構化時間參數若不傳，則實現當前時間
print(time.strftime("%Y-%m-%d %X"))  #2018-07-03 14:49:57
print(time.strftime("%Y-%m-%d",time.localtime(1500000000))) #2017-07-14

#字符串時間 -->結構化時間
print(time.strptime("2017-3-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)
print(time.strptime("07/03/2017","%m/%d/%Y"))
#執行結果：time.struct_time(tm_year=2017, tm_mon=7, tm_mday=3, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, 
tm_yday=184, tm_isdst=-1)

#結構化時間 --> %a %b %d %H:%M:%S %Y 串
#time.asctime(結構化時間) 如果不傳參數，直接返回當前時間的格式化串
import time
print(time.asctime(time.localtime(1500000000)))
#執行結果：Fri Jul 14 10:40:00 2017
print(time.asctime())
#執行結果：Wed Jul  4 09:21:53 2018

#時間戳 --> %a %b %d %H:%M:%S %Y 串
#time.ctime(時間戳) 如果不傳參數，直接返回當前時間的格式化串
print(time.ctime())
#執行結果：Wed Jul  4 09:23:48 2018
print(time.ctime(1500000000))
#執行結果：Fri Jul 14 10:40:00 2017

計算時間差：

import time
true_time = time.mktime(time.strptime('2017-09-20 09:00:03','%Y-%m-%d %H:%M:%S'))
time_now = time.mktime(time.strptime('2018-07-03 15:00:03','%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))
#打印結果：過去了0年9月13天6小時0分鐘0秒

random模塊

取隨機小數

#大於0且小於1之間的整數
print(random.random()) #0.4391279705536437
#大於1小於3的小數
print(random.uniform(1,3)) #1.8060052925154961

取隨機整數

#取大於等於1且小於等於5之間的整數
print(random.randint(1,5)) #3
#取大於等於1且小於10之間的奇數
print(random.randrange(1,10,2)) #5

隨機選擇一個返回

#1或者23或者[4,5]
print(random.choice([1,'23',[4,5]]))  #[4, 5]

隨機選擇多個返回，返回的個數爲函數的第二個參數

#列表元素任意兩個組合
print(random.sample([1,'23',[4,5]],2)) #['23', 1]

打亂列表順序

item = [1,3,5,7,9]
random.shuffle(item)
print(item) #[7, 3, 9, 5, 1]

練習：生成隨機驗證碼

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模塊是與操作系統交互的一個接口

import os
'''
os.getcwd() 獲取當前工作目錄，即當前腳本工作的目錄路徑
os.chdir("dirname") 改變當前腳本工作目錄；相當於shell下的cd
os.curdir 返回當前目錄：（'.'）
os.pardir 獲取當前目錄的父目錄字符串名：（'..'）
os.makedirs('dirname1/dirname2') 可生成多層遞歸目錄
os.removedirs('dirname1') 若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪除，以此類推
os.mkdir('dirname') 生成單級目錄；
os.rmdir('dirname') 刪除單級空目錄，若目錄不爲空則無法刪除，報錯
os.listdir('dirname') 列出指定目錄下的所有文件和子目錄，包括隱藏文件，並以列表方式打印
os.remove() 刪除一個文件
os.rename("oldname","newname") 重命名文件/目錄
os.stat("path/filename") 獲取文件/目錄信息
os.sep  輸出操作系統特定的路徑分隔符，windows下爲"\\"，Linux下爲"/"
os.linesep 輸出當前平臺使用的行終止符，windows下爲"\t\n",Linux下爲"\n"
os.pathsep 輸出用於分割文件路徑的字符串 windows下爲；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(filename) 返回path所指向的文件或者目錄的最後訪問時間
os.path.getmtime(filename) 返回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模塊是與python解釋器交互的一個接口

'''
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是做什麼的？eval官方demo解釋爲：將字符串str當成有效的表達式來求值並返回計算結果。
BUT!強大的函數有代價。安全性是其最大的缺點
想象一下，如果我們從文件中讀出的不是一個數據結構，而是一句“刪除文件”類似的破壞性語句，那麼後果實在不堪設想。而使用eval就要擔這個風險。所以我們並不推薦使用eval方法來進行反序列化操作（將str轉換成python中的數據結構）

序列化的目的

以某種存儲形式使自定義對象持久化；
將對象從一個地方傳遞到另一個地方
使程序更具維護性

json 數據解析

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

json.dumps() --將Python對象編碼成JSON字符串

語法：

json.dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, encoding="utf-8", default=None, sort_keys=False, **kw)

json.loads() --將已編碼的JSON字符串解碼爲Python對象

語法：

json.loads(s, encoding=None, cls=None, object_hook=None, parse_float=None, 
parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

Python 編碼爲 JSON 類型轉換對應表：

Python	JSON
dict	object
list, tuple	array
str	string
int, float, int- & float-derived Enums	number
True	true
False	false
None	null

JSON 解碼爲 Python 類型轉換對應表：

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

實例

loads和dumps實例

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

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

如果你要處理的是文件而不是字符串，可以使用json.dump()和json.load()來編碼和解碼JSON數據。

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

f = open('jsonfile')
dic2 = json.load(f) #load方法接收一個文件句柄，直接將文件中的json字符串轉換成數據結構返回
f.close()
print(type(dic2),dic2)
# 執行結果：<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

ensure_ascii 關鍵字參數

由於在使用pyhton.dumps序列化時，對中文默認使用ascii編碼,例如：

import json
print(json.dumps('中國'))
#打印結果："\u4e2d\u56fd"

所以如果想輸出真正的中文字符，需要指定ensure_ascii=False：

print(json.dumps('英國',ensure_ascii=False)) #打印結果："英國"

其他參數說明

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的中文即可正常顯示

indent： 應該是一個非負的整型，如果是0就頂格分行顯示，如果爲空就是一行最緊湊顯示，否則會換行且按照indent的數值顯示前面的空白分行顯示，這樣打印出來的json數據也叫pretty-printed json

seperators: 分隔符，實際上是（item_seperator,dict_seperator)的一個元組，默認的就是(',' , ':');這表示dictionary內keys之間用“,”隔開，而key和value之間用":"隔開。

sort_keys:將數據根據Keys的值進行排序。

json的格式化輸出

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

'''
執行結果：
{
  "age":16,
  "sex":"male",
  "username":[
    "李華",
    "二愣子"
  ]
}
'''

pickle

pickle 和json 都有dumps,dump,loads,load四種方法，而且用法一樣。

不同的是json序列化出來的是通用格式，其他編程語言都認識，就是普通的字符串，

而pickle模塊序列化出來的只有python可以識別，其他編程語言不認識，表現爲亂碼

不過pickle可以序列化函數，可以把python中任意的數據類型序列化。

import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic)

#執行結果：一串二進制字符
'''b'\x80\x03}q\x00(X\x02\x00\x00\x00k1q\x01X\x02\
x00\x00\x00v1q\x02X\x02\x00\x00\x00k2q\x03X\x02\
x00\x00\x00v2q\x04X\x02\x00\x00\x00k3q\x05X\x02\
x00\x00\x00v3q\x06u.'''''

dic2 = pickle.loads(str_dic)
print(dic2)
# 輸出：{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}

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)


#輸出：
'''time.struct_time(tm_year=2001, tm_mon=9, tm_mday=9, tm_hour=9, tm_min=46, tm_sec=40, tm_wday=6, tm_yday=252, tm_isdst=0)
2001'''

shelve

shelve 也是python提供給我們的序列化工具，比pickle用起來更簡單一些。

shelve只提供給我們一個open方法，是用key來訪問的，使用起來和字典類似

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10,'float':9.5,'string':'sample data'} #直接對文件句柄進行操作，就可以存入數據
f.close()


f1 = shelve.open('shelve_file')
existing = f1['key'] #取出數據的時候也只需要直接用key獲取即可，但是如果key不存在會報錯
f1.close()
print(existing)

#{'int': 10, 'float': 9.5, 'string': 'sample data'}

這個模塊有個限制，它不支持多個應用同一時間往同一個DB裏進行寫操作。所以當我們知道我們的應用如果只進行讀操作，我們可以讓shelve通過只讀方式打開DB

import shelve
f2 = shelve.open('shelve_file', flag= 'r')
existing = f2['key']
f2.close()
print(existing)
#{'int': 10, 'float': 9.5, 'string': 'sample data'}

由於shelve在默認情況下是不會記錄待持久化對象的任何修改的，所以我們在shelve.open()時候需要修改默認參數，否則對象的修改不會保存。

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()

#打印結果：
{'int': 10, 'float': 9.5, 'string': 'sample data'}
{'int': 10, 'float': 9.5, 'string': 'sample data'}

writeback方式有優點也有缺點，優點是減少了我們出錯的概率，並且讓對象的持久化對用戶更加的透明瞭；但這種方式並不是所有的情況下都需要，首先，使用writeback以後，shelve在open()的時候會增加額外的內存消耗，並且當DB在close的時候會將緩存中的每一個對象都寫入DB，這也會帶來額外的等待時間。因爲shelve沒有辦法知道緩存中哪些對象修改了，哪些對象沒有修改，因此所有的對象都會被寫入。

re模塊和正則表達式

學習這個之前先舉個例子：註冊頁面讓用戶輸入手機號，那麼如何判斷手機號是合法的呢？

兩種方法：

while True:
    phone_number = input('please enter 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('16')):
       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沒什麼關係，就是匹配字符串內容的一種規則。

官方定義：正則表達式是對字符串操作的一種邏輯公式，就是用事先定義好的一些特定字符、及這些特定字符的組合，組成一個“規則字符串”，這個“規則字符串”用來表來對字符串的一種過濾邏輯。

正則表達式

在線測試工具：http://tool.chinaz.com/regex/

談到正則，就只和字符串相關了。

所以需要考慮的是在同一個位置上可以出現的字符的範圍。

字符組

此處需要注意的是，一個字符組只代表一個字符。例如[0-9]只代表0-9這幾個數中的一個數。

在同一個位置可能出現的各種字符組成了一個字符組，在正則表達式中用[]表示

字符分爲很多類，比如數字、字母、標點等等。

例如你現在要求一個位置“只能出現一個數字",那麼這個位置上的字符只能是0-9這10個數之一。

正則	待匹配字符	匹配結果	說明
[0123456789]	8	True	在一個字符組裏枚舉合法的所有字符，字符組裏的任意一個字符和”待匹配字符“相同都
[0123456789]	a	False	由於字符組中沒有”a"字符，所以不能匹配
[0-9]	7	True	也可以用-表示範圍，[0-9]就和
[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
()	匹配括號內的表達式，也表示一個組
[...]	匹配字符組中的字符

[^...]

匹配除了字符組中字符的所有字符

量詞：

量詞只能約束相鄰前面的字符組出現的次數

貪婪匹配：正則表達式中的所有量詞，都會盡量多的匹配，例如+表示匹配一次或多次，

量詞	用法說明
*	重複0次或更多次，如果待匹配的字符爲空，也會顯示匹配到一條結果
+	重複一次或更多次
？	重複零次或一次
{n}	重複n次
{n,}	重複n次或更多次
{n,m}	重複n到m次

. ^ $

正則	待匹配字符	匹配結果	說明
海	海燕海嬌海東	海燕海嬌海東	匹配所有“海.”的字符
^海	海燕海嬌海東	海燕	只從開頭匹配“海.”
海.$	海燕海嬌海東	海東	只匹配結尾的“海.$"

* + ? { }

正則	待匹配字符	匹配結果	說明
李.?	李傑和李蓮英和李二棍子	李傑李蓮李二	？表示重複零次或一次，即只匹配”李“後面一個任意字符
李.*	李傑和李蓮英和李二棍子	李傑和李蓮英和李二棍子	*表示重複零次或多次，即匹配”李“後面零個或多個任意字符
李.{1,2}	李傑和李蓮英和李二棍子	李傑和李蓮英和李二棍子	+表示重複一次或多次，即只匹配”李“後面一個或多個任意字符
李.{1,2}	李傑和李蓮英和李二棍子	李傑和李蓮英李二棍	{1，2}匹配1到2次任意字符

注意：前面的*，+，？等都是貪婪匹配，也就是儘可能匹配，後面加？號使其變成惰性匹配。？號寫在字符組後面表示匹配零次或多次，？號寫在兩次後面，會盡量少匹配，例如\d{3,5}?,表示最多匹配3次。

正則

待匹配字符

匹配結果

說明

李.*?

李傑和李蓮英和李二棍子

李

惰性匹配

字符集［］［^］

正則	待匹配字符	匹配結果	說明
李[傑蓮英二棍子]*	李傑和李蓮英和李二棍子	李傑李蓮英李二棍子	表示匹配"李"字後面[傑蓮英二棍子]的字符任意次
李[^和]*	李傑和李蓮英和李二棍子	李傑李蓮英李二棍子	表示匹配一個不是"和"的字符任意次
[\d]	456bdha3	4 5 6 3	表示匹配任意一個數字，匹配到4個結果
[\d]+	456bdha3	456 3	表示匹配任意個數字，匹配到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	現在不會匹配錯誤的身份證號了 ()表示分組，將\d{2}[0-9x]分成一組，就可以整體約束他們出現的次數爲0-1次
^([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，讓整個字符串不轉義

貪婪匹配

貪婪匹配：在滿足匹配時，匹配儘可能長的字符串，默認情況下，採用貪婪匹配。

正則

待匹配字符

匹配結果

說明

<.*>

默認爲貪婪匹配模式，會匹配儘量長的字符串

<.*?>

r'\d'

加上?爲將貪婪匹配模式轉爲非貪婪匹配模式，會匹配儘量短的字符串

幾個常用的非貪婪匹配Pattern

*？重複任意次，但儘可能少重複

+？重複1次或更多次，但儘可能少重複

？？重複0次或1次，但儘可能少重複

{n,m}? 重複n到m次，但儘可能少重複

{n,}? 重複n此以上，但儘可能少重複

.*?的用法

. 是任意字符

* 是取0至無限長度

? 是非貪婪模式

合在一起就是取儘量少的任意字符，一般不會這麼單獨寫，他大多用在：

.*?x

就是取前面任意長度的字符，直到一個x出現

re模塊下的常用方法

re.findall()

返回所有滿足條件的結果，放在列表裏。

ret = re.findall('a','sahdjakja')
print(ret)
# 輸出：['a', 'a', 'a']

re.search().group()

函數會在字符串內查找模式匹配，只找到第一個匹配然後返回一個包含匹配信息的對象，該對象可以通過調用group()方法得到匹配的字符串，如果字符串沒有匹配，則返回None

ret = re.search('a','dhajdhsladlk').group()
print(ret)
# 輸出：a

re.match().group()

同search,不過盡在字符串開始處進行匹配

ret = re.match('a','shdjahsdashdl').group()
print(ret)
# 如待匹配字符串開始處沒有'a'，報錯

re.split(’表達式‘，’待匹配字符串‘)

ret = re.split('[ab]','abcd')
print(ret)
# 輸出： ['', '', 'cd']
# 先按'a'分割得到''和'bcd',再對''和'bcd'分別按'b'分割

re.sub()

ret = re.sub('\d','_Replace_','shdja3123sda344',2)
print(ret)
#輸出：shdja_Replace__Replace_23sda344
#將待匹配字符串中的數字替換爲'_replace_',最後的那個'2'表示只替換兩個

re.subn()

ret = re.subn('\d','_replace_','shdja3123sda344')
print(ret)
# 輸出：('shdja_replace__replace__replace__replace_sda_replace__replace__replace_', 7)
# 將數字替換成'_replace_',返回元組（替換的結果，替換了多少次）

re.compile()

obj = re.compile('\d{3}')
#將正則表達式編譯成爲一個正則表達式對象，規則要匹配的是三個數字
ret = obj.search('abc123hdjeh')
#正則表達式對象調用search,參數爲待匹配的字符串
print(ret.group())
#輸出：123

re.finditer()

ret = re.finditer('\d','ds3sy3432sa')
# finditer返回一個存放匹配結果的迭代器
print(ret)
# <callable_iterator object at 0x10085c2b0>
print(next(ret).group())
# 查看第一個結果
print(next(ret).group())
# 查看第二個結果
print([i.group() for i in ret])
#查看剩餘的左右結果

注意：

1. re.findall()的優先級查詢：

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']

Python學習之常用模塊

認識模塊

什麼是模塊

模塊的導入和使用

常用模塊一

collections模塊

namedtuple

deque

OderedDict

Defaultdict

Counter

時間模塊

表示時間的三種方式

幾種格式之間的轉換

random模塊

os模塊

sys模塊

序列化模塊

json 數據解析

JSON 解碼爲 Python 類型轉換對應表：

pickle

shelve

re模塊和正則表達式

正則表達式

. ^ $

* + ? { }

字符集［］［^］

分組 ()與或｜［^］

轉義符 \

貪婪匹配

re模塊下的常用方法

接口自動化測試框架-httprunner V2.x中文使用手冊-介紹及安裝

接口自動化測試框架-httprunner V2.x中文使用手冊-快速上手

pip 安裝成功後，提示pip不是內部或外部命令解決方案

Python學習之常用模塊

selenium學習之--從0開始搭建一個測試框架（總章）

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Python學習之常用模塊

認識模塊

什麼是模塊

模塊的導入和使用

常用模塊一

collections模塊

namedtuple

deque

OderedDict

Defaultdict

Counter

時間模塊

表示時間的三種方式

幾種格式之間的轉換

random模塊

os模塊

sys模塊

序列化模塊

json 數據解析

JSON 解碼爲 Python 類型轉換對應表：

pickle

shelve

re模塊和正則表達式

正則表達式

. ^ $

* + ? { }

字符集［］［^］

分組 ()與 或 ｜［^］

轉義符 \

貪婪匹配

re模塊下的常用方法

分組 ()與或｜［^］