摘要：掃描字符串開頭掃描整個字符串，返回第一個匹配成功的結果返回所有結果的列表，失敗返回空列表返回迭代器失敗返回空比如是否區分大小寫。

re.match(pattern, string[, flags])：掃描字符串開頭
re.search(): 掃描整個字符串，返回第一個匹配成功的結果
re.findall()：返回所有結果的列表，失敗返回空列表
finditer() 返回迭代器 失敗返回空
flags 比如是否區分大小寫。
re.I：忽略大小寫  ignorecase
re.M:多行匹配 會影響$和^  multiline
re.S:會匹配包括換行符在內的所有字符 # DOTALL dot matches all

import re
tmp = "http"
print(re.match(tmp,"http://www.baidu.com")) 
# <_sre.SRE_Match object; span=(0, 4), match="http">
print(re.match(tmp,"://wwwhttp.baidu.com")) 
# None
print(re.match(tmp,"http://www.baidu.com").span())
# (0, 4)

print(re.search(tmp, "www.Http://baidu.com", re.I))
# <_sre.SRE_Match object; span=(4, 8), match="Http">

print(re.findall(tmp, "http://www.http.com"))
# ["http", "http"]

find = re.finditer(tmp, "http://HTTp.com0", re.I)
for i in find:
    print(i)
# <_sre.SRE_Match object; span=(0, 4), match="http">
# <_sre.SRE_Match object; span=(7, 11), match="HTTp">

· 匹配除換行符以外的所有字符

[] 是字符的集合,匹配括號中任意字符

[a-zA-Z] 大小寫字符

[0-9]

[^0-9]除數字外的所有字符 ^托字符

d 匹配數字，效果等同于[0-9]

D 匹配除數字以外的字符 [^0-9]

w 匹配數字，字母及下劃線 效果等同于[0-9a-zA-Z_]

W 取反

s 匹配任意空白字符（空格，換行，制表，換頁，回車）[ntfr]

S 取反

print(re.findall(".","http:
//"))
# ["h", "t", "t", "p", ":", "/", "/"]
print(re.findall("[12345]","qhchg461905nkj"))  
# ["4", "1", "5"]


# 保留原始字符的R/r在正則中無效
print(re.findall(r"D","123qwr"))
# ["q", "w", "r"]

print(re.findall("S","123 gh 
 78
"))
# ["1", "2", "3", "g", "h", "7", "8"]

^ 行首匹配(不在方括號內)

$ 行尾匹配（不在方括號內）當需要進行多行匹配時候，需要設置flags=re.M，如果不寫默認匹配字符串的開頭和結尾 只匹配一次

A 行首匹配 與^的區別:A只匹配整個字符串的開頭，即使有flags = re.M參數也不會匹配其他的行首

Z 行尾匹配 與$的區別：Z只匹配整個字符串的結尾，即使有flags = re.M參數也不會匹配其他的行尾

b 匹配字符邊界 就是字符串與空格間的位置，比如"ce",可以匹配nice 不能匹配nicer

B 匹配非字符邊界

# 看你是否nice開始 類似于match
print(re.findall("^nice","to nice meet you"))
# []

# 多行開頭匹配
print(re.findall("^nice","nice to meet you
nice to meet you", re.M))
# ["nice", "nice"]

# 是否是com結尾
print(re.findall("com$", "http:baidu.com"))
# ["com"]

#  本身是個轉義字符，但在正則中也有特殊意義，在正則字符串前面加r
# 將將轉義字符的意義去掉 保留正則的意義
# 以空格有邊界的有一個ce
print(re.findall(r"ce", "nice to meet niceto meet"))
# ["ce"]

(abc) 匹配小括號中的字符作為整體

x? ? 匹配0或1個x字符 非貪婪匹配

x+ + 匹配至少一個x 貪婪匹配

x* * 匹配任意多個x 貪婪匹配

x{n} 匹配確定的n個x 非負整數

x{n,} 匹配大于等于n個x

x{n,m} 匹配至少n個x，最多m個

x|y 匹配x或y

print(re.findall("[abc]", "qwracb"))
# ["a", "c", "b"]

print(re.findall("(abc)", "qwrabc"))
# ["abc"]

print(re.findall("a?","a"))
# ["a", ""]

print(re.findall("(aa)?", "aaab"))
# ["aa", "", "", ""]

print(re.findall("(aa)","aaaab"))
# ["aa", "aa"]
print(re.findall("(aa)+","aaaab"))  
# 由于是貪婪匹配，相當于在最長的aaaa中找出： ["aa"]

print(re.findall("aa+","aabaaaabaaaba")) 
# 最后一個a沒 ["aa", "aaaa", "aaa"]

print(re.findall("a*", "abaabbaaabaaaabb"))
# 匹配任意多個a
# ["a", "", "aa", "", "", "aaa", "", "aaaa", "", "", ""]

print(re.findall("a{3}","aabaaacsdsaaa"))
# ["aaa", "aaa"]
print(re.findall("a{3,}","aabbaaabbaaaa"))
# ["aaa", "aaaa"]

print(re.findall("(good)","good--Good-good"))
print(re.findall("good","good--Good-good"))
# ["good", "good"]

print(re.findall("(good)|(Good)","good--Good"))
# [("good", ""), ("", "Good")]
print(re.findall("good|Good","good--Good"))
# ["good", "Good"]

.   匹配除換行符以為的所有字符
*   匹配任意多個 貪婪匹配
?   匹配0個或一個
.*? 將貪婪匹配變為非貪婪

print(re.findall(".",""))
# []
print(re.findall(".*",""))  
# [""]

r = "who .* he"
print(re.findall(r, "who is a girl he who is boy he "))
# ["who is a girl he who is boy he"] 貪婪

r = "who .*? he"
print(re.findall(r, "who is a girl he who is boy he who  he"))
# ["who is a girl he", "who is boy he", "who  he"] 非貪婪

正則中有組的概念
分組：group
正則有判斷是否匹配的功能，還提供了提取子串的功能，用()表示提取的分組，從外向里，從左向右標注第幾組

tmp = "d{3}-d{8}"
str1 = "010-12345678"
result = re.findall(tmp, str1)
print(result)
# ["010-12345678"]

tmp2 ="(d{3})-(d{8})" # 用小括號括起來的內容為一組
result2 = re.findall(tmp2, str1)
print(result2)
# [("010", "12345678")]

tmp3 = "(d{3})-(d{8})"
result3 = re.match(tmp3, str1)
print(result3)
# <_sre.SRE_Match object; span=(0, 12), match="010-12345678">

# groups()可以查看匹配到的所有分組的情況
print(result3.groups())  # ("010", "12345678")

# group() 可以多帶帶獲取分組情況
# group(0) 一直代表匹配到的原始字符串
print(result3.group())   # 010-12345678
print(result3.group(0))  # 010-12345678
print(result3.group(1))  # 010
print(result3.group(2))  # 12345678

# 另起名稱(?P<名稱>)
tmp4 = "(?Pd{3})-(?Pd{8})"
result4 = re.match(tmp4, str1)
print(result4.group(0))
print(result4.group(1))
print(result4.group(2))
print(result4.group("love"))

str1 = "ac b  c   d     e"
print(str1.split())
# ["ac", "b", "c", "d", "e"]

print(re.split(" +", str1))
# ["ac", "b", "c", "d", "e"]

# 替換字符串
# re.sub(pattern, rep1, string)
# pattern: 即將被替換的字符
# rep1:替換的字符
# count 替換次數
# subn 將結果和替換的次數放到一個元組了
res2 = re.sub(" +", "*", str1)
print(res2)  
# ac*b*c*d*e

res2 = re.sub(" +", "*", str1, count=2)
print(res2)
# ac*b*c   d     e

res2 = re.subn(" +", "*", str1)
print(res2)
# ("ac*b*c*d*e", 4)

tmp = "d{3}-d{8}"
str1 = "090-99999999"
res = re.match(tmp, str1)
print(res)

tmp2 = "d{3}-d{8}"
str2 = "090-99999999"
re_tmp2 = re.compile(tmp2)
res2 = re_tmp2.match(str2)
print(res2)
# <_sre.SRE_Match object; span=(0, 12), match="090-99999999">

# 判斷某一個字符串是不是11位，第一個是否是數字1

r= "^1d{10}$"
# 1開頭
# 10個數字結尾

print(re.findall(r, "12534568545"))


# 前面是3個數字 后面八個數字 中間為-

r= "^d{3}-d{8}$"


# 123456@qq.com
# ^.$ 在正則中有實際意義，如果想要作為普通字符使用需要使用轉義字符

r= "^d{6}@qq.com"    
print(re.findall(r,"125565@qq.com"))