正則表達式

from re import fullmatch, search, findall

1.什么是正則表達式

正則表達式是處理字符串的工具，通過不同的正則符號來描述字符串的規(guī)則
正則符號（語法）

匹配符號

1)普通字符：除了在正則中有特殊功能和特殊意義的符號以外的字符都是普通字符

普通字符：代表字符本身

fullmatch(正則表達式，字符串) - 查看字符串和正則表達式是否匹配，如果不匹配返回結(jié)果None

正則表達式：r'正則語法'

1).匹配一個字符串有三個字符，分別是'a', 'b', 'c'

re_str = r'abc'  #
result = fullmatch(re_str, 'abc')
print(result)

2) . - 匹配一個任意字符 （一個 . 只能匹配一個字符）

匹配一個字符串長度是8，前三個是abc，中間兩個點表示任意字符，后三個字符是123

re_str = r'abc..123'
result = fullmatch(re_str, 'abc21123')
print(result)

3).\w - 匹配一個數(shù)字、字母或者下劃線_ （一個\w智能匹配一個字符）(在ASCII碼表中)

匹配一個長度為4的字符串，第一個字符是數(shù)字、字母或者下劃線_，后面的三個字符是'abc'

re_str = r'\wabc'
result = fullmatch(re_str, '_abc')
print(result)

4) \d - 匹配任意一個數(shù)字字符

匹配一個長度為5的字符串，前兩個字符時任意數(shù)字，后面三個是任意字符

re_str = r'\d\d...'
result = fullmatch(re_str, '12l==')
print(result)

5) \s 匹配任意一個空白字符

（space（）、enter、tab）

result = fullmatch(r'how\s\s\sare!', 'how \t\nare!')
print(result)

6）\大寫字母

\D - 匹配除了數(shù)字字符以外的任意字符（非數(shù)字字符）
\S - 匹配非空白字符

re_str = r'\Dabc\S'
print(fullmatch(re_str, 'aabcs'))

7）[字符集] - 匹配字符集出現(xiàn)的任意一個字符

注意：一個[]只能匹配一個字符

a.

[abc] - 匹配abc中任意一個字符
[a123] - 匹配a123中任意一個字符（a或1或2或3）
[\d\s] - 匹配任意一個數(shù)字或空白字符

b.

[1-9] - 匹配1-9中任意一個字符（字符編碼遞增）
[a-z]
[A-Z]
[a-zA-Z] - 匹配一個字母
[a-zA-Z\d_] 或 [a-zA-Z0-9_]- 匹配任意一個數(shù)字字母下劃線
[ \t\n] - 匹配任意一個空白字符
[\u4e00-\u9fa5] - 匹配任意一個中文字符

8）[^字符集] - 匹配不在字符集中的任意一個字符

[^abc]
[^2-8] - 匹配任意一個不是2到8的字符
[^\u4e00-\u9fa5] - 不知中文

檢測符號

所有的檢測符號都不會影響字符串長度

1）\b - 檢查是否是單詞邊界

單詞邊界 - 能夠?qū)蓚€單詞隔開并且不會產(chǎn)生歧義的任意符號：空白字符、標點符號等，字符串開頭和字符串結(jié)尾
匹配規(guī)則：先去掉\b再對字符串進行匹配，如果匹配成功在檢查\b所在位置是否是單詞邊界

匹配一個字符串長度是6，每個字符串分別是abc123；并且要求abc和123之間是單詞邊界

re_str = r'abc\b123'
print(fullmatch(re_str, 'abc,123'))   # None

re_str = r'abc\b,123'
print(fullmatch(re_str, 'abc,123'))   # <re.Match object; span=(0, 7), match='abc,123'>

2) ^ - 在[]外使用，檢查 ^ 所在位置是否是字符串開頭

re_str = r'\d\d\d'

print(fullmatch(re_str, '345'))

print(search(re_str, 'sadjksfhsd123sdasda===898'))

print(findall(re_str, 'sadjksfhsd123sdasda===898'))

3) 所咋在是否是字符串結(jié)尾

re_str = r'\d\d\d$'

print(fullmatch(re_str, '345'))

print(search(re_str, 'sadjksfhsd123sdasda===898'))

print(findall(re_str, 'sadjksfhsd123sdasda===898'))

控制次數(shù)的符號：

1. * - 匹配0次或多次

123a* - 123后a出現(xiàn)0次或多次

123， 123a, 123aa,.....

123\d* - 123后面出現(xiàn)0個或多個任意字符，如123，1230,123546

123[mnxy9]* - 123n,123m,123mmn,123999999,.....

re_str = r'abc0*123'
print(fullmatch(re_str, 'abc00000123'))

2. + - 匹配一次或多次

123a+ - 123a, 123aa, 123aaa, ....

re_str = r'123[a-z]+'
print(fullmatch(re_str, '123sda'))

3. ? - 匹配0次或者1次

-?123 - 123, -123

re_str = r'_?abc'
print(fullmatch(re_str, 'abc'))

4. {}

1）{N} - 匹配N次

a{3} - 匹配三個a, aaa
\d{3} - 匹配三個任意數(shù)字， 123 ，546

2）{M,N} - 匹配M - N次（匹配至少M次最多N次）

3）{M,} - 至少匹配M次

4){,N} - 至多匹配N次

匹配電話號碼

re_str = r'1[3-9]\d{9}'

匹配密碼：6-12數(shù)字或字母

re_str = r'[a-zA-Z\d]{6,12}'

5.貪婪和非貪婪

在匹配次數(shù)不確定的時候，會出現(xiàn)貪婪和非貪婪兩種情況；默認情況都是貪婪的。

貪婪：在能夠匹配成功的前提下，匹配次數(shù)盡可能多

非貪婪：在能夠匹配成功的前提下，匹配次數(shù)盡可能少(在匹配次數(shù)后面加？)

*？
+?
??
{M,N}?
{,N}?
{M,}?

re_str = r'a.+'
print(search(re_str, 'hjsafkja==sa'))
# <re.Match object; span=(3, 12), match='afkja==sa'>
# 貪婪的取最多次

print(search(r'a\d{3,5}', 'fga123548ad'))
# <re.Match object; span=(2, 8), match='a12354'>

print(search(r'a\d{3,5}?', 'fga123548ad'))
# <re.Match object; span=(2, 6), match='a123'>

分支

1. | - 在兩個中選擇一個

正則1|正則2 - 先讓正則1去匹配如果匹配成功就成功，如果匹配失敗再讓正則2去匹配
（正則1和正則2中只要有一個能匹配成功就行）

re_str = r'abc|123'
print(fullmatch(re_str, 'abc'))
print(fullmatch(re_str, '123'))

練習1：寫一個正則表達式匹配一個字符串：abc的前面是兩個數(shù)字或者兩個大寫字母

re_str = r'\d\dabc|[A-Z]{2}abc'

分組

1.() - 將括號中的內(nèi)容作為一個整體

1)整體操作

r'(\d\d|[A-Z]{2})abc'   # 匹配一個字符串：abc的前面是兩個數(shù)字或者兩個大寫字母

r'([a-z]\d){3}'  - a8v8d9

2)分組 - 將結(jié)果分段

a.
分組截?。悍奖愫竺娣侄位蛘叻智闆r取不同的匹配結(jié)果
b.
分組重復(fù)：在正則中用\X來重復(fù)前面第X個分組匹配到的內(nèi)容
注意：\X的前面必須有這個分組

re_str = r'(\d{3})[a-z]{3}'
print(fullmatch(re_str, '344hsj'))
print(findall(re_str, 'add123358fw989ned131asd=jkD=as232dd1das313das--d5d'))
# ['989', '131', '313']

# 234hjk234,112kls112
re_str = r'(\d{3})[a-z]{3}\1'   # 重復(fù)第一個分組的內(nèi)容

轉(zhuǎn)義符號

1.加\

在正則中有特殊功能和特殊意義的符號前加''，讓這個符號的特殊功能和意義消失

re_str = r'\d{3}\.[a-z]{3}'
print(fullmatch(re_str, '123.zxc'))

re_str = r'a\+\d{3}'
print(fullmatch(re_str, 'a+344'))

2.加[]

在[]括號中有特殊意義的符號：a. ^ 放在開頭 b. - 放在兩個字符之間
其他符號：. + ? * $ 這些單獨的符號在[]括號中都表示這個人符號本身

re_str = r'\d{3}[.][a-z]{3}'
print(fullmatch(re_str, '123.aaa'))

re模塊

re模塊式python提供的，專門針對正則表達式應(yīng)用的相關(guān)函數(shù)

1.compile（正則表達式） ->> 將正則表達式轉(zhuǎn)換成正則對象

re_obj = compile(r'\d{3}')
fullmatch(r'\d{3}', '345')

re_obj.fullmatch('234')

字符串匹配

fullmatch(正則表達式, 字符串) - 讓正則表達式和字符串完全匹配
match(正則表達式, 字符串) - 匹配字符串開頭（字符串開頭滿足正則）

匹配成功返回匹配對象，匹配失敗返回None

re_str = r'\d{3}'
print(fullmatch(re_str, '123'))
print(match(re_str, '123llj'))

1）匹配對象

result = fullmatch(r'(\d{3})=([a-z]{2})', '234=am')
print(result)
# <re.Match object; span=(0, 6), match='234=am'>

a.獲取匹配結(jié)果

匹配對象.group() - 獲取整個正則表達式匹配到的字符串，結(jié)果是字符串
匹配對象.group(N) - 獲取整個正則表達式中第N個分組匹配到的字符串，結(jié)果是字符串

print(result.group())
# 234=am
print(result.group(1))
# 234
print(result.group(2))
# am

獲取匹配到的字符串在原字符串中的位置

result = match()

匹配對象.span() ->返回匹配結(jié)果在源字符串中的下標范圍
匹配對象.span(N) ->返回第N個分組匹配到的結(jié)果在原字符串中的范圍

result = match(r'(\d{3})=([a-z]{2})', '234=am')
print(result.span())  # (0, 6)

print(result.span(2))  # (4, 6)
start, end = result.span(1)
print(start, end)
# 0 3

c.獲取原字符串

匹配對象.string

print(result.string)
# 234=am

3.查找

1)search(正則表達式，字符串) - 在字符串中找到第一個滿足正則表達式的子串，如果找到了

結(jié)果是匹配對象，找不到返回None

2)findall(正則表達式, 字符串) - 獲取字符串中所有滿足正則表達式的子串；返回值是一個列表

注意：如果正則表達式中有分組，列表中的匹配結(jié)果只會取分組匹配到的內(nèi)容

3）finditer(正則表達式, 字符串) - 獲取字符串中所有滿足正則表達式的子串

result = search(r'\d{3}', 'dasqwe1321eqeq122asdaf')
print(result)

result = findall(r'\d{3}[a-z]{2}', 'sad123dwq541gda555dad5s5df5')
print(result)
# ['123dw', '541gd', '555da']

result = findall(r'(\d{3})[a-z]{2}', 'sad123dwq541gda555dad5s5df5')
print(result)
# ['123', '541', '555']

result = findall(r'(\d{3})([a-z]{2})', 'sad123dwq541gda555dad5s5df5')
print(result)
# [('123', 'dw'), ('541', 'gd'), ('555', 'da')]

result = finditer(r'(\d{3})([a-z]{2})', 'sad123dwq541gda555dad5s5df5')
group = []
group1 = []
group2 = []
for x in result:
    group.append(x.group())
    group1.append(x.group(1))
    group2 .append(x.group(2))

print(group)
print(group1)
print(group2)
# ['123dw', '541gd', '555da']
# ['123', '541', '555']
# ['dw', 'gd', 'da']

4.切割

split(正則表達式, 字符串) - 將字符串中滿足正則表達式的子串作為切割點對字符串進行切割；返回一個字符串列表

result = split(r'\d+', 'das12dsa54gds875fsalos4548dds')
print(result)
# ['das', 'dsa', 'gds', 'fsalos', 'dds']

5.替換

sub(正則表達式, 字符串1, 字符串2) - 將字符串2中所有滿足正則表達式的子串都替換成字符串1；返回替換后的字符串