01. 正则表达式基础知识

1.1 原子

原子是正则表达式中最基本的组成单位，每个正则表达式中至少要包含一个原子，常见的原子有以下几类：
1）普通字符作为原子
2）非打印字符作为原子
3）通用字符作为原子
4）原子表

1.1.1普通字符作为原子

我们可以使用一些普通的字符，比如数字，大小写字母，下划线等都可以作为原子使用。

import re
pattern ="baidu"
string ="http://www.baidu.com"
result1= re.search(pattern,string)
print(result1)

# 输出：
# <re.Match object; span=(11, 16), match='baidu'>

1.1.2非打印字符作为原子

所谓的非打印字符，指的是一些在字符串中用于格式控制的符号，比如换行符等。

符号	含义
\n	用于匹配一个换行符
\t	用于匹配一个制表符

import re
pattern ="\n"
string =""""http://www.baidu.com
baiduyixia
"""
result1= re.search(pattern,string)
print(result1)

# 输出：
# <re.Match object; span=(21, 22), match='\n'>

1.1.3通用字符作为原子

所谓通用字符，即一个原子可以匹配一类字符。

符号	含义
\w	匹配任意一个字母，数字或下划线
\W	匹配除字母，数字和下划线以外的任意一个字符
\d	匹配任意一个十进制数
\D	匹配除十进制数以外的任意一个其他字符
\s	匹配任意一个空白字符
\S	匹配除空白字符以外的任意一个其他字符

import re
pattern ="\w\dpython\w"
string ="abcdfphp345pythony_py"
result1= re.search(pattern,string)
print(result1)

# 输出：
# <re.Match object; span=(9, 18), match='45pythony'>

1.1.4原子表

使用原子表，可以定义一组地位平等的原子，然后匹配的时候会取该原子表中的任意一个原子进行匹配，在Python中，原子表由[]表示。
类似的，[^]代表的是除了中括号里面的原子均可以匹配。

import re
pattern1 ="\w\dpython[xyz]\w"
pattern2 ="\w\dpython[^xyz]\w"
pattern3 ="\w\dpython[xyz]\W"
string ="abcdfphp345pythony_py"
result1= re.search(pattern1,string)
result2= re.search(pattern2,string)
result3= re.search(pattern3,string)
print(result1)
print(result2)
print(result3)

# 输出：
# <re.Match object; span=(9, 19), match='45pythony_'>
# None
# None

1.2元字符

所谓元字符，就是正则表达式中具有一下特殊含义的字符

符号	含义
.	匹配除换行符以外的任意字符
^	匹配字符串的开始位置
$	匹配字符串的结束位置
*	匹配0次，1次或多次前面的原子
?	匹配0次或1次前面的原子
+	匹配1次或多次前面的原子
{n}	前面的原子恰好出现n次
{n,}	前面的原子至少出现n次
{n,m}	前面的原子至少出现n次，至多出现m次
|	模式选择符
()	模式单元符

元字符可以分为：任意匹配元字符，边界限制元字符，限定符，模式选择符，模式单元等。

1.2.1任意匹配元字符

.匹配除换行符以外的任意字符

import re
pattern =".python..."
string ="abcdfphp345pythony_py"
result1= re.search(pattern,string)
print(result1)

# 输出：
# <re.Match object; span=(10, 20), match='5pythony_p'>

1.2.2边界限制元字符

^匹配字符串的开始位置 $匹配字符串的结束位置

import re
pattern1 ="^abd"
pattern2 ="^abc"
pattern3 ="py$"
pattern4 ="ay$"
string ="abcdfphp345pythony_py"
result1= re.search(pattern1,string)
result2= re.search(pattern2,string)
result3= re.search(pattern3,string)
result4= re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

# 输出：
# None
# <re.Match object; span=(0, 3), match='abc'>
# <re.Match object; span=(19, 21), match='py'>
# None

1.2.3 限定符

常见的限定符包括*，？，+，{n}，{n,}，{n,m}

import re
pattern1 ="py.*n"
pattern2 ="cd{2}"
pattern3 ="cd{3}"
pattern4 ="cd{2,}"
string ="abcdddfphp345pythony_py"
result1= re.search(pattern1,string)
result2= re.search(pattern2,string)
result3= re.search(pattern3,string)
result4= re.search(pattern4,string)
print(result1)
print(result2)
print(result3)
print(result4)

# 输出：
# <re.Match object; span=(13, 19), match='python'>
# <re.Match object; span=(2, 5), match='cdd'>
# <re.Match object; span=(2, 6), match='cddd'>
# <re.Match object; span=(2, 6), match='cddd'>

1.2.4模式选择符

模式选择符|,可以设置多个模式，匹配时，可以从中选择任意一个模式匹配

import re
pattern1 ="python|php"
string ="abcdfphp345pythony_py"
result1= re.search(pattern1,string)
print(result1)

# 输出：
# <re.Match object; span=(5, 8), match='php'>

1.2.5模式单元

使用模式单元()将一些原子组合成一个大原子使用，小括号括起来的部分会被当做一个整体去使用。

import re
pattern1 ="(cd){1,}"
pattern2 ="cd{1,}"
string ="abcdcdcdcdfphp345pythony_py"
result1= re.search(pattern1,string)
result2= re.search(pattern2,string)
print(result1)
print(result2)

# 输出：
# <re.Match object; span=(2, 10), match='cdcdcdcd'>
# <re.Match object; span=(2, 4), match='cd'>

1.3模式修正

所谓模式修正符，即可以在不改变正则表达式的情况下，通过模式修正符改变正则表达式的含义，从而实现一些匹配结果的调整等功能。

符号	含义
I	匹配时忽略大小写
M	多行匹配
L	做本地化识别匹配
U	根据Unicode字符及解析字符
S	让.匹配包括换行符，即用了该模式修正后，.匹配就可以匹配任意的字符

import re
pattern1 ="python"
pattern2 ="python"
string ="abcdfphp345Pythony_py"
result1= re.search(pattern1,string)
result2= re.search(pattern2,string,re.I)
print(result1)
print(result2)

# 输出：
# None
# <re.Match object; span=(11, 17), match='Python'>

1.4 贪婪模式与懒惰模式

贪婪模式的核心点就是尽可能多低匹配
懒惰模式的核心点就是尽可能少低匹配
通常情况下，如果想在某些字符间匹配任意字符，像p.*y这样写没有任何的语法错误，这个时候默认是使用贪婪模式的，如果要转化为懒惰模式， 需要在对应的.*后面加上?,方可转化为懒惰模式。

import re
pattern1 ="p.*y" # 贪婪模式
pattern2 ="p.*?y" # 懒惰模式
string ="abcdfphp345Pythony_py"
result1= re.search(pattern1,string)
result2= re.search(pattern2,string,re.I)
print(result1)
print(result2)

# 输出：
# <re.Match object; span=(5, 21), match='php345Pythony_py'>
# <re.Match object; span=(5, 13), match='php345Py'>

02 正则表达式常见函数

常见的正则表达式函数有re.match()，re.search()，全局匹配函数，re.sub()。

2.1 re.match()函数

如果想要从源字符串的起始位置匹配一个模式，可以使用 re.match()函数。
re.match(pattern,string,flag)
第一个参数代表对应的正则表达式；
第二个参数代表对应的源字符；
第三个参数是可选参数，代表对应的标志位，可以放模式修正符等信息。

import re
pattern =".python."
string ="apythonhellomypythonhispythonourpythonend"
result= re.match(pattern,string)
result2= re.match(pattern,string).span()
print(result)
print(result2)

# 输出：
# <re.Match object; span=(0, 8), match='apythonh'>
# (0, 8)

2.2 re.search()函数

使用re.search()函数进行匹配，会扫描整个字符串并进行对应的匹配。

import re
pattern =".python."
string ="hellomypythonhispythonourpythonend"
result= re.match(pattern,string)
result2= re.search(pattern,string)
print(result)
print(result2)

# 输出：
# None
# <re.Match object; span=(6, 14), match='ypythonh'>

2.3 全局匹配函数

全局匹配函数会将符合模式的内容全部都匹配出来。
1）使用re.compile()对正则表达式进行预编译；
2）编译后，使用findall()根据正则表达式从源字符串中将匹配的结果全部找出。

import re
string ="hellomypythonhispythonourpythonend"
pattern = re.compile(".python.")    # 预编译
result= pattern.findall(string)    # 找出符合模式的所有结果

print(result)

# 输出：
# ['ypythonh', 'spythono', 'rpythone']

2.4 re.sub()函数

re.sub()函数可以根据正则表达式来实现替换某些字符串的功能。
re.sub(pattern, rep,string,max)
第一个参数为对应的正则表达式；
第二个参数为要替换成的字符串；
第三个参数为源字符串；
第四个参数为可选项，代表最多替换的次数，默认全部替换。

import re
string ="hellomypythonhispythonourpythonend"
pattern ="python."
result1 = re.sub(pattern,"php",string)   # 全部替换
result2 = re.sub(pattern,"php",string,2)      # 最多替换俩次
print(result1)
print(result2)

# 输出：
# hellomyphpisphpurphpnd
# hellomyphpisphpurpythonend