社群 學習 工具庫 休閒
搜尋
繁体中文
首頁 > 後端開發 > Python教學 > 一文詳解python中的正規表示式（re模組）

一文詳解python中的正規表示式（re模組）

青灯夜游
發布： 2022-11-02 20:10:07
轉載
3530 人瀏覽過

正则表达式是处理字符串的强大工具，拥有独特的语法和独立的处理引擎。下面本篇文章就来给大家介绍一下python中的正则表达式（re模块），希望对大家有所帮助！

一文詳解python中的正規表示式（re模組）

在Python中需要通过正则表达式对字符串进行匹配的时候，可以使⽤⼀个python自带的模块，名字为re。

正则表达式的大致匹配过程是：
1.依次拿出表达式和文本中的字符比较，
2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。
3.如果表达式中有量词或边界，这个过程会稍微有一些不同。

r：Python 中字符串的前导 r 代表原始字符串标识符，该字符串中的特殊符号不会被转义，适用于正则表达式中繁杂的特殊符号表示。 因此 r"\n" 表示包含 '\' 和 'n' 两个字符的字符串，而 "\n" 则表示只包含一个换行符的字符串。

print("\\n") # 输出 \n
print(r"\n") #输出 \n
登入後複製

re模块的使用：import re

re.match函数

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

pattern 匹配的正则表达式
string 要匹配的字符串
flags

标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

  1. re.I 忽略大小写
  2. re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  3. re.M 多行模式
  4. re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
  5. re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  6. re.X 为了增加可读性，忽略空格和 # 后面的注释

尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。匹配成功re.match方法返回一个匹配的对象。

如果上⼀步匹配到数据的话，可以使⽤group⽅法来提取数据。以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

group()用来提出分组截获的字符串，（）用来分组，group() 同group（0）就是匹配正则表达式整体结果，group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。没有匹配成功的，re.search()返回None。

举例：

>>> import re
>>> result = re.match("itcast","itcast.cn")
>>> result.group()
'itcast'
登入後複製

从string头开始匹配pattern完全可以匹配，pattern匹配结束，同时匹配终止，后面的.cn不再匹配，返回匹配成功的信息。

匹配单个字符

字符 功能 位置
. 匹配任意1个字符（除了\n）
[ ] 匹配[ ]中列举的字符
\d 匹配数字，即0-9 可以写在字符集[...]中
\D 匹配⾮数字，即不是数字 可以写在字符集[...]中
\s 匹配空⽩，即空格，tab键 可以写在字符集[...]中
\S 匹配⾮空⽩字符 可以写在字符集[...]中
\w 匹配单词字符，即a-z、A-Z、0-9、_ 可以写在字符集[...]中
\W 匹配⾮单词字符 可以写在字符集[...]中
\w \w 匹配单词字符，即a-z、A-Z、0-9、_
\W 匹配⾮单词字符

[...]字符集，对应的位置可以是字符集中任意字符。字符集中的字符可以逐个列出，也可以给出范围，比如[abc]和[a-c]，第一个字符如果是^表示取反。所有特殊字符（比如"]""-""^"）在字符集中都失去原来的含义，如要使用可把"]""-"放在第一个字符，"^"放在非第一个字符。

举例：

import re
ret = re.match(".","M")
print(ret.group())
ret = re.match("t.o","too")
print(ret.group())
ret = re.match("t.o","two")
print(ret.group())
# 如果hello的⾸字符⼩写，那么正则表达式需要⼩写的h
ret = re.match("h","hello Python")
print(ret.group())
# 如果hello的⾸字符⼤写，那么正则表达式需要⼤写的H
ret = re.match("H","Hello Python")
print(ret.group())
# ⼤⼩写h都可以的情况
ret = re.match("[hH]","hello Python")
print(ret.group())
ret = re.match("[hH]","Hello Python")
print(ret.group())
ret = re.match("[hH]ello Python","Hello Python")
print(ret.group())
# 匹配0到9的多种写法
ret = re.match("[0123456789]Hello Python","7Hello Python")
print(ret.group())
ret = re.match("[0-9]Hello Python","7Hello Python")
print(ret.group())
# 匹配0到3和5-9
ret = re.match("[0-35-9]Hello Python","7Hello Python")
print(ret.group())
ret = re.match("[0-35-9]Hello Python","4Hello Python")
#print(ret.group())
ret = re.match("嫦娥\d号","嫦娥1号发射成功")
print(ret.group())
ret = re.match("嫦娥\d号","嫦娥2号发射成功")
print(ret.group())
登入後複製

结果：

M
 too
 two
 h
 H
 h
 H
 Hello Python
 7Hello Python
 7Hello Python
 7Hello Python
 嫦娥1号
 嫦娥2号
登入後複製

匹配多个字符

字符功能位置表达式实例完整匹配的字符串
*匹配前⼀个字符出现0次或者⽆限次，即可有可⽆用在字符或(...)之后abc*abccc
+匹配前⼀个字符出现1次或者⽆限次，即⾄少有1次用在字符或(...)之后abc+abccc
?匹配前⼀个字符出现1次或者0次，即要么有1次，要么没有用在字符或(...)之后abc?ab,abc
{m}匹配前⼀个字符出现m次用在字符或(...)之后ab{2}cabbc
{m,n}匹配前⼀个字符出现从m到n次，若省略m，则匹配0到n次，若省略n，则匹配m到无限次用在字符或(...)之后ab{1,2}cabc,abbc

举例：

import re
#：匹配出，⼀个字符串第⼀个字⺟为⼤写字符，后⾯都是⼩写字⺟并且这些⼩写字⺟可有可⽆
ret = re.match("[A-Z][a-z]*","M")
print(ret.group())
ret = re.match("[A-Z][a-z]*","MnnM")
print(ret.group())
ret = re.match("[A-Z][a-z]*","Aabcdef")
print(ret.group())
#匹配出，变量名是否有效
names = ["name1", "_name", "2_name", "__name__"]
for name in names:
    ret = re.match("[a-zA-Z_]+[\w]*",name)
    if ret:
        print("变量名 %s 符合要求" % ret.group())
    else:
        print("变量名 %s ⾮法" % name)
#匹配出，0到99之间的数字
ret = re.match("[1-9]?[0-9]","7")
print(ret.group())
ret = re.match("[1-9]?\d","33")
print(ret.group())
# 这个结果并不是想要的，利⽤$才能解决
ret = re.match("[1-9]?\d","09")
print(ret.group())
ret = re.match("[a-zA-Z0-9_]{6}","12a3g45678")
print(ret.group())
#匹配出，8到20位的密码，可以是⼤⼩写英⽂字⺟、数字、下划线
ret = re.match("[a-zA-Z0-9_]{8,20}","1ad12f23s34455ff66")
print(ret.group())
登入後複製

结果：

M
 Mnn
 Aabcdef
 变量名 name1 符合要求
 变量名 _name 符合要求
 变量名 2_name ⾮法
 变量名 __name__ 符合要求
 7
 33
 0
 12a3g4
 1ad12f23s34455ff66
登入後複製

匹配开头结尾

字符功能
^匹配字符串开头
$匹配字符串结尾

举例：匹配163.com的邮箱地址

import re
email_list = ["xiaoWang@163.com", "xiaoWang@163.comheihei", ".com.xiaowang@qq.com"]
for email in email_list:
    ret = re.match("[\w]{4,20}@163\.com$", email)
    if ret:
        print("%s 是符合规定的邮件地址,匹配后的结果是:%s" % (email, ret.group()))
    else:
        print("%s 不符合要求" % email)
登入後複製

结果：

xiaoWang@163.com 是符合规定的邮件地址,匹配后的结果是:xiaoWang@163.com
 xiaoWang@163.comheihei 不符合要求
 .com.xiaowang@qq.com 不符合要求
登入後複製

匹配分组

字符功能
|匹配左右任意⼀个表达式
(ab)将括号中字符作为⼀个分组
\num引⽤分组num匹配到的字符串
(?P)分组起别名，匹配到的子串组在外部是通过定义的 name 来获取的
(?P=name)引⽤别名为name分组匹配到的字符串

举例：|

#匹配出0-100之间的数字
import re
ret = re.match("[1-9]?\d$|100","8")
print(ret.group()) # 8
ret = re.match("[1-9]?\d$|100","78")
print(ret.group()) # 78
ret = re.match("[1-9]?\d$|100","08")
# print(ret.group()) # 不是0-100之间
ret = re.match("[1-9]?\d$|100","100")
print(ret.group()) # 100
登入後複製

举例：()

#需求：匹配出163、126、qq邮箱
ret = re.match("\w{4,20}@163\.com", "test@163.com")
print(ret.group()) # test@163.com
ret = re.match("\w{4,20}@(163|126|qq)\.com", "test@126.com")
print(ret.group()) # test@126.com
ret = re.match("\w{4,20}@(163|126|qq)\.com", "test@qq.com")
print(ret.group()) # test@qq.com
ret = re.match("\w{4,20}@(163|126|qq)\.com", "test@gmail.com")
if ret:
    print(ret.group())
else:
    print("不是163、126、qq邮箱") # 不是163、126、qq邮箱
#不是以4、7结尾的⼿机号码(11位)
tels = ["13100001234", "18912344321", "10086", "18800007777"]
for tel in tels:
    ret = re.match("1\d{9}[0-35-68-9]", tel)
    if ret:
        print(ret.group())
    else:
        print("%s 不是想要的⼿机号" % tel)
#提取区号和电话号码
ret = re.match("([^-]*)-(\d+)","010-12345678")
print(ret.group())
print(ret.group(1))
print(ret.group(2))
登入後複製

举例：\number

匹配数字代表的组合。每个括号是一个组合，组合从1开始编号。比如 (.+) \1 匹配 'the the' 或者 '55 55', 但不会匹配 'thethe' (注意组合后面的空格)。这个特殊序列只能用于匹配前面99个组合。如果 number 的第一个数位是0， 或者 number 是三个八进制数，它将不会被看作是一个组合，而是八进制的数字值。在 '[' 和 ']' 字符集合内，任何数字转义都被看作是字符。

例子1：匹配出 hh

\1,...,\9，匹配第n个分组的内容。如例子所示，指匹配第一个分组的内容。

import re
# 正确的理解思路：如果在第⼀对<>中是什么，按理说在后⾯的那对<>中就应该是什么。通过引⽤分组中匹配到的数据即可，但是要注意是元字符串，即类似 r""这种格式。
ret = re.match(r"<([a-zA-Z]*)>\w*</\1>", "<html>hh</html>")
# 因为2对<>中的数据不⼀致，所以没有匹配出来
test_label = ["<html>hh</html>","<html>hh</htmlbalabala>"]
for label in test_label:
    ret = re.match(r"<([a-zA-Z]*)>\w*</\1>", label)
    if ret:
        print("%s 这是一对正确的标签" % ret.group())
    else:
        print("%s 这是⼀对不正确的标签" % label)
登入後複製

结果：

<html>hh</html> 这是一对正确的标签
 <html>hh</htmlbalabala> 这是⼀对不正确的标签
登入後複製

例子2：匹配出

www.itcast.cn

import re
labels = ["<html><h1>www.itcast.cn</h1></html>", "<html><h1>www.itcast.cn</h2></html>"]
for label in labels:
    ret = re.match(r"<(\w*)><(\w*)>.*</\2></\1>", label)
    if ret:
        print("%s 是符合要求的标签" % ret.group())
    else:
        print("%s 不符合要求" % label)
登入後複製

结果：

<html><h1>www.itcast.cn</h1></html> 是符合要求的标签
 <html><h1>www.itcast.cn</h2></html> 不符合要求
登入後複製

举例：(?P) (?P=name)

一个用于标记，一个用于在同一个正则表达式中复用

import re
ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>","<html><h1>www.itcast.cn</h1></html>")
ret.group()
ret = re.match(r"<(?P<name1>\w*)><(?P<name2>\w*)>.*</(?P=name2)></(?P=name1)>","<html><h1>www.itcast.cn</h2></html>")
#ret.group()
登入後複製

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&#39;\d+&#39;)   
m = pattern.match(&#39;one12twothree34four&#39;, 3, 10) # 从&#39;1&#39;的位置开始匹配，正好匹配
>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
&#39;12&#39;
>>> 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))

re.search函数

re.search 扫描整个字符串并返回第一个成功的匹配，如果没有匹配，就返回一个 None。

re.match与re.search的区别：re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配

举例：

import re
ret = re.search(r"\d+", "阅读次数为9999")
print(ret.group())
登入後複製

结果：

9999
登入後複製

re.findall函数

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。注意： match 和 search 是匹配一次 findall 匹配所有。

举例：

import re
ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)
登入後複製

结果：

[&#39;9999&#39;, &#39;7890&#39;, &#39;12345&#39;]
登入後複製

re.finditer函数

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

import re
it = re.finditer(r"\d+", "12a32bc43jf3")
for match in it:
    print(match.group())
登入後複製

结果：

12
 32
 43
 3
登入後複製

re.sub函数

sub是substitute的所写，表示替换，将匹配到的数据进⾏替换。

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

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

举例：将匹配到的阅读次数加1

方法一：

import re
ret = re.sub(r"\d+", &#39;998&#39;, "python = 997")
print(ret)
登入後複製

结果：

python = 998
登入後複製

方法二：

import re
def add(temp):
    #int（）参数必须是字符串，类似字节的对象或数字，而不是“re.Match”
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)
ret = re.sub(r"\d+", add, "python = 997")
print(ret)
ret = re.sub(r"\d+", add, "python = 99")
print(ret)
登入後複製

结果;

python = 998
 python = 100
登入後複製

re.subn函数

行为与sub()相同，但是返回一个元组 (字符串, 替换次数)。

re.subn(pattern, repl, string[, count])

返回：(sub(repl, string[, count]), 替换次数)

import re
pattern = re.compile(r&#39;(\w+) (\w+)&#39;)
s = &#39;i say, hello world!&#39;
print(re.subn(pattern, r&#39;\2 \1&#39;, s))
def func(m):
    return m.group(1).title() + &#39; &#39; + m.group(2).title()
print(re.subn(pattern, func, s))
### output ###
# (&#39;say i, world hello!&#39;, 2)
# (&#39;I Say, Hello World!&#39;, 2)
登入後複製

re.split函数

根据匹配进⾏切割字符串，并返回⼀个列表。

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

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

举例：

import re
ret = re.split(r":| ","info:xiaoZhang 33 shandong")
print(ret)
登入後複製

结果：

[&#39;info&#39;, &#39;xiaoZhang&#39;, &#39;33&#39;, &#39;shandong&#39;]
登入後複製

python贪婪和⾮贪婪

Python⾥数量词默认是贪婪的（在少数语⾔⾥也可能是默认⾮贪婪），总是尝试匹配尽可能多的字符；⾮贪婪则相反，总是尝试匹配尽可能少的字符。

例如：正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量词”ab*?”，将找到”a”。

注：我们一般使用非贪婪模式来提取。

在"*","?","+","{m,n}"后⾯加上？，使贪婪变成⾮贪婪。

举例1：

import re
s="This is a number 234-235-22-423"
#正则表达式模式中使⽤到通配字，那它在从左到右的顺序求值时，会尽量“抓取”满⾜匹配最⻓字符串，在我们上⾯的例⼦⾥⾯，“.+”会从字符串的启始处抓取满⾜模式的最⻓字符，其中包括我们想得到的第⼀个整型字段的中的⼤部分，“\d+”只需⼀位字符就可以匹配，所以它匹配了数字“4”，⽽“.+”则匹配了从字符串起始到这个第⼀位数字4之前的所有字符
r=re.match(".+(\d+-\d+-\d+-\d+)",s)
print(r.group(1))
#⾮贪婪操作符“？”，这个操作符可以⽤在"*","+","?"的后⾯，要求正则匹配的越少越好
r=re.match(".+?(\d+-\d+-\d+-\d+)",s)
print(r.group(1))
登入後複製

结果：

4-235-22-423
 234-235-22-423
登入後複製

举例2：

>>> re.match(r"aa(\d+)","aa2343ddd").group(1)
&#39;2343&#39;
>>> re.match(r"aa(\d+?)","aa2343ddd").group(1)
&#39;2&#39;
>>> re.match(r"aa(\d+)ddd","aa2343ddd").group(1)
&#39;2343&#39;
>>> re.match(r"aa(\d+?)ddd","aa2343ddd").group(1)
&#39;2343&#39;
登入後複製

举例3：提取图片地址

import re
test_str="<img src=https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973.jpg>"
ret = re.search(r"https://.*?.jpg", test_str)
print(ret.group())
登入後複製

结果：https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973.jpg

r的作⽤

与大多数编程语言相同，正则表达式里使用”\”作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\\\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，Python中字符串前⾯加上 r 表示原⽣字符串。

import re
mm = "c:\\a\\b\\c"
print(mm)#c:\a\b\c
ret = re.match("c:\\\\",mm).group()
print(ret)#c:\
ret = re.match("c:\\\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\a",mm).group()
print(ret)#AttributeError: &#39;NoneType&#39; object has no attribute &#39;group&#39;
登入後複製

【相关推荐：Python3视频教程 】

以上是一文詳解python中的正規表示式（re模組）的詳細內容。更多資訊請關注PHP中文網其他相關文章！

相關標籤：
python
來源：csdn.net
上一篇：Python學習之列表和元組的使用詳解 下一篇：pytorch模型保存與載入中的一些問題實戰記錄
本網站聲明
本文內容由網友自願投稿，版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容，請聯絡admin@php.cn
作者最新文章
最新問題
Python/MySQL無法正確持久化整數數據 在這裡不需要任何程式碼。我想要保存一個非常長的數字，因為我正在製作一個遊戲，需要保存分數。但是我測試了一下，將分數設定為25000000000，但在mysql中儲存為2147483...
來自於 2024-04-04 19:09:44
0
1
367
使用selenium想要點擊並在類別中定義URL 今天我需要另一個提示。我正在嘗試建立Python/Selenium程式碼，想法是點擊www.thewebsiteIwantoclickon下面是我正在處理的HTML範例。類別ent...
來自於 2024-04-04 14:14:44
0
1
3492
Selenium + Python - 透過execute_script檢查映像 我需要使用python中的selenium驗證圖片是否顯示在頁面上。例如，讓我們檢查https://openweathermap.org/頁面左上角的標誌。我使用execute_s...
來自於 2024-04-03 09:32:15
0
1
375
保留前X行，刪除表格行的方法 我在MySQLincident_archive中有一個包含數百萬筆記錄的大表，我想按created列對行進行排序，並保留前X行並刪除其餘行，最有效的方法是什麼。到目前為止，我用Py...
來自於 2024-04-01 18:32:54
0
1
347
如何使用 BeautifulSoup 抓取特定的Google天氣文字？ 如何使用BeautifulSoup在Python中找到課程文本“美國紐約市”？嘗試複製影片進行練習，但不再有效。嘗試在官方文件中找到一些內容，但沒有成功。或者我的get_html_...
來自於 2024-04-01 14:06:14
0
1
308
相關專題
更多>
熱門推薦
熱門教學
更多>
相關教學
熱門推薦
最新課程
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板