python 正则模块（re）

最新推荐文章于 2025-03-12 18:35:38 发布
原创 最新推荐文章于 2025-03-12 18:35:38 发布
· 891 阅读 · 1 ·
版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python #p2p #gnu

本文介绍了Python的re模块，详细讲解了正则表达式的应用场景，如手机号、邮箱的校验，以及re模块的常用函数，如match、search、findall、split、sub和subn的用法，并给出了多个实际案例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.正则表达式常见的具体应用场景如下：

  1. 手机号校验；

  2. 邮箱校验；

  3. 身份证校验；

  4. 网页标签匹配；

  5. 车牌号校验；

  6. 中文校验；

2.re模块

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。re 模块使 Python 语言拥有全部的正则表达式功能。 

1>元字符，量词，贪婪与非贪婪匹配，分组与或的使用

元字符：

字符功能
.匹配任意1个字符（除了\n）
[ ]匹配[ ]中列举的字符
\d匹配数字，即0-9
\D匹配非数字，即不是数字
\s匹配空白，即 空格
\S匹配非空白
\w匹配单词字符，即a-z、A-Z、0-9、_
\W匹配非单词字符
#案例演示01：（.	匹配任意1个字符（除了\n））


# .	匹配任意1个字符（除了\n）
import re

ret = re.match("t.o", "t\no")
if ret:
    print(ret.group())
else:
    print("匹配失败")

# .	匹配任意1个字符（除了\n）
import re

ret = re.match("t.o", "two")
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示02：（[ ]   匹配[ ]中列举的字符 ,只匹配任意一个字符）


# [ ]	匹配[ ]中列举的字符 ,只匹配任意一个字符
import re

ret = re.match("t[1wqs]o", "two")   # 将w换成9，查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示03：（\d  匹配数字，即0-9）


# \d	匹配数字，即0-9
import re

ret = re.match("t\do", "t6o")   # 将6换成a，查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示04：（\D  匹配非数字，即不是数字）


# \D	匹配非数字，即不是数字
import re

ret = re.match("t\Do", "two")   # 将w换成7，查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示05：（\s  匹配空白，即 空格）


# \s	匹配空白，即 空格
import re

ret = re.match("t\so", "t o")   # 将空格换成z，查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示06：（\S  匹配非空白）


# \S	匹配非空白
import re

ret = re.match("t\So", "two")  # 将w替换成空格，查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示07：（\w  匹配单词字符，即a-z、A-Z、0-9、_）


# \w	匹配单词字符，即a-z、A-Z、0-9、_
import re

ret = re.match("t\wo", "t_o")   # 将_分别替换成a、A、z、Z，分别查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


#案例演示08：（\W  匹配非单词字符）


# \W	匹配非单词字符
import re

ret = re.match("t\Wo", "t%o")   # 将%分别替换成a、A、#、&，分别查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")

量词：

字符功能
*匹配前一个字符出现0次或者无限次，即可有可无
+匹配前一个字符出现1次或者无限次，即至少有1次
?匹配前一个字符出现1次或者0次，即要么有1次，要么没有
{m}匹配前一个字符出现m次
{m,n}匹配前一个字符出现从m到n次
案例演示01：（*   匹配前一个字符出现0次或者无限次，即可有可无）


# *	匹配前一个字符出现0次或者无限次，即可有可无
import re
ret = re.match("tw*o","twwo")   # 将ww分别替换成w、www、wwwwwwwww或者删除ww，分别查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")


案例演示02：（+   匹配前一个字符出现1次或者无限次，即至少有1次）


# +	匹配前一个字符出现1次或者无限次，即至少有1次
import re
ret = re.match("tw+o","twwo")    # 将ww分别替换成w、www、wwwwwwwww或者删除ww，分别查看匹配结果，并比较与									*的区别
if ret:
    print(ret.group())
else:
    print("匹配失败")


案例演示03：（?   匹配前一个字符出现1次或者0次，即要么有1次，要么没有）


# ?	匹配前一个字符出现1次或者0次，即要么有1次，要么没有        
import re
ret = re.match("tw?o","to")
if ret:
    print(ret.group())
else:
    print("匹配失败")

贪婪与非贪婪匹配：（？非贪婪匹配 +* 贪婪匹配）

案例演示04：（{m} 匹配前一个字符出现m次）


# {m}	匹配前一个字符出现m次
import re
ret = re.match("tw{2}o", "twwo")   # 将ww替换为www，查看匹配结果，比较区别
if ret:
    print(ret.group())
else:
    print("匹配失败")


案例演示05：（{m,n}   匹配前一个字符出现从m到n次）


# {m,n} 匹配前一个字符出现从m到n次
import re
ret = re.match("tw{3,5}o","twwwwwo")  # 将wwwww替换为ww，查看匹配结果
if ret:
    print(ret.group())
else:
    print("匹配失败")
    
# 特殊情况说明{3，}，对应含义为：匹配前一字符至少出现三次的情况；
import re
ret = re.match("tw{3,}o","twwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwo")
if ret:
    print(ret.group())
else:
    print("匹配失败")
    
# 特殊情况说明{，5}，对应含义为：匹配前一字符最多出现5次的情况；
import re
ret = re.match("tw{,5}o","twwwo")
if ret:
    print(ret.group())
else:
    print("匹配失败")

分组与或的使用：

匹配分组

字符功能
|匹配左右任意一个表达式
(ab)将括号中字符作为一个分组
\num引用分组num匹配到的字符串
(?P<name>)分组起别名
(?P=name)引用别名为name分组匹配到的字符串
案例演示01：（(ab)    将括号中字符作为一个分组）

# (ab)	将括号中字符作为一个分组    www.baidu.com
import re
ret = re.match("^(https://www)\.[a-z]+(\.com)$", "https://www.baidu.com")
if ret:
    print(ret.group())
else:
    print("匹配失败")


案例演示02：（|   匹配左右任意一个表达式）


# 定义邮箱列表
email_list = ["xiaoWang@163.com", "xiaoWang@163.comheihei", "12345678@qq.com"]
# 导包
import re
# 遍历列表，获取列表中的邮箱字符串
for email in email_list:
    # 匹配每一个邮箱字符串，判断是否符合邮箱格式要求
    ret = re.match("\w{4,20}@(163|qq|sina|139)(.com)$", email)
    if ret:
        print("正确邮箱：", ret.group())
    else:
        print("%s匹配失败" % email)


案例演示03：（\num    引用分组num匹配到的字符串）


# 匹配标签：<html>hh</html>
# \num	引用分组num匹配到的字符串     r  声明原生字符，特别针对\等
import re
ret = re.match(r"<([a-z]+)>[a-z]{2}</\1>","<html>hh</html>")
if ret:
    print(ret.group())
else:
    print("匹配失败")


案例演示04：（(?P<name>)  分组起别名， (?P=name)  引用别名为name分组匹配到的字符串 ）


# 匹配标签：<html><h1>hh</h1></html>
# (?P<name>)	分组起别名
# (?P=name)	引用别名为name分组匹配到的字符串
import re
ret = re.match(r"<(?P<xiaohei>[a-z]{4})><(?P<xiaobai>\w{2})>[a-z]{2}</(?P=xiaobai)></(?P=xiaohei)>","<html><h1>hh</h1></html>")
if ret:
    print(ret.group())
else:
    print("匹配失败")

匹配开头

字符功能
^匹配字符串开头

现有王老师手机号：13051115888，要求使用正则表达式，判断该手机号是否合规？

思路分析：

  1. 手机号长度11位数字；

  2. 手机号以1开头；

  3. 手机号号段（3-8），例如：130、152、186，其中第二位为号段；

import re
ret = re.match("^1[3-8]\d{9}","13051115888")
if ret:
    print(ret.group())
else:
    print("匹配失败")

匹配结尾

字符功能
$匹配字符串以xxx结尾

现有赵老师邮箱号：zhaolaoshi123456@sina.com，要求使用正则表达式，判断该邮箱账号是否合规？

思路分析：

  1. 邮箱账号4-20位字符；

  2. 邮箱账号一般以.com结尾；

import re
ret = re.match("\w{4,20}@sina(.com)$","zhaolaoshi123456@sina.com")  # 正则表达式中的（），代表分组匹配
if ret:
    print(ret.group())
else:
    print("匹配失败")

2>re.match函数（re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。 ）

用法：re.match(pattern, string, flags=0)

函数参数说明：

参数描述
pattern匹配的正则表达式
string要匹配的字符串。
flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.match方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法描述
group(num=0)匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。

案例

# 导包
import re
# 使用re模块中的match(正则表达式，要匹配的字符串对象)方法进行匹配
ret = re.match("abc","abcdef")
if ret:  # 判断匹配结果是否存在
    print(ret.group())
else:
    print("匹配失败")

3>re.search函数（re.search 扫描整个字符串并返回第一个成功的匹配。 ）

用法：re.search(pattern, string, flags=0)

函数参数说明：

参数描述
pattern匹配的正则表达式
string要匹配的字符串。
flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.search方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法描述
group(num=0)匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()返回一个包含所有小组字符串的元组，从 1 到 所含的小组号

 案例1

import re

ret_01 = re.search('www', 'www.runoob.com')  # 在起始位置匹配
if ret_01:
    print(ret_01.group())   # 查看匹配到的对象
    print(ret_01.span())    # 查看匹配到的对象的位置区间（下标索引）
else:
    print("ret_01 匹配失败")

 案例2

import re

ret_02 = re.search('com', 'www.runoob.com')  # 不在起始位置匹配
if ret_02:
    print(ret_02.group())  # 查看匹配到的对象
    print(ret_02.span())  # 查看匹配到的对象的位置区间（下标索引）
else:
    print("ret_02 匹配失败")

 案例3

import re
# 字符串
line = "Cats are smarter than dogs";
# search匹配（分组）
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
# 如果匹配结果存在，则分组查看匹配数据
if searchObj:
   print "searchObj.group() : ", searchObj.group()
   print "searchObj.group(1) : ", searchObj.group(1)
   print "searchObj.group(2) : ", searchObj.group(2)
else:
   print "Nothing found!!"

4>re.findall函数（在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。 ）

注意： match 和 search 是匹配一次 findall 匹配所有。

用法：findall(string[, pos[, endpos]])

参数：

  • string : 待匹配的字符串。

  • pos : 可选参数，指定字符串的起始位置，默认为 0。

  • endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度。

查找字符串中的所有数字，返回包含所有匹配结果的列表：

案例

import re

pattern = re.compile(r'\d+')  # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)

print(result1)
print(result2)

结果：
['123', '456']
['88', '12']

5>re.split函数（根据匹配进⾏切割字符串，并返回⼀个列表。）

用法：re.split(pattern, string, maxsplit=0, flags=0)

参数描述
pattern匹配的正则表达式
string要匹配的字符串
maxsplit分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数

案例：

import re
ret = re.split(r":| ","dasdsa:asdadas:dasdadada")
print(ret)

6>re.sub函数(sub是substitute的所写，表示替换，将匹配到的数据进⾏替换。)

用法：re.sub(pattern, repl, string, count=0, flags=0)

#参数	描述
#pattern	必选，表示正则中的模式字符串
#repl	必选，就是replacement，要替换的字符串，也可为一个函数
#string	必选，被替换的那个string字符串
#count	可选参数，count 是要替换的最大次数，必须是非负整数。如果省略这个参数或设为 0，所有的匹配都会被替换
#flag	可选参数，标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等


import re
ret = re.sub(r"\d+", '998', "python = 997")
print(ret)

结果：
python=998

7>re.subn函数（行为与sub()相同，但是返回一个元组 (字符串, 替换次数)）

用法：re.subn(pattern, repl, string[, count])返回：(sub(repl, string[, count]), 替换次数)


import re
pattern = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print(re.subn(pattern, r'\2 \1', s))
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
print(re.subn(pattern, func, s))

8>re.compile函数（compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。）

prog = re.compile(pattern)
result = prog.match(string)

等价于

result = re.match(pattern, string)

案例

>>>import re
>>> pattern = re.compile(r'\d+')   
m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

在上面，当匹配成功时返回一个 Match 对象，其中：

group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
span([group]) 方法返回 (start(group), end(group))


 

车牌号正则表达式
mcy的博客
03-08 2739
车牌号正则表达式校验 @ApiModelProperty(value = "车牌号") @Pattern(regexp = "^[测京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}$", message = "车牌号格式不准确") private String plateNumb er; 严格 //验证plateNumber是否是车牌号 String pattern = "([测京津沪渝
Python RE 正则表达式模块
优快云
01-07 5661
默认匹配除\n之外的任意一个字符,若指定flag=DOTALL则匹配包括换行在内的字符.获取非重复的匹配列表,且每一个匹配均是字符串,空的匹配也会包含在结果中.先匹配查找结果,然后进行字串的替换,也就是替换匹配成功的指定位置字符串.从起始位置开始匹配,匹配成功返回一个对象,未匹配成功返回None.匹配加号前面的字符出现过1次,或任意多次,至少出现一次.^匹配指定字符开头的数据,$匹配指定字符结尾的数字.匹配前一个字符x,最少出现过n次,最多出现过m次.匹配前一个字符出现过1次或0次,允许出现0次.
Python 正则表达式模块 re
最新发布
二分掌柜的
03-12 2054
flyfish
Python-正则模块
msmso的博客
08-03 620
sailan1、正则模块是啥2、常用匹配模式（元字符）3、re模块提供方法介绍 1、正则模块是啥 正则就是用一些具有特殊含义的符号组合到一起（称为正则表达式）来描述字符或者字符串的方法。或者说：正则就是用来描述一类事物的规则。（在Python中）它内嵌在Python中，并通过 re 模块实现。 正则表达式：由一系列特殊字符拼接而成的表达式/规则，该表达式用于从一个大字符串中匹配出符合规则的子字符串。 2、常用匹配模式（元字符） \w 匹配字母数字及下划线 \W 匹配非字母数字下划线 # \w print(r
Python中正则表达式模块详解
weixin_44178366的博客
09-13 692
正则表达式 用来处理字符串，对字符串进行检索和替换，另外正则在python爬虫的应用也是相当广泛！ 特点 灵活性、逻辑性和功能性非常强 可以迅速地用极简单的方式达到字符串的复杂控制 正则语法 # 1、数字和字母都表示它本身, . 表示匹配除了换行以外的任意字符， \. 表示匹配 . # 2、很多字母前面添加 \ 会有特殊含义 - \n:换行 - \t：制表符 - \d: 匹配数字，等价[0-9] - \D:非数字，等价于[^0-9] - \w:表示数字、字母以及下划线，中
python之正则表达式模块
qq_44858403的博客
09-29 424
在python中，有四种通配符：*，？，+，.。 "*":表示该通配符前面的字符或子模式匹配0次或任意多次。 例如： import re pattern=re.compile('str*a') print(pattern.match('strrrra')) //结果为：<re.Match object; span=(0, 7), match='strrrra'> re.match函数 re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回non
python正则模块re.xmind
05-22
个人学习，整理python正则模块re的内容
python正则模块re.pdf
03-23
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern），可以用来检查一个串是否含有某种子串、将匹配的子串替换或者从某个串中取出符合某个条件的子串等。 构造正则表达式的方法和创建数学...
python正则-re的用法详解
12-31
所以现在呢，我们就一起来review一下python中正则模块re的用法吧。 今天是review，所以一些基础的概念就不做介绍了，先来看正则中的修饰符以及它的功能： 修饰符 •re.I 使匹配对大小写不敏感 •re.L 做本地化识别...
详解Python正则表达式re模块
12-26
正则大同小异，python 中的正则跟其他语言相比略有差异： 1、替换字符串时，替换的字符串可以是一个函数 2、split 函数可以指定分割次数，这会导致有个坑 3、前项界定的表达式必须定长 下面详细描述下 re 模块的使用...
python正则表达式re模块详解
01-20
快速入门 import re pattern = 'this' text = 'Does this text match the pattern?' match = re.search(pattern, text) s = match.start() e = match.end() print('Found {0}\nin {1}'....#python re_simple_matc
车牌号码正则校验
09-03
车牌号码校验，车牌号码校验
Python之re模块 - 正则表达式操作
weixin_34256074的博客
06-22 114
一、前言 字符串是编程时涉及到的最多的一种数据结构，对字符串进行操作的需求几乎无处不在。而正则表达式就是一种用来描述字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规则，凡是符合规则的字符串，我们就认为它“匹配”了，否则，该字符串就是不合法的。学习本章知识，你需要有了解正则表达式基础， 网上快速入门教程一抓一大把，这里就不再叙述了。二、r...
Python中的正则模块
qq_63892156的博客
09-07 240
正则表达式及其规则，search和match函数，re模块的常用函数，练习题（邮箱，手机，ip验证）
python之正则模块Re
LuckFariy的博客
11-11 485
正则表达式 正则表达式为高级的文本模式匹配，抽取，与/或文本形式的搜索和替换功能提供了基础。正则表达式是一些由字符和特殊符号组成的字符串，它们描述了模式的重复或者表述多个字符。 转义符\ 在正则表达式中，有很多有特殊意义的是元字符，比如\n和\s等，如果要在正则中匹配正常的&quot;\n&quot;而不是&quot;换行符&quot;就需要对&quot;&quot;进行转义，变成’\’。 在python中，无论是正则表达式，还是待匹配的内容，都是
python正则模块re
聊伟的博客
03-23 482
python正则模块re 一.re模块内置的函数方法 re.compile(pattern, flags=0) https://cdn.analyticsvidhya.com/wp-content/uploads/2019/06/seq2seq.gif) re.compile()方法可以把一个正则表达式编译成一个正则对象(PatternObj)，返回的正则对象是操作其他处理字符串方法的主体。 p...
车牌号正则表达式（含新能源车牌）
热门推荐
日常笔记/总结/系列知识梳理
08-26 2万+
普通车牌 格式： 汉字 + A-Z + 5位A-Z或0-9( 车牌号不存在字母I和O防止和1、0混淆) 正则表达式： /^[京津沪渝冀豫云辽黑湘皖鲁新苏浙赣鄂桂甘晋蒙陕吉闽贵粤青藏川宁琼使领A-Z]{1}[A-Z]{1}[A-Z0-9]{4}[A-Z0-9挂学警港澳]{1}$/ 新能源车牌（含普通车牌校验） 格式： 组成：省份简称（1位汉字）+发牌机关代号（1位字母）+序号（6位），总计8个字符，序号不能出现字母I和字母O * 通用规则：不区分大小写，第一位：省份简称（1位汉字），第二位：发牌机关代号（
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值