定义

在编写处理字符串的程序或网页时，经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。

简而言之：正则表达式就是记录文本规则的代码。

特点:

操作字符串

1.更快的方式操作字符串；(表单校验，数据匹配...)

2.普通字符串操作无法做到的，或者很难做的正则很容易搞定！！！

使用场景：

1.表单校验

2.api 里面也需要正则

3.[\u4e00-\u9fa5] 中文匹配 Unicode 编码中文匹配

正则表达式代码体验

# Python 解释器为我们提供了一个使用正则的模块，这个模块叫做re(regex)

import re

if __name__ == '__main__':

# 1.match()：匹配 -> object

# group()：通过匹配后，可以使用group()获取内容

obj = re.match(r"jovelin", "jovelin")

print(obj.group()) # -> jovelin

# 2.如果被匹配的内容多余正则；(只返回开头匹配的部分)

obj = re.match(r"jovelin", "jovelin.cn")

print(obj.group()) # -> jovelin

# 3.如果开头部分，没有匹配的内容； 那么返回None

obj = re.match(r"jovelin", "www.jovelin.cn")

print(obj) # -> None

print(None, type(None)) # -> None

常用的元字符

语法

说明

.

匹配除换行符(\n)以外的任意字符

[]

匹配 [ ] 中列举的字符

\w | \W

匹配字母或数字或下划线或汉字 | 反义

\s | \S

匹配任意的空白符 | 非空白

\d | \D

匹配数字 [0-9] | 非数字

\b | \B

匹配单词的开始或结束 | 反义

^

匹配字符串的开始

$

匹配字符串的结束

代码演示：

# . 匹配任意1个字符(除了 \n)

print(re.match(r'a.b', 'a\nb')) # -> None

# - 在 [] 里代表范围

print(re.match(r'a[a-c]c', 'abc').group()) # -> abc

# 在 [] 里面也想使用 - 那么需要 \ 转义

print(re.match(r'a[a\-c]c', 'a-c').group()) # -> a-c

# \b用法 与 ^ $ 相似，不过 \b 只匹配单词，\B 只匹配非单词

print(re.match(r"\b\w+\b", "0_9_a_z_A_Z汉字").group()) # -> 0_9_a_z_A_Z

print(re.match(r"\B\W+\B", "!@#$%^&*").group()) # -> !@#$%^&*

# ^ 匹配字符串开头

# $ 匹配字符串结尾

print(re.match(r'[\w\W]*$', '0_9_a_z_A_Z汉字!@#$%^&* \n\t').group()) # -> 0_9_a_z_A_Z汉字!@#$%^&*

# 注意: ^ 如果出现在 [] 中，代表的是取反! (想要使用 ^,可以转义 \)

print(re.match(r'^[\^]$', '^').group()) # -> ^

print(re.match(r'^[^^]$', '^')) # -> None

print(re.match(r'^[^47]$', '47')) # -> 47

常用的限定符(量词)

语法

说明

备注

*

重复零次或更多次

>=0

+

重复一次或更多次

>=1

?

重复零次或一次

0|1

{n}

重复n次

==n

{n,}

重复n次或更多次

>=n

{n,m}

重复n到m次

n<=X<=m

代码演示：

# * 匹配前一个字符出现0次或者无限次，即可有可无 (>=0)

print(re.match(r'a*b', 'b').group()) # -> b

# + 匹配前一个字符出现1次或者无限次，即至少有1次 (>=1)

print(re.match(r'a+b', 'b')) # -> None，必须要 1 个 a

# {n} 匹配前一个字符出现n次 == n (== n)

print(re.match(r'a{2}b', 'ab')) # -> None，必须要 2 个 a

# {n,m} 匹配前一个字符出现: n次<= 前一个字符 <=m次 (n<=X<=m)

print(re.match(r'a{2,5}b', 'ab')) # -> None，a 的次数必须是 2<=a<=5

案例：

1.校验手机号

import re

def isMobileNumber(tel):

"""

校验手机号是否正确

"""

if re.match(r"^[1-][34578-]\d{9}$", tel) is None:

return False

else:

return True

print(isMobileNumber("18819950820"))

2.校验邮箱

import re

"""

邮箱名称部分为： [a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}

域名部分： [a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+

连起来 ^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){1,2}$

"""

def isEmail(email):

"""校验邮箱是否正确"""

if re.match(r"^[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){0,4}@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+){1,2}$", email) is None:

return False

else:

return True

print(isEmail("jovelin@163.com"))

print(isEmail("jovelin.dev@gmail.com"))

print(isEmail("jovelin@163.com.cn"))

print(isEmail("jovelin.dev@gmail.com.cn"))

分组

用小括号来指定子表达式(也叫做分组)，然后你就可以指定这个子表达式的重复次数了，你也可以对子表达式进行其它一些操作。

语法

说明

(abc)

将括号中字符作为一个分组

|

匹配左右任意一个表达式

\num

引用分组num匹配到的字符串

(?P)

分组起别名

(?P=name)

引用别名为name分组匹配到的字符串

代码演示：

# (abc) 将括号中字符作为一个分组

print(re.match(r'(aaa)bbb(ccc)', 'aaabbbccc').group())

# 一个括号就是一个分组； group()：参数代表分组的编号；写 0 或者不写时，获取全部；

print(re.match(r'(aaa)bbb(ccc)', 'aaabbbccc').group())

print(re.match(r'(aaa)bbb(ccc)', 'aaabbbccc').group(0))

print(re.match(r'(aaa)bbb(ccc)', 'aaabbbccc').group(1))

# | 匹配左右任意一个表达式(和 [] 相似)

print(re.match(r'aaa(xxx|yyy|zzz)bbb', 'aaaxxxbbb').group())

# \num 引用分组 num 匹配到的字符串

# 前后保证一致，要使用到分组！

print(re.match(r'^\w+\1>$', 'nihao').group())

print(re.match(r'^\w+\2>\1>$', '

').group())

# (?P正则) 分组起别名

# (?P=name) 引用别名为name分组匹配到的字符串

print(re.match(r'^\w+)>\w+)>\w+(?P=re2)>(?P=re1)>$', '

').group())

正则高级 API(4个)

语法

说明

search()

搜索字符串中符合正则表达式的内容 -> 只返回第一个

findall()

搜索字符串中符合正则表达式的内容 -> 返回一个列表

sub()

替换字符串中符合正则的内容 -> 替换后的字符串

split()

按照指定正则切割字符串 -> 返回列表

代码演示：

import re

# 1.search()

print(re.search(r"\d+", "aaa111bbb222ccc333ddd").group())

# 2.findall()

print(re.findall(r"\d+", "aaa111bbb222ccc333ddd"))

# 3.sub()

print(re.sub(r"\d+", "***", "aaa111bbb222ccc333ddd"))

# sub(正则, 替换成***, 被操作的字符串, 替换次数)

print(re.sub(r"\d+", "***", "aaa111bbb222ccc333ddd", 2))

# 4.split()

print(re.split(r"\d+", "aaa111bbb222ccc333ddd eee"))

print(re.split(r"\d+|\s", "aaa111bbb222ccc333ddd eee"))

r 的作用

让程序把正则直接当做正则看；(不是从字符串开始解释)

# c:\aaa\bbb\ccc

print('c:\aaa\bbb\ccc')

print('c:\\aaa\\bbb\\ccc')

# 问题：在字符串中写 \ 时会转义，需要写成 \\

# 不写 r 时 \\\\ -> \\

print(re.match('c:\\\\aaa\\\\bbb\\\\ccc', 'c:\\aaa\\bbb\\ccc').group())

# 写 r 时 \\ -> \\

print(re.match(r'c:\\aaa\\bbb\\ccc', 'c:\\aaa\\bbb\\ccc').group())

贪婪/非贪婪

贪婪：(量词在自己的范围内，取最多...)

非贪婪：(量词在自己的范围内，取最少... )

非贪婪用法：量词后面加?

print('贪婪', re.match(r'a+', 'aaa').group()) # -> aaa

# 量词后面加?

print('非贪婪', re.match(r'a+?', 'aaa').group()) # -> a

print('贪婪', re.match(r'a{1,2}', 'aaa').group()) # -> aa

# 量词后面加?

print('非贪婪', re.match(r'a{1,3}?', 'aaa').group()) # -> a