python 正则表达式 re模块之match的基本使用匹配字符数量表示原始字符串正则表达式之表示边界正则表达式之匹配分组正则表达式之高级用法正则表达式之贪婪模式和非贪婪模式

最新推荐文章于 2024-06-22 09:36:52 发布

嘎嘎_哈

最新推荐文章于 2024-06-22 09:36:52 发布

阅读量4k

点赞数 7

分类专栏： python 1 文章标签： python 正则表达式re模块只match的基本用法正则表达式之匹配字符数量表示原始字符串正则表达式之表示边界匹配分组正则表达式之高级用法正则表达式之贪婪模式和非贪婪模式

本文链接：https://blog.csdn.net/weixin_45222544/article/details/94620211

版权

python 1 专栏收录该内容

48 篇文章 3 订阅

订阅专栏

1，re模块之match的基本使用

1，可使用re模块，通过正则表达式对字符串进行匹配

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

3，函数语法为：re.match(pattern, string, flags=0)

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

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

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

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

import re
pattern = "hello"
str = "Helloworld"
result = re.match(pattern, str)
print(result)

运行结果为：

None

之所以返回结果为None，是因为严格区分大小写
修改代码之后的验证如下：

import re
pattern = "Hello"
str = "Helloworld Hello"
v = re.match(pattern, str)
print(v)
print(type(v))
print(dir(v))
print(v.group())    # group查找匹配的内容
print(v.span())     # span匹配的内容的索引范围
print(v.start())
print(v.end())
print(v.string)

运行结果为：

<_sre.SRE_Match object; span=(0, 5), match='Hello'>
<class '_sre.SRE_Match'>
['__class__', '__copy__', '__deepcopy__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'end', 'endpos', 'expand', 'group', 'groupdict', 'groups', 'lastgroup', 'lastindex', 'pos', 're', 'regs', 'span', 'start', 'string']
Hello
(0, 5)
0
5
Helloworld Hello

当首个单词不匹配时，验证如下：

import re
pattern = "Hello"
str = "helloworld Hello"
v = re.match(pattern, str)
print(v)

运行结果为：

None #原因是re.match函数只匹配字符串的起始位置，如果匹配不成功，就直接返回None

如果想匹配字符串的其他位置，需要用re.search()函数 验证如下：

import re
pattern = "Hello"
str = "helloworld Hello"
v = re.search(pattern, str)
print(v)
print(v.group())
print(v.span())

运行结果为：

<_sre.SRE_Match object; span=(11, 16), match='Hello'>
Hello
(11, 16)

2，正则表达式之匹配字符

**
在这里插入图片描述
. 点的演示如下：

import re
pattern = "."
str1 = "h"
str2 = "H"
str3 = "-"
str4 = "6"
str5 = "\n"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
v4 = re.match(pattern, str4)
v5 = re.match(pattern, str5)
print(v1)
print(v2)
print(v3)
print(v4)
print(v5)

运行结果为：

<_sre.SRE_Match object; span=(0, 1), match='h'>
<_sre.SRE_Match object; span=(0, 1), match='H'>
<_sre.SRE_Match object; span=(0, 1), match='-'>
<_sre.SRE_Match object; span=(0, 1), match='6'>
None

\d的演示如下：

import re
pattern = "\d"
str1 = "9"
str2 = "a"
str3 = "_"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
print(v1)
print(v2)
print(v3)

运行结果为：

<_sre.SRE_Match object; span=(0, 1), match='9'>
None
None

\D 的演示如下：

import re
pattern = "\D"
str1 = "9"
str2 = "a"
str3 = "_"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
print(v1)
print(v2)
print(v3)

运行结果为：

None
<_sre.SRE_Match object; span=(0, 1), match='a'>
<_sre.SRE_Match object; span=(0, 1), match='_'>

\s 匹配\r \t \n 的演示如下：

import re
pattern = "\s"
str1 = " "
str2 = "\t"
str3 = "\n"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
print(v1)
print(v2)
print(v3)

运行结果为：

<_sre.SRE_Match object; span=(0, 1), match=' '>
<_sre.SRE_Match object; span=(0, 1), match='\t'>
<_sre.SRE_Match object; span=(0, 1), match='\n'>

\S 的演示如下：

import re
pattern = "\S"
str1 = " "
str2 = "\t"
str3 = "\n"
str4 = "a"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
v4 = re.match(pattern, str4)
print(v1)
print(v2)
print(v3)
print(v4)

运行结果为：

None
None
None
<_sre.SRE_Match object; span=(0, 1), match='a'>

\w 的演示如下：

import re
pattern = "\w"
str1 = " "
str2 = "\t"
str3 = "9"
str4 = "$"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
v4 = re.match(pattern, str4)
print(v1)
print(v2)
print(v3)
print(v4)

运行结果为：

None
None
<_sre.SRE_Match object; span=(0, 1), match='9'>
None

\W 的演示如下：

import re
pattern = "\W"
str1 = " "
str2 = "\t"
str3 = "9"
str4 = "$"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
v4 = re.match(pattern, str4)
print(v1)
print(v2)
print(v3)
print(v4)

运行结果为：

<_sre.SRE_Match object; span=(0, 1), match=' '>
<_sre.SRE_Match object; span=(0, 1), match='\t'>
None
<_sre.SRE_Match object; span=(0, 1), match='$'>

[ ] 的演示如下：

import re
pattern = "[1,3,5,7,9]"
str1 = " "
str2 = "1"
str3 = "9"
str4 = "$"
v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
v4 = re.match(pattern, str4)
print(v1)
print(v2)
print(v3)
print(v4)

运行结果为：

None
<_sre.SRE_Match object; span=(0, 1), match='1'>
<_sre.SRE_Match object; span=(0, 1), match='9'>
None

需求：匹配手机号，11位数

import re
pattern = "1[35789]\d\d\d\d\d\d\d\d\d"
str1 = "19812341234"
v1 = re.match(pattern, str1)

print(v1)

运行结果为：

<_sre.SRE_Match object; span=(0, 11), match='19812341234'>

3，正则表达式之表示数量

**
在这里插入图片描述
*的演示如下

import re
pattern = "\d*"
s1 = "123abc"
s2 = "abc"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 0), match=''>

+ 的演示如下：

import re
pattern = "\d+"
s1 = "123abc"
s2 = "abc"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 3), match='123'>
None

？的使用演示如下：

import re
pattern = "\d?"
s1 = "123abc"
s2 = "abc"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 1), match='1'>
<_sre.SRE_Match object; span=(0, 0), match=''>

{m}的使用演示如下：

import re
pattern = "\d{3}"
s1 = "123abc"
s2 = "abc"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 3), match='123'>
None

{m,n}的使用演示如下：

import re
pattern = "\d{2,4}"  # 代表匹配2个或者3个或者4个
s1 = "123abc"
s2 = "1abc"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 3), match='123'>
None

{m,}的使用演示如下：

import re
pattern = "\d{2,}"  # 代表代表至少匹配2个数字
s1 = "123abc"
s2 = "abc"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 3), match='123'>
None

需求：匹配出一个字符串首字母为大写字母，后边都是小写字符，这些小写字母可有可无

import re
pattern = "[A-Z][a-z] * " 
s1 = "Hello"
s2 = "HEllo"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 5), match='Hello'>
<_sre.SRE_Match object; span=(0, 1), match='H'>

需求：匹配出有效的变量名

import re
pattern = "[A-Za-z_][A-Za-z0-9_]*"  # 等价于"[A-Za-z_]\w*"
s1 = "Hb2"
s2 = "2hb"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 3), match='Hb2'>
None

需求：匹配1-99之间的数字

import re
pattern = "[1-9][0-9]?"
s1 = "33"
s2 = "123"
s3 = "0"
v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)
v3 = re.match(pattern, s3)
print(v1)
print(v2)
print(v3)

运行结果为：

<_sre.SRE_Match object; span=(0, 2), match='33'>
<_sre.SRE_Match object; span=(0, 2), match='12'>
None

需求：匹配出一个随机密码8-20位以内（大小写字母数字下划线）

import re
pattern = "\w{8,20}"
s1 = "33agcdefg"
s2 = "123agc"

v1 = re.match(pattern, s1)
v2 = re.match(pattern, s2)

print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 9), match='33agcdefg'>
None

4，正则表达式之原始字符串

**
概述：python中字符串前边加上r表示原生字符串

示例代码如下：

import re
v1 = r"\nabc"
v2 = "\nabc"
v3 = "\\nabc"

print(v1)
print(v2)
print(v3)

运行结果为：

\nabc

abc   # 打印此结果之前出现了换行 因为字符串前面没有加r ，\n就代表换行符
\nabc

示例2如下：

import re
pattern = r"\\\\n\d{3,}"
str = "\\\\n123"
result = re.match(pattern, str)
print(result)

运行结果为：

<_sre.SRE_Match object; span=(0, 6), match='\\\\n123'>

5，正则表达式之表示边界

**
在这里插入图片描述
需求：匹配QQ邮箱 5-10位，@qq.com

import re
pattern = r"[1-9]\d{4,9}@qq.com"
str = "1297685567@qq.com.cn"   
result = re.match(pattern, str)
print(result)

运行结果为：

<_sre.SRE_Match object; span=(0, 17), match='1297685567@qq.com'>

注意：以上代码是错误的 str字符串不是QQ邮箱的正确格式
修改后的代码如下：

import re
pattern = r"[1-9]\d{4,9}@qq.com$"
str = "1297685567@qq.com.cn"
result = re.match(pattern, str)
print(result)

运行结果为：

None

需求：使用\b匹配单词边界

import re
pattern1 = r".*\ber"        # 匹配左边界
pattern2 = r".*er\b"        # 匹配右边界
str1 = "123 eroa"
str2 = "123,oaer"
v1 = re.match(pattern1, str1)
v2 = re.match(pattern2, str2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 6), match='123 er'>
<_sre.SRE_Match object; span=(0, 8), match='123,oaer'>

需求：使用\B匹配非单词边界

import re
pattern1 = r".*\Ber"        # 匹配非单词左边界
pattern2 = r".*er\B"        # 匹配非单词右边界
str1 = "123 Peroa"
str2 = "123,oaer"
v1 = re.match(pattern1, str1)
v2 = re.match(pattern2, str2)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 7), match='123 Per'>
None

6，正则表达式之匹配分组

**
在这里插入图片描述
| 的使用需求：匹配0-100之间所有的数字

import re
pattern = r"[0-9]?\d$|100$"
str1 = "1000"
str2 = "0"
str3 = "99"
str4 = "100"

v1 = re.match(pattern, str1)
v2 = re.match(pattern, str2)
v3 = re.match(pattern, str3)
v4 = re.match(pattern, str4)

print(v1)
print(v2)
print(v3)
print(v4)

运行结果为：

None
<_sre.SRE_Match object; span=(0, 1), match='0'>
<_sre.SRE_Match object; span=(0, 2), match='99'>
<_sre.SRE_Match object; span=(0, 3), match='100'>

需求：匹配座机号码 区号-电话号{5,8} 演示(ab)的使用

import re
pattern = r"(\d{3,4})-([1-9]\d{4,7})$"
str1 = "0178-55559999"

v1 = re.match(pattern, str1)
print(v1)
print(v1.group())
print(v1.group(1))
print(v1.group(2))
print(v1.groups())
print(v1.groups()[0])
print(v1.groups()[1])

运行结果为：

<_sre.SRE_Match object; span=(0, 13), match='0178-55559999'>
0178-55559999
0178
55559999
('0178', '55559999')
0178
55559999

\num 的演示如下：需求匹配出网页标签内的数据

import re
pattern = r"<(.+)><(.+)>.+</\2></\1>"  # \2对应第二个括号中的.+  \1对应第一个括号中的.+
str1 = "<html><title>我是魔鬼标题</title></html>"

v1 = re.match(pattern, str1)
print(v1)

运行结果为

<_sre.SRE_Match object; span=(0, 34), match='<html><title>我是魔鬼标题</title></html>'>

(?P<>)的用法演示如下****需求：匹配分组别名以及引用别名 注意P是大写的

import re
# pattern = r"<(.+)><(.+)>.+</\2></\1>" 改版后的标题如下
pattern = r"<(?P<标签1>.+)><(?P<标签2>.+)>.+</(?P=标签2)></(?P=标签1)>"  # 标签1标签2是随便起的组名

str1 = "<html><title>我是魔鬼标题</title></html>"

v1 = re.match(pattern, str1)
print(v1)

运行结果为：

<_sre.SRE_Match object; span=(0, 34), match='<html><title>我是魔鬼标题</title></html>'>

7，正则表达式之高级用法

**
1，search：扫描字符串，查找正则表达式模式产生匹配的第一个位置，并返回相应的匹配对象。如果字符串中没有与模式匹配的位置，则返回None

2，findall:从左到右扫描字符串，并按照找的顺序返回匹配。如果模式中有一个或多个组，返回组列表

import re
pattern = r"\d+"
str1 = "python阅读次数为999次,java阅读次数为888次,c阅读次数为666次"

# search从前往后找，找到一个之后就直接返回
v1 = re.search(pattern, str1)

# findall 返回与表达式相匹配的所有内容 ，返回的是一个列表
v2 = re.findall(pattern, str1)

print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(11, 14), match='999'>
['999', '888', '666']

3，sub：返回通过替换rep|替换字符串中最左边不重叠的模式出现而得到的字符串，如果没有找到模式，则返回字符串不变

用法1：直接替换演示如下：

import re
pattern = r"\d+"
str1 = "python阅读次数为999次,java阅读次数为888次,c阅读次数为666次"

# count值设为0,或者不写 默认替换所有
v1 = re.sub(pattern,"100", str1, count=0)

# 注意返回的是一个替换之后的新的字符串对象
print(v1)

运行结果为：

python阅读次数为100次,java阅读次数为100次,c阅读次数为100次

用法2：使用函数（可以运算）替换（常用）

import re
pattern = r"\d+"
str1 = "python阅读次数为100次,java阅读次数为1000次,c阅读次数为10000次"

def replace(result):
    # print(result)
    # print(type(result.group()))
    return str(int(result.group())+1)

v = re.sub(pattern, replace, str1)
print(v)

运行结果为：

python阅读次数为101次,java阅读次数为1001次,c阅读次数为10001次

4，split：通过指定模式拆分字符串（按指定的格式拆分字符串）

import re
pattern = r"\s|:|,"
str1 = "He say:learn,python"

v = re.split(pattern, str1)

# 注意返回的结果是一个列表
print(v)

运行结果为：

['He', 'say', 'learn', 'python']

8，正则表达式之贪婪模式和非贪婪模式

**
贪婪模式：python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符

非贪婪模式：与贪婪相反,总是尝试匹配尽可能少的字符,可使用"*" “?” “+” "{m, n}"后面加上?,使贪婪变非贪婪

import re

# 贪婪模式
pattern1 = r"abc\d+"

# 非贪婪模式
pattern2 = r"abc\d+?"

str = "abc123"

v1 = re.match(pattern1, str)
v2 = re.match(pattern2, str)
print(v1)
print(v2)

运行结果为：

<_sre.SRE_Match object; span=(0, 6), match='abc123'>
<_sre.SRE_Match object; span=(0, 4), match='abc1'>

示例二如下：

import re

# 贪婪模式
pattern1 = r"(.+)(\d+)-(\d+)-(\d+)"

# 非贪婪模式
pattern2 = r"(.+?)(\d+)-(\d+)-(\d+?)"

str = "this is my tel:186-1234-1234"

v1 = re.match(pattern1, str)
v2 = re.match(pattern2, str)
print(v1)
print(v1.group(1))
print(v1.group(2))
print(v1.group(3))
print(v1.group(4))
print("--" * 35)
print(v2)
print(v2.group(1))
print(v2.group(2))
print(v2.group(3))
print(v2.group(4))

运行结果为：

<_sre.SRE_Match object; span=(0, 28), match='this is my tel:186-1234-1234'>
this is my tel:18
6
1234
1234
----------------------------------------------------------------------
<_sre.SRE_Match object; span=(0, 25), match='this is my tel:186-1234-1'>
this is my tel:
186
1234
1

以上

**
如有错误欢迎指正
欢迎粘贴复制评论转发点赞
**

轻轻一点好运连连

嘎嘎_哈

关注

7
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
python 正则表达式 re模块之match的基本使用匹配字符数量表示原始字符串正则表达式之表示边界正则表达式之匹配分组正则表达式之高级用法正则表达式之贪婪模式和非贪婪模式

**1，re模块之match的基本使用**1，可使用re模块，通过正则表达式对字符串进行匹配2，re.match函数尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。3，函数语法为：re.match(pattern, string, flags=0)4，参数说明pattern 匹配的正则表达式string 要匹配的字符串。fla...
复制链接

扫一扫