正则表达式，又称规则表达式,（Regular Expression，在代码中常简写为regex、regexp或RE），是一种文本模式，包括普通字符（如：a 到 z 之间的字母）和特殊字符（称为"元字符"），是计算机科学的一个概念。正则表达式使用单个字符串来描述、匹配一系列匹配某个语法规则的字符串，通常被用来检索、替换那些符合某个模式（规则）的文本。

• 正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。
• 正则表达式使用单个字符串来描述、匹配一系列匹配某个语法规则的字符串。
• 正则表达式虽然繁琐，但确是很强大的，可以提高效率
• 许多程序设计语言都支持利用正则表达式进行字符串操作。

正则表达式的应用场景：

• 表单验证(例如 : 手机号、邮箱、身份证.... )
• 爬虫

1.普通字符

字母、数字、汉字、下划线、以及没有特殊定义的符号，都是普通字符。正则表达式中的普通字符，在匹配的时

候,只匹配与自身相同的一个字符。

如：表达式c，在匹配字符串"abcde"时，匹配结果是：成功；匹配到的内容是c；匹配到的位置开始于2，结束于3。

注意： 下标从0开始还是从1开始，因当前编程语言的不同而可能不同

2.match()函数

• match(pattern, string[,flags])
• 第一个参数是正则表达式，如果匹配成功，则返回一个match对象，否则返回一个None
• 第二个参数表示要匹配的字符串
• 第三个参数是标志位用于控制正则表达式的匹配方式。如: 是否区分大小写，多行匹配等

flags匹配模式（标志位）：

使用match()函数，需要导入模块：re模块是内置库，不用我们去安装，直接导入使用即可

#导入模块
import re

代码示例：match()函数的使用

import re

#pattern = 'ad' # bd在string中并不是连贯存在的
#pattern = 'a' # 此时匹配成功
pattern = 'b' # 此时匹配失败，发生错误
string = 'abcdefg'
#result = re.match(pattern,string).group() #group()捕获
result = re.match(pattern,string)

print(result)
if result:
    print("匹配成功")
else:
    print("匹配失败")

注意：

• 正则表达式的匹配模式一定要是作为一个整体去进行匹配的，必须连贯的，不能单独存在
• match()对象是从头开始匹配的，如果最开始的地方没有匹配到，那么一定会返回None
• 在正则表达式没有匹配到的情况下，使用group()想去捕获匹配到的内容会发生报错

3.元字符

正则表达式中使⽤了很多元字符，⽤来表示⼀些特殊的含义或功能的字符

代码示例：元字符的使用

import re

# .
pattern = 'w.q'
string = "wwq" # 此时匹配成功
#string = "wwwq" # 此时匹配失败，不满足从开始位连贯匹配的整体条件
result = re.match(pattern,string).group()
print(result)

import re

# |
pattern = 'w|q'
string = 'w' # 取得字符 w
# string = 'q' # 取得字符 q
# string = 'wq' # 取得字符 w
# string = 'qw' # 取得字符 q
# string = 'zw' # 匹配失败
result = re.match(pattern,string).group() # match()函数是从最开始开始匹配且或者|只能取得开头的第一个字符
print(result)

import re

# [] -- 任意匹配中括号里面的其中一个字符
print(re.match('[wqz]','w').group()) 
print(re.match('[wqz]','q').group())
print(re.match('[wqz]2','w2').group())

import re

# [^] -- 取反是在括号的里面进行取反，指的是除括号里面的内容取不到以外，其它全可以取到
print(re.match('[^a-z]','S').group())
print(re.match('[^a-z]','3').group()) 
# print(re.match('[^a-z]','w').group()) # 匹配失败，发生错误

import re

# - -- 指的是匹配一个范围
print(re.match('[a-z]','w').group()) # 匹配a到z

import re

#\ -- 转义，有特殊数据或特殊字符时才会用到
print(re.match('开发者社区温轻舟2','开发者社区温轻舟.').group()) # 匹配失败
print(re.match('开发者社区温轻舟.','开发者社区温轻舟2').group())
print(re.match('开发者社区温轻舟.','开发者社区温轻舟.').group())
print(re.match('开发者社区温轻舟\.','开发者社区温轻舟.').group())
# print(re.match('开发者社区温轻舟\.','开发者社区温轻舟2').group()) # 匹配失败

import re

# ()分组
print(re.match('(wq.)','wqz').group(1)) # 如果分组较多时记得标序号
print(re.match('(wq.)','wqz').groups()) # 获取所有的分组

'''
分组功能
Python的re模块有一个分组功能。所谓的分组就是去已经匹配到的内容再筛选出需要的内容，相当于二次过滤。实现分组靠圆括号()，而获取分组的内容靠的是group()；groups()，re模块里的某个重要方法在分组上，有不同的表现形式，需要区别对待
'''

一些无法书写或者具有特殊功能的字符，采用在前面加斜杠进行转义的方法，如：

注意： 尚未列出的还有问号？；星号*和括号等其他的符号。所有正则表达式中具有特殊含义的字符在匹配自身的时候，都要使用斜杠进行转义。这些转义字符的匹配用法与普通字符类似，也是匹配与之相同的一个字符

4.预定义匹配字符集

正则表达式中的一些表示方法，可以同时匹配某个预定义字符集中的任意一个字符。

如，表达式\d可以匹配任意一个数字。虽然可以匹配其中任意字符，但是只能是一个，不是多个

代码示例：预定义匹配字符集的使用

import re
print(re.match('\d\d\d','123123123').group())

print(re.match('\w','1').group())
print(re.match('\w','a').group())
print(re.match('\w','A').group())
print(re.match('\w','_').group())

print(1) # 这里是为了方便查看
print(re.match('\s',' ').group())
print(2) # 这里是为了方便查看
print(re.match('\s','\t').group())
print(3) # 这里是为了方便查看
print(re.match('\s','\n').group())

5.重复匹配

前面的表达式，无论是只能匹配一种字符的表达式，还是可以匹配多种字符其中任意一个的表达式，都只能匹配一次。但是有时候我们需要对某个字段进行重复匹配。

如：手机号码13666666666，一般的新手可能会写成\d\d\d\d\d\d\d\d\d\d\d（这并不是一个恰当的表达式），不但写着费劲，看着也累，还不⼀定准确恰当。

代码示例：重复匹配表达式的使用

import re
# {n}
print(re.match('\d{3}','123').group())

# {m,n}
print(re.match('\d{3,4}-\d{7,8}','0730-1008611').group())

# {m,}
print(re.match('\d{3,}','07301008611').group())

# ?
print(re.match('w[qz]?','w').group())
print(re.match('w[qz]?','wq').group())
print(re.match('w[qz]?','wz').group())
print(re.match('w[qz]?','wqz').group()) 

# +
print(re.match('w[a-z]+','wqz').group())
print(re.match('w[a-z]+','wq').group())
# print(re.match('w[a-z]+','w').group()) # 发生错误

# *
print(re.match('w[a-z]*','wqz').group())
print(re.match('w[a-z]*','wq').group())
print(re.match('w[a-z]*','w').group())

注意：

• 正则写的表达式，一定要当一个整体去看
• 因为我们在取值的过程中，像div这种标签特别的多，很难知道在哪里开始到哪里结束，所以?表达式就显得尤为重要

6.位置匹配

有时候，我们对匹配出现的位置有要求，比如开头、结尾、单词之间等等

代码示例：位置匹配表达式的使用

import re

# ^
print(re.match('^a\d{3,}','a123456').group())
# print(re.search('^a\d{3,}','ba123456').group()) # 发生报错，因为没有以指定的a开头
print(re.search('^a\d{3,}','a123w456').group())

# $
# print(re.search('^a\d{3,}w$','a123w456').group()) # 发生报错，因为没有以指定的w开头
print(re.search('^a\d{3,}w$','a123456w').group())

注意：

• 后两个表达式（\b和\B）极少会去使用
• 注意区分位置表达式的开始匹配（^）与元字符中的字符集求反表达式（[^]）

7.贪婪与非贪婪

在重复匹配时，正则表达式默认总是尽可能多的匹配，这被称为贪婪模式。

贪婪与非贪婪的示例代码：

import re

a = '<div>aliyun</div><div>wqz</div>'
# 取到<div>aliyun</div>这个值

# b = '<div>.*</div>' # 此时会取到所有的值，因为*是贪婪的
b = '<div>.*?</div>'
print(re.match(b,a,re.S).group())

注意：

• 非贪婪的属性：.*?
• 贪婪的属性：.*

（1）校验数字的相关表达式：

（2）特殊场景的表达式：

8.re模块常用方法

（1）compile(pattern, flags=0)

这个方法是re模块的工厂法，⽤于将字符串形式的正则表达式编译为Pattern模式对象，可以实现更加效率的匹配。第二个参数flag是匹配模式 使用compile()完成一次转换后，再次使用该匹配模式的时候就不能进行转换了。经过compile()转换的正则表达式对象也能使用普通的re方法

import re
pattern = re.compile('python')
text = 'python2024'
print(pattern,type(pattern)) # 此时返回的是一个re对象
print(pattern.match(text).group())

（2）search(pattern, string, flags=0)

从当前字符串中进行全局搜索，返回第一个匹配到的字符串。它的返回值类型和使用方法与match()是一样的，唯一的区别就是查找的位置不用固定在文本的开头

（3）findall(pattern, string, flags=0)

作为re模块的三大搜索函数之一，findall()和match()、search()的不同之处在于，前两者都是单值匹配，找到一个就忽略后面，直接返回不再查找了。而findall()是全文查找，它的返回值是一个匹配到的字符串的列表。这个列表没有group()方法，没有start、end、span，更不是一个匹配对象，仅仅是个列表！如果一项都没有匹配到那么返回一个空列表

import re
i = '1*2+3-4/1' 
print(re.findall('\d',i)) # 将数字分割出来

（4）split(pattern, string, maxsplit=0, flags=0)

re模块的split()方法和字符串的split()方法很相似，都是利用特定的字符去分割字符串。但是re模块的split()可以使用正则表达式，因此更灵活，更强大。split()有个参数maxsplit，用于指定分割的次数

import re
i = '1*2+3-4/1' 
print(re.split('[\*\+\-\/]',i,maxsplit=2)) # 将数字分割出来，切2段，所以是3块

（5）sub(pattern, repl, string, count=0, flags=0)

sub()方法类似字符串的replace()方法，用指定的内容替换匹配到的字符，可以指定替换次数

import re
n = '<*温轻舟?'
print(re.sub('[\/:*?"<>!]','',n)) # 将n中的特殊字符替换掉