Python正则表达式(re)

由 '\' 和一个字符组成的特殊序列在以下列出。 如果普通字符不是ASCII数位或者ASCII字母，那么正则样式将匹配第二个字符。比如，\$ 匹配字符 '$'.

主要函数

• re库是Python的标准库，不需要额外安装，主要用于字符串匹配
• 调用方式：import re
• re 库采用raw string类型表示正则表达式，rawstring是不包含对转义符再次转义的字符串。例如:r'[1‐9]\d{5}’
• re库也可以采用string类型表示正则表达式，但更繁琐，例如“'[1‐9]\\d{5}'”
• 当正则表达式包含转义符时，建议使用raw string

主要功能函数有：

re.seach()

re.search(pattern, string, flags=0)

参数说明：

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

扫描整个字符串并返回第一个成功的匹配。

>>> import re
>>> re.search('www', 'www.csdn.net')
object; span=(0, 3), match='www'>
>>> re.search('www', 'www.csdn.net').span()
(0, 3)
>>> re.search('csdn', 'www.csdn.net').span()
(4, 8)

从上面的例子可以看到，search()返回的是re.Match对象。

标志位

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

re.match()

re.match(pattern, string, flags=0)

参数说明：

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

re.match与re.search的区别

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

>>> re.match('www', 'www.csdn.net').span()
(0, 3)
>>> re.match('csdn', 'www.csdn.net').span()
Traceback (most recent call last):
  File "", line 1, in 
AttributeError: 'NoneType' object has no attribute 'span'

re.Match

由成功的 match 和 search 所返回的匹配对象。

主要方法和属性：

注意：group在Match中是一个非常重要的概念，它是通过小括号匹配出来的一段，而不是多个匹配的串。

>>> m=re.match(r'(\d{4})[/-](\d{2})[/-](\d{2})', '2023-09-17 && 2022-08-11')
>>> m
object; span=(0, 10), match='2023-09-17'>
>>> m.groups()
('2023', '09', '17')

上面的例子可以看到，string中有两个可以匹配上的子串，但match只匹配了第一个子串，而所谓的组就是这个匹配的串中，如果在正则表达式中有小括号，则表示的是小括号的匹配子串。如果正则表达式中没有小括号来分组，就不会有groups的内容。

>>> m=re.match(r'\d{4}[/-]\d{2}[/-]\d{2}', '2023-09-17 && 2022-08-11')
>>> m
object; span=(0, 10), match='2023-09-17'>
>>> m.groups()
()

groups表示的是匹配的字符串元组，group是指定取其中的一个，也可以通过[]按下标去取，如果取第0个，会把所有的都取出来。

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")
>>> m.group(0)
'Isaac Newton'
>>> m.group(1)
'Isaac'
>>> m[0]
'Isaac Newton'
>>> m[1]
'Isaac'
>>> m[2]
'Newton'
>>> m[3]
Traceback (most recent call last):
  File "", line 1, in 
IndexError: no such group
>>> m.groups()
('Isaac', 'Newton')
>>> m.lastindex
2
>>> m.lastgroup
>>> m.re
re.compile('(\\w+) (\\w+)')
>>> m.string
'Isaac Newton, physicist’
>>> m.span()
(0, 12)
>>> m.span(1)
(0, 5)
>>> m.start()
0
>>> m.end()
12
>>> m.end(1)
5
>>> m.groupdict()
{}
>>> m.pos
0
>>> m.endpos
23

re.fullmatch()

re.fullmatch(pattern, string, flags=0)

参数：

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

如果整个 string 与此正则表达式匹配，则返回相应的 Match。 如果字符串与模式不匹配则返回 None；请注意这与零长度匹配是不同的。

>>> re.fullmatch('o[gh]', 'dog')
>>> m = re.fullmatch('o[gh]', 'dog')
>>> m
>>> m = re.fullmatch('o[gh]', 'ogg')
>>> m
>>> m = re.fullmatch('o[gh]', 'oh')
>>> m
object; span=(0, 2), match='oh'>
 

re.findall()

re.findall(pattern, string, flags=0)

参数：

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

在字符串中找到正则表达式所匹配的所有子串（不是Match对象），并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

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

>>> m = re.findall(r'\d+', 'python3 c++2 Java18')
>>> m
['3', '2', '18']
>>> type(m)
<class 'list'>
 

>>> re.findall("(ab)*","aabz1144c")
['', 'ab', '', '', '', '', '', '', '']
>>> re.findall("(ab)+","aabz1144c")
['ab']

re.finditer()

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

re.finditer(pattern, string, flags=0)

参数说明：

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

import re
 
it = re.finditer(r'\d+', 'abc123efg5994&&&*987---')
print(type(it))
for m in it:
    print(m)
 
‘’’
<class 'callable_iterator'>
object; span=(3, 6), match='123'>
object; span=(9, 13), match='5994'>
object; span=(17, 20), match='987’>
’‘’

re.split()

按照能够匹配的子串将字符串分割后返回列表

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

参数说明：

• pattern：匹配的正则表达式
• string：要匹配的字符串。
• maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
• flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

>>> re.split(r'\W+', 'python.org,Python-c,PYTHON+JAVA.python*',0,re.I)
['python', 'org', 'Python', 'c', 'PYTHON', 'JAVA', 'python', '']

>>> re.split(r'\d', 'one1two2three3four4')
['one', 'two', 'three', 'four', '']
>>> re.split(r'\d', 'one1two20three3four4')
['one', 'two', '', 'three', 'four', '']
>>> re.split(r'\d+', 'one1two20three3four4')
['one', 'two', 'three', 'four', '']
>>> re.split(r'\b', 'one two cc three four')
['', 'one', ' ', 'two', ' ', 'cc', ' ', 'three', ' ', 'four', '']
>>> re.split(r' ', 'one two cc three four')
['one', 'two', 'cc', 'three', 'four']

re.sub()

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

参数说明：

• pattern : 正则表达式
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

import re
 
phone = "081-956-559 # 这是一个国外电话号码"
 
# 删除字符串中的 Python注释
num = re.sub(r'#.*$', '', phone)
print("电话号码是: ", num) #电话号码是:  081-956-559
 
# 删除非数字(-)的字符串
num = re.sub(r'\D', '', phone)
print("电话号码是 : ", num) #电话号码是 :  081956559

如果 repl 是一个函数，则它会针对每次 pattern 的非重叠出现的情况被调用。 该函数接受单个 Match 参数，并返回替换字符串。 例如:

import re
 
# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P\d+)', double, s))
 
‘’'
A46G8HFD1134
‘''

 re.subn()

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

re.subn(pattern, repl, string, count=0, flags=0)

re.compile()

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

参数说明：

• pattern : 一个字符串形式的正则表达式
• flags：标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

>>>import re
>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
>>> print m
None
>>> 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)

class re.Pattern

由 re.compile() 返回的已编译正则表达式对象。

主要的属性和方法有：

Pattern.search(string[, pos[, endpos]])

扫描整个 string 查找该正则表达式产生匹配的第一个位置，并返回相应的 Match。 如果字符串中没有与模式匹配的位置则返回 None；请注意这不同于在字符串的某个位置上找到零长度匹配。
可选的第二个参数 pos 给出了字符串中开始搜索的位置索引；默认为 0，它不完全等价于字符串切片； '^' 样式字符匹配字符串真正的开头，和换行符后面的第一个字符，但不会匹配索引规定开始的位置。
可选参数 endpos 限定了字符串搜索的结束；它假定字符串长度到 endpos ， 所以只有从 pos 到 endpos - 1 的字符会被匹配。如果 endpos 小于 pos，就不会有匹配产生；另外，如果 rx 是一个编译后的正则对象， rx.search(string, 0, 50) 等价于 rx.search(string[:50], 0)。

>>>pattern = re.compile("d")
>>>pattern.search("dog")     # Match at index 0
object; span=(0, 1), match='d'>
>>>pattern.search("dog", 1)  # No match; search doesn't include the "d"

Pattern.match(string[, pos[, endpos]])

如果字符串 开头 的零个或多个字符与此正则表达式匹配，则返回相应的 Match。 如果字符串与模式不匹配则返回 None；请注意这与零长度匹配是不同的。
可选参数 pos 和 endpos 与 search() 含义相同。

>>>pattern = re.compile("o")
>>>pattern.match("dog")      # No match as "o" is not at the start of "dog".
>>>pattern.match("dog", 1)   # Match as "o" is the 2nd character of "dog".
object; span=(1, 2), match='o'>

Pattern.fullmatch(string[, pos[, endpos]])

如果整个 string 与此正则表达式匹配，则返回相应的 Match。 如果字符串与模式不匹配则返回 None；请注意这与零长度匹配是不同的。
可选参数 pos 和 endpos 与 search() 含义相同。

>>>pattern = re.compile("o[gh]")
>>>pattern.fullmatch("dog")      # No match as "o" is not at the start of "dog".
>>>pattern.fullmatch("ogre")     # No match as not the full string matches.
>>>pattern.fullmatch("doggie", 1, 3)   # Matches within given limits.
object; span=(1, 3), match='og'>

Pattern.split(string, maxsplit=0)
等价于 split() 函数，使用了编译后的样式。

Pattern.findall(string[, pos[, endpos]])
类似函数 findall() ， 使用了编译后样式，但也可以接收可选参数 pos 和 endpos ，限制搜索范围，就像 search()。

Pattern.finditer(string[, pos[, endpos]])
类似函数 finditer() ， 使用了编译后样式，但也可以接收可选参数 pos 和 endpos ，限制搜索范围，就像 search()。

Pattern.sub(repl, string, count=0)
等价于 sub() 函数，使用了编译后的样式。

Pattern.subn(repl, string, count=0)
等价于 subn() 函数，使用了编译后的样式。

Pattern.flags
正则匹配标记。这是可以传递给 compile() 的参数，任何 (?…) 内联标记，隐性标记比如 UNICODE 的结合。

Pattern.groups
捕获到的模式串中组的数量。

Pattern.groupindex
映射由 (?P) 定义的命名符号组合和数字组合的字典。如果没有符号组，那字典就是空的。

Pattern.pattern
编译对象的原始样式字符串。

re.escape(pattern)

转义 pattern 中的特殊字符。如果你想对任意可能包含正则表达式元字符的文本字符串进行匹配，它就是有用的。

>>>print(re.escape('https://www.python.org'))
https://www\.python\.org
 
>>>legal_chars = string.ascii_lowercase + string.digits + "!#$%&'*+-.^_`|~:"
>>>print('[%s]+' % re.escape(legal_chars))
[abcdefghijklmnopqrstuvwxyz0123456789!\#\$%\&'\*\+\-\.\^_`\|\~:]+
 
>>>operators = ['+', '-', '*', '/', '**']
>>>print('|'.join(map(re.escape, sorted(operators, reverse=True))))
/|\-|\+|\*\*|\*

re.purge()

清除正则表达式的缓存。

常用正则表达式

邮箱

包含大小写字母，下划线，阿拉伯数字，点号，中划线

表达式：

[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)

>>> re.match(r'[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)', 'ssxw@qq.com')
object; span=(0, 11), match='ssxw@qq.com'>
>>> re.search(r'[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(?:\.[a-zA-Z0-9_-]+)', 'my email is ssxw@qq.com.')
object; span=(12, 23), match='ssxw@qq.com'>

身份证号码

xxxxxx yyyy MM dd 375 0 十八位

• 地区： [1-9]\d{5}
• 年的前两位： (18|19|([23]\d)) 1800-2399
• 年的后两位： \d{2}
• 月份： ((0[1-9])|(10|11|12))
• 天数： (([0-2][1-9])|10|20|30|31) 闰年不能禁止29+
• 三位顺序码： \d{3}
• 两位顺序码： \d{2}
• 校验码： [0-9Xx]

表达式：

[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]

>>> re.match(r'[1-9]\d{5}(18|19|([23]\d))\d{2}((0[1-9])|(10|11|12))(([0-2][1-9])|10|20|30|31)\d{3}[0-9Xx]', '450104197710101516')
object; span=(0, 18), match='450104197710101516'>

国内手机号码

手机号都为11位，且以1开头，第二位一般为3、5、6、7、8、9 ，剩下八位任意数字
例如：13987692110、15610098778

表达式：

1(3|4|5|6|7|8|9)\d{9}

>>> re.search(r'1(3|4|5|6|7|8|9)\d{9}', '我的手机号为：17910880306，希望常联系')
object; span=(7, 18), match='17910880306'>

国内固定电话

区号3\~4位，号码7\~8位

例如：0571-1234567、010-87654321

表达式：

\d{3}-\d{8}|\d{4}-\d{7}

>>> re.search(r'\d{3}-\d{8}|\d{4}-\d{7}', 'Our phone number is 010-68820403. Welcome to inquire')
object; span=(20, 32), match='010-68820403'>

域名

包含http:\\或https:\\

表达式：

(?:(?:http:\/\/)|(?:https:\/\/))?(?:[\w](?:[\w\-]{0,61}[\w])?\.)+[a-zA-Z]{2,6}(?:\/)?

>>> re.search(r'(?:(?:http:\/\/)|(?:https:\/\/))?(?:[\w](?:[\w\-]{0,61}[\w])?\.)+[a-zA-Z]{2,6}(?:\/)?', 'The official website address of Python is http://www.python.org')
object; span=(42, 63), match='http://www.python.org'>

IP地址

IP地址的长度为32位(共有2^32个IP地址)，分为4段，每段8位，用十进制数字表示
每段数字范围为0～255，段与段之间用句点隔开　

表达式：

((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))

>>> re.search(r'((?:(?:25[0-5]|2[0-4]\d|[01]?\d?\d)\.){3}(?:25[0-5]|2[0-4]\d|[01]?\d?\d))', 'IP192.168.1.4')
object; span=(2, 13), match='192.168.1.4'>

日期

常见日期格式：yyyyMMdd、yyyy-MM-dd、yyyy/MM/dd、yyyy.MM.dd

表达式：

\d{4}(?:-|\/|.)\d{1,2}(?:-|\/|.)\d{1,2}

>>> re.search(r'\d{4}(?:-|\/|.)\d{1,2}(?:-|\/|.)\d{1,2}', 'Yesterday2023-9-17, was a sad day')
object; span=(9, 18), match='2023-9-17'>

国内邮政编码

我国的邮政编码采用四级六位数编码结构
前两位数字表示省（直辖市、自治区）
第三位数字表示邮区；第四位数字表示县（市）
最后两位数字表示投递局（所）

表达式：

[1-9]\d{5}(?!\d)

>>> re.search(r'[1-9]\d{5}(?!\d)', 'BEIJING100073')
object; span=(7, 13), match='100073'>

中文字符

表达式：

[\u4e00-\u9fa5]

>>> re.search(r'[\u4e00-\u9fa5]+', 'name:李寻欢')
object; span=(5, 8), match='李寻欢'>
>>> 

数字

• 验证数字：^[0-9]*$
• 验证n位的数字：^\d{n}$
• 验证至少n位数字：^\d{n,}$
• 验证m-n位的数字：^\d{m,n}$
• 验证零和非零开头的数字：^(0|[1-9][0-9]*)$
• 验证有两位小数的正实数：^[0-9]+(.[0-9]{2})?$
• 验证有1-3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$
• 验证非零的正整数：^\+?[1-9][0-9]*$
• 验证非零的负整数：^\-[1-9][0-9]*$
• 验证非负整数（正整数 + 0） ^\d+$
• 验证非正整数（负整数 + 0） ^((-\d+)|(0+))$
• 整数：^-?\d+$
• 非负浮点数（正浮点数 + 0）：^\d+(\.\d+)?$
• 正浮点数 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$
• 非正浮点数（负浮点数 + 0） ^((-\d+(\.\d+)?)|(0+(\.0+)?))$
• 负浮点数 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$
• 浮点数 ^(-?\d+)(\.\d+)?$

字符串

• 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$
• 长度为3-20的所有字符：^.{3,20}$
• 由26个英文字母组成的字符串：^[A-Za-z]+$
• 由26个大写英文字母组成的字符串：^[A-Z]+$
• 由26个小写英文字母组成的字符串：^[a-z]+$
• 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$
• 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$
• 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$
• 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$
• 可以输入含有^%&',;=?$\”等字符：[^%&',;=?$\x22]+
• 禁止输入含有\~的字符：[^~\x22]+