什麼是正則表示式？

　　正則表示式是一個特殊的字元序列，用於檢測一個字串是否與我們所設定的這樣的字元序列相匹配。

那麼，正則表示式的作用呢？

　　舉個例子：

　　　　1. 檢查一串資料是否是電話號碼。 　　　　2. 檢測一個字串是否符合email 　　　　3.把一個文字中指定的單詞替換成另一個單詞 　　　　... ...

內建函式：

　　　　在python中有一些內建函式可以實現一些字串匹配，例如index()可以用來判斷一些內容是否在序列中存在,當然也可以通過in來查詢。 　

正則表示式正篇：

　　python提供了re模組，他就是python的正則表示式模組兒。在re模組兒中存放著正則所需要的函式和它的一些屬性。如findall, search等。、 　　

import
 
 re

a = 'C|C++|Python|C#|Javascript|Java'

result = re.findall('Python', a) 
print(result)
# 結果是
# ['Python']

　　判斷是否存在：

if len(result) != 0:
    print('字串中包含Python')

　　查詢是否存在數字：

import re
a = 'C0C++7Python8C#6Javascript9Java'
result = re.findall('\d', a)
print(result)

　　結果是：

['0', '7', '8', '
 
6', '9']

　　1. 元字元與普通字元：

　　　　字串指的普通字元，而元字元指的# . ^ $ * + ? {} [] \ | ()，\d等等。

　　2.字符集： []

　　　　中括號內的字元表示或的關係，即匹配任意其中一個。而^在其中，則表示範圍取反。

　　3.概括字符集：(常用)

　　

字元	含義	備註
\d	數字匹配
\D	匹配非數字
\w	匹配字母數字下劃線
\W	匹配非字母數字下劃線
\s	空白字元
\S	非空白字元
.	匹配除換行符\n以外的所有字元	如果設定了re.S，則表示匹配所有的字元，包括換行符

　　4.數量詞

import re

a = 'python 11111java68php'

r = re.findall('[a-z]{3}', a)
print(r)

#['pyt', 'hon', 'jav', 'php']

r1 = re.findall('[a-z]{3,6}', a)
print(r1)

#['python', 'java', 'php']

　　注意，後一個表示式匹配的不是pyt和hon，而是python，即在數量詞上匹配儘可能大的數字個數。也就是貪婪匹配。 　　其他數量詞：

表示	含義	備註
*	表示0次或無限多次
+	1次或無限多次
？	匹配0次或者1次	作為數量詞，與非貪婪匹配的概念還是不一樣的

　　

　　5.貪婪匹配和非貪婪匹配

　　　　匹配預設是貪婪匹配，用？來表示非貪婪匹配。

r2 = re.findall('[a-z]{3,6}?', a)
print(r2)

#['pyt', 'hon', 'jav', 'php']

　　6.邊界匹配

字元	含義	備註
^	必須以此作為匹配字串的開始	如‘^000’表示匹配以000作為開頭的字串
$	必須以此作為匹配字串的結束

　　7.組 （）　

　　例子：

import re

a = 'PythonPython0PythonPythonPythonPython'
r = re.findall('(Python){3}', a)
print(r)

#['Python']

　　8. re.findall的三個引數

　　　　第一個是正則str 　　　　第二個是被匹配的字串， 　　　　第三個引數：re.I 表示忽略大小寫，多個模式之間用 | 進行分隔,表示幾個模式同時使用。 　　

字元	含義	備註
re.I	忽略大小寫
re.S	對於匹配字串種的.表示匹配所有的字元，包括\n	可參考下面示例8-1或概括字符集

import re

language = 'PythonC#JavaPHP'


r = re.findall('c#.{1}', language, re.I | re.S)
print(r)

#['C#J']

　　上邊正則表示式表示匹配c#，其後是任意字元，包括\n

　　9.re.sub正則替換

　　　　　　第四個引數flag=0表示預設的將所有的C#替換，flag = 1表示只替換匹配到的第一個字串

import re

language = 'PythonC#JavaPHPC#JavaPHP'

r = re.sub('C#', 'GO', language, 0)
print(r)
#PythonGOJavaPHPGOJavaPHP

　　

　　　　內建函式replace 　　　　　　　　 　　　　　　上邊程式碼改用replace的方法進行替換。

r = language.replace('C#', 'GO')

print(r)
#PythonGOJavaPHPGOJavaPHP

　　函式在re.sub中的使用：

import re

language = 'PythonC#JavaPHPC#JavaPHP'

def convert(value):
    pass

#flag = 0表示預設的將所有的C#替換
r = re.sub('C#', convert, language, 1)

print(r)

#PythonJavaPHPC#JavaPHP

　　當re.sub中第二個引數是一個函式的時候，如果匹配到'C#'，則將匹配的結果傳到函式中作為引數，函式返回的結果去替換匹配到的內容。

import re

language = 'PythonC#JavaPHPC#JavaPHP'

def convert(value):
    print(value)

#flag = 0表示預設的將所有的C#替換
r = re.sub('C#', convert, language)

　　列印的結果是：　　

　　　　說明返回的不只有匹配到的內容，還有span（匹配到的內容的位置）

import re

language = 'PythonC#JavaPHPC#JavaPHP'

def convert(value):
    matched = value.group()
    print(matched)
    return '!!' + matched + '!!'

#flag = 0表示預設的將所有的C#替換
r = re.sub('C#', convert, language)

print(r)

　　列印的結果：

C#
C#
Python!!C#!!JavaPHP!!C#!!JavaPHP

10.re.match和re.search

import re

s = 'SD21F2S1F2SD1F1DSF5514'

r = re.match('\d', s)

print(r)

r1 = re.search('\d', s)

print(r1)
#None
#<re.Match object; span=(2, 3), match='2'>

　　match將嘗試從字串的首位開始匹配，如果匹配不上，則返回None，一旦匹配到，就將匹配結果給返回.而search搜尋整個字串，一旦找到第一個匹配的字串，就馬上將匹配的結果返回。修改s

s = '21F2S1F2SD1F1DSF5514'
r = re.match('\d', s)

　　返回的結果是：

<re.Match object; span=(0, 1), match='2'>

　　列印匹配的結果：

print(r.group())
#2

　　通過.span（）可以獲取到匹配的位置

print(r.span())
#(0, 1)

　　與re.findall對比：

r2 = re.findall('\d', s)
print(r2)
#['2', '1', '2', '1', '2', '1', '1', '5', '5', '1', '4']

　　re.findall反回了所有的匹配的結果。

　　11.group分組

import re

s = 'life is short, i use python'
r = re.search('life(.*)python', s)

print(r.group(0)) 
#group(0)永遠記錄的是完整的匹配結果
#life is short, i use python
print(r.group(1))
#group(1)則是分組的第一組
# is short, i use

　　用findall來看看

r = re.findall('life(.*)python', s)
print(r)
#[' is short, i use ']

　　但是多分組呢？

s = 'life is short, i use python, i love python'

r = re.findall('life(.*)python(.*)python', s)
print(r)

#[(' is short, i use ', ', i love ')]

　　如果用search

import re

s = 'life is short, i use python, i love python'
r = re.search('life(.*)python(.*)python', s)

print(r)
print(r.group(0)) 

print(r.group(1))
print(r.group(2))
# <re.Match object; span=(0, 42), match='life is short, i use python, i love python'>
# life is short, i use python, i love python
# is short, i use
# , i love

　　當然我們可以使用groups（）來檢視匹配結果。

print(r.groups()) 
#(' is short, i use ', ', i love ')

　　此時會返回匹配到的括號中的字元

關於正則表示式的建議：

　　　　1.正則表示式可以幫助我們完成一些字串內建函式無法 完成的功能，提高工作效率 　　　　2.正則表示式不是python獨有的，且大部分主流語言都有正則表達水。（在我看來，除了關鍵字和部分細節，在語法和功能上都與javascript的正則相似）。由於python的應用場景（爬蟲，資料處理與分析等），使得正則顯得尤為重要 　　　　3.查詢常用正則表示式，如果這個表示式在你的系統上執行良好，不妨多花些時間去 研究一下。

JSON

　　JSON是一種輕量級的資料交換格式 　　優點： 　　　　易於解讀，易於解析，網路傳輸效率高 　　JSON的反序列化： 　　　　python內建了json模組兒。

import json

json_str = '{"name":"qiyue", "age":18}'

student = json.loads(json_str)

print(type(student))
print(student)
print(student['name'])
print(student['age'])

# <class 'dict'>
# {'name': 'qiyue', 'age': 18}
# qiyue
# 18

如果JSON是一個陣列的話：

import json

json_str = '[{"name": "qiyue", "age": 18},{"name": "dongsheng", "age": 22} ]'

student = json.loads(json_str)
print(type(student))
print(student)

JSON序列化：

import json

student = [
    {'name': 'qiyue', 'age': 18, 'flag':False},
    {'name': 'dasheng', 'age': 1500}
]

json_str = json.dumps(student)

print(type(json_str))
print(json_str)
#<class 'str'>
#[{"name": "qiyue", "age": 18, "flag": false}, {"name": "dasheng", "age": 1500}]