正则表达式
认识正则
正则表达式，又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE），是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"），是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个语法规则的字符串，通常被用来检索、替换那些符合某个模式（规则）的文本。
-
正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
-
正则表达式使用单个字符串来描述、匹配一系列匹配某个语法规则的字符串。
-
正则表达式是繁琐的，但它是强大的，学会之后的应用会让你除了提高效率外，会给你带来绝对的成就感。
-
许多程序设计语言都支持利用正则表达式进行字符串操作。
re模块的常用方法
前面的一个 r 表示字符串为非转义的原始字符串
match 方法
# 函数语法
import re
re.match(pattern, string, flags)
| 参数 | 描述 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 |
从头开始尝试匹配字符串数据(注意：如果开头就不匹配直接返回None值)
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
实例
import re
# 在www.baidu.com这个字符串里面匹配www
re.match(r'www', 'www.baidu.com') # 在起始位置匹配
re.match(r'com', 'www.baidu.com') # 不在起始位置匹配
# 返回的结果
>>>(0,3)
>>>None
search 方法
# re.search 扫描整个字符串并返回第一个成功的匹配。
# 函数语法：
re.search(pattern, string, flags=0)
函数参数说明
| 参数 | 说明 |
|---|---|
| pattern | 匹配的正则表达式 |
| string | 要匹配的字符串。 |
| flags | 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。 |
匹配成功search方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式
实例
import re
re.search('www', 'www.baidu.com').span() # 在起始位置匹配
re.search('com', 'www.baidu.com').span() # 不在起始位置匹配
# 返回结果
>>>(0,3)
>>>(10,13)
findall 方法
在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
# 语法函数
re.findall(pattern, string, flags=0)
案例
import re
result1 = re.findall(r'\d+','runoob 123 google 456')
# 返回结果
>>>["123","456"]
多个匹配模式，返回元组列表
import re
result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)
# 返回结果
>>>[('width', '20'), ('height', '10')]
compile 方法
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。
实现更高效的匹配
语法格式
re.compile(pattern, flags)
- pattern : 一个字符串形式的正则表达式
- flags 可选，表示匹配模式，比如忽略大小写，多行模式等
实例
import re
pattern = re.compile(r'\d+')
data = pattern.match('123abc').group()
split 方法
拆分字符串，和字符串当中的.split()作用一致，可以指定分割次数
语法格式
re1 = re.split(r"分割符",var1,maxsplit=1)
- maxsplit分割次数
实例
var1 = "你好|我是|张三|喜欢篮球"
re1 = re.split(r"\|",var1,maxsplit=2)
print(re1)
sub方法
sub方法类似字符串的replace()方法，用指定内容替换匹配到的字符，可以指定替换次数
语法
re.sub(r"匹配内容","替换内容",字符串,count=0)
- count替换次数
实例
var1 = "你好,我是张三,喜欢篮球"
re1 = re.sub(r"张三", "阿坤",var1)
print(re1)
正则字符
修饰符
| 修饰符 | 描述 |
|---|---|
| re.I | 使匹配对大小写不敏感 |
| re.L | 做本地识别化匹配 |
| re.M | 多行匹配，影响^和$ |
| re.S | 使.匹配，包括换行在内的所有字符 |
| re.U | 根据unicode字符集解析字符，这个标志会影响\w,\W\b,\B |
| re.A | ASCII字符模式 |
元字符
| 字符 | 描述 |
|---|---|
| . | 小数点可以匹配除了换行符\n以外的任意字符，只能匹配一个 |
| | | 逻辑操作符-或 |
| [abc] | 匹配字符集所包含的任意一个字符。 |
| [^abc] | 匹配未包含的任意字符。 |
| [a-z] | 字符范围。匹配指定范围内的任意字符。 |
| \ | 将紧跟后面的字符进行转义。 |
| （） | 对表达式进行分组，将圆括号的内容当做一个整体，并获得匹配的值 |
实例：
import re
r1 = re.match(r'张三', '张三是法外狂徒').group()
r2 = re.match(r"张三","法外狂徒张三")
r3 = re.match(r"a...c","a和和和cde")
r4 = re.match(r"d|a","abc")
# r5 = re.search(r"[bc]","apple and banana")
r5 = re.search(r"叶问[123]","叶问2")
r6 = re.findall(r"[^abc]","apple and banana")
转义字符
让其失去特殊的
| 字符 | 描述 |
|---|---|
| \n | 匹配一个换行符。 |
| \r | 匹配一个回车符。 |
| \t | 匹配一个制表符。 |
| \\ | 匹配一个斜杠 |
| ^ | 匹配^符号 |
| \$ | 匹配$符号 |
| \. | 匹配小数点. |
import re
r1 = re.search(r"\.","aa.b")
r2 = re.search(r"\$","我的资产100000$")
r3 = re.search(r"\\","大家好\我是张三")
r4 = re.search(r"\^","你好^呀")
r5 = re.search(r"\\n","大家好\\n我是张三")
预定义匹配字符集
| 字符 | 描述 |
|---|---|
| \d | 匹配一个数字字符。等价于 [0-9]。 |
| \w | 匹配字母、数字、下划线。等价于'[A-Za-z0-9_]'。 |
| \s | 匹配空白字符 |
| \D | 匹配一个非数字字符。等价于 [^0-9】。 |
| \W | 匹配非字母、数字、下划线。等价于 '[^A-Za-z0-9_]'。 |
| \S | 匹配任何非空白字符。等价于 [^ \f\n\r\t\v】 |
\w 能不能匹配汉字要视你的操作系统和你的应用环境而定。
弱不想匹配到中文，则加入修饰符re.A
实例：
import re
r1 = re.findall(r"\d","快来数一数，24678")
r2 = re.findall(r"\s","大家好\r我\t是 张三")
r3 = re.findall(r"\w","大家好，wosho 1234_ _ _",re.A)
# r3 = re.findall(r"[a-zA-Z0-9_]","大家好，wosho 1234_ _ _")
r4 = re.findall(r"\D","快来数一数，24678")
r5 = re.findall(r"\S","大家好\r我\t是 张三")
r6 = re.findall(r"\W","大家好，wosho 1234_ _ _",re.A)
print(r6)
重复匹配
| 字符 | 描述 |
|---|---|
| * | 匹配前面的子表达式零次或多次。例如，zo* 能匹配 "z" 以及 "zoo"。* 等价于{0,}。 |
| + | 匹配前面的子表达式一次或多次。例如，'zo+' 能匹配 "zo" 以及 "zoo"，但不能匹配 "z"。+ 等价于 {1,}。 |
| ? | 匹配前面的子表达式零次或一次。例如，"do(es)?" 可以匹配 "do" 或 "does" 。? 等价于 {0,1}。 |
| {n} | n 是一个非负整数。匹配确定的 n 次。例如，'o{2}' 不能匹配 "Bob" 中的 'o'，但是能匹配 "food" 中的两个 o。 |
| {n,} | n 是一个非负整数。至少匹配n 次。例如，'o{2,}' 不能匹配 "Bob" 中的 'o'，但能匹配 "foooood" 中的所有 o。'o{1,}' 等价于 'o+'。'o{0,}' 则等价于 'o*'。 |
| {n,m} | m 和 n 均为非负整数，其中n <= m。最少匹配 n 次且最多匹配 m 次。例如，"o{1,3}" 将匹配 "fooooood" 中的前三个 o。'o{0,1}' 等价于 'o?'。请注意在逗号和两个数之间不能有空格。 |
实例：
import re
r1 = re.match(r"\d{3}", "1234").group()
# r1 = re.match(r"13\d{9}|15\d{9}|17\d{9}|18\d{9}","13512344321")
# r1 = re.match(r"1[3578]\d{9}","13345678911")
r2 = re.match(r"\d{3,4}-\d{7,8}", "123-44567890")
r3 = re.match(r"\d{3,}-\d{7,}", "123-4456781290")
# r4 = re.match(r"\d{0,1}", "1234")
r4 = re.match(r"\d?","12345")
r5 = re.match(r"\d*","123456789")
位置匹配
| 字符 | 描述 |
|---|---|
| ^ | 匹配输入字符串的开始位置。 |
| $ | 匹配输入字符串的结束位置。 |
实例：
import re
r1 = re.match(r"^abc$","abc")
贪婪与非贪婪
在重复匹配时，尽可能多的去匹配，贪婪
import re
html_data = """
<ul>
<li>宝马</li>
<li>奔驰</li>
<li>奥迪</li>
<li>大众</li>
</ul>
"""
r1 = re.search(r"<li>(.*)</li>", html_data).group()
print(r1)