Python --正则表达式

qq_25500415

已于 2023-09-12 15:51:20 修改

阅读量70

点赞数

分类专栏： python 文章标签： python

于 2023-08-09 12:12:05 首次发布

本文链接：https://blog.csdn.net/qq_25500415/article/details/132164416

版权

python 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

1-6，指定范围和否定(-, ^, [])

2-4, 多次匹配（*， +， ?， {}）

3-7， re.sub(), re.subn()

1，特殊符号

1-1，管道符(|)

通过管道符(|)， 分割多个正则表达式

# 表示两个正则表达式，一个为at, 另外一个为home
at|home

1-2，点号(.)

通过点号(.)匹配任意单个字符，换行符除外

# 其中的"."可以匹配任意单个字符，换行符除外
f.o

1-3，字符串边界匹配

1-3-1，起始匹配(^)

通过\A或者^，可匹配字符串开头

# 匹配以From开始的字符串
^From
\AFrom

1-3-2，结尾匹配($)

通过\Z或者$，可匹配字符串结尾

# 匹配以/bin/tcsh结束的字符串
/bin/tcsh$
/bin/tcsh\Z

1-3-3，匹配^, $

通过\^，可匹配字符^，通过\$，可匹配$

# 匹配^的字符串
\^

# 匹配$的字符串
\$

1-4，单词边界匹配

1-4-1，单词边界匹配(\b)

通过\b，单词边界匹配

# 匹配以the开始的字符串
\bthe

1-4-2，单词中匹配(\B)

通过\B，单词中的子串匹配

# 匹配包含the的字符串， 单不能以the开头
\Bthe

1-5，中括号([])

通过[字符1字符2字符3...]， 匹配指定字符集中的任意一个

# 表示三个正则表达式：a,b,c
# 表示匹配a,b,c中任意一个字符
[abc]

1-6，指定范围和否定(-, ^, [])

[a~z]：表示匹配a~z之间的任意一个字符
[^a~z]：表示匹配除a~z以外的任意字符

2，特殊字符

2-1，数字匹配

2-1-1，数字匹配(\d)

通过\d， 匹配数字0~9中的任意数字

# 表示匹配数据0~9， 等价[0-9]
\d

2-1-2，非数字匹配(\D)

通过\D， 匹配除0~9以外的非数字字符

# 表示匹配除0~9以外的字符
\D

2-2，字符数字匹配

2-2-1，字符数字匹配(\w)

通过\w， 匹配0~9，a~z, A~Z, _

2-2-2，非字符数字匹配(\w)

通过\W， 匹配0~9，a~z, A~Z, _以外的字符

2-3，空格匹配(\s, \S)

2-3-1，空格匹配

通过\s， 匹配空格

2-3-2，非空格匹配

通过\S，匹配非空格

2-4, 多次匹配（*， +， ?， {}）

2-4-1，问号(?)

2-4-1-1，匹配0次或1次

单独使用时，表示?前面的字符只能出现0次或1次

# 这里的?，表示t可以出现0次或1次
bat?

2-4-1-2，非贪婪匹配

紧跟在表示元字符后面，表示非贪婪匹配

2-4-2，星号(*)

表示星号前面的正则表达式可以出现0次或多次

# 表示\w可以出现0次或多次
\w*

2-4-3，加号(+)

表示加号前的正则表达式可以出现1次或多次

# 表示\w可出现1次或多次
\w+

2-4-4，大括号({})

指定大括号前面的表达式出现的次数

# 表示\d出现三次
\d{3}

# 表示\d出现3到5次
\d{3, 5}

2-5，括号()

通过括号可以实现对正则表达式进行分组，匹配子组

3， re模块

3-1， re.compile()

通过re.compile(正则表达式)， 返回一个regex对象，可以提供性能

3-2， group()

通过匹配对象.group()， 返回匹配对象或者根据要求返回子组

In [4]: str1 = 'aatheraa'
In [8]: m = re.search(r'(the)', str1)

# 通过m.group()返回匹配对象
In [9]: m.group()
Out[9]: 'the'

# 通过m.group(1)返回子组1， 1为子组的编号
In [10]: m.group(1)
Out[10]: 'the'

3-3， groups()

通过m.groups()，可返回子组组成的元组

In [8]: m = re.search(r'(the)', str1)

# 因为r'(the)'只有一个子组，所以返回的元组元素只有一个
In [13]: m.groups()
Out[13]: ('the',)

3-4， re.match()

通过re.match(正则表达式，字符串)， 从字符串的开始进行匹配，成功返回匹配对象，失败则返回None

In [51]: m = re.match('foo', 'foo')

# 匹配成功
In [52]: m
Out[52]: <re.Match object; span=(0, 3), match='foo'>

In [56]: m.group()
Out[56]: 'foo'

3-5， re.search()

通过re.search(正则表达式，字符串)， 从字符串中查询匹配对象，成功返回匹配对象，失败则返回None

# 从整个字符串中进行查找匹配
In [58]: m = re.search('foo', 'seafood')
In [59]: m
Out[59]: <re.Match object; span=(3, 6), match='foo'>

In [60]: m.group()
Out[60]: 'foo'

3-6， re.findall()

通过re.findall(正则表达式，字符串)， 找出所有匹配的部分，返回一个列表

当正则表达式有子组，返回内容是一个元组组成的列表，元组元素是由子组匹配结果组成

# 返回所有匹配部分，是一个列表
In [10]: re.findall('car', 'carry the barcardi to the car')
Out[10]: ['car', 'car', 'car']

# 没有匹配返回一个空列表
In [11]: re.findall('car1', 'carry the barcardi to the car')
Out[11]: []

# 先匹配abc， 通过子组匹配b， 在通过子组匹配c， 所以返回如下
In [17]: m = re.findall('(a(b)(c))', 'abcabc')

In [18]: m
Out[18]: [('abc', 'b', 'c'), ('abc', 'b', 'c')]

3-7， re.sub(), re.subn()

通过re.sub(正则表达式，字符， my_string，次数)， 匹配my_string中的字符串，通过字符来替换匹配的结果，返回匹配后的字符串， 不指定次数，则表示全部替换，指定替换次数，则按指定值进行替换

# 没有指定次数替换
In [21]: re.sub('[ae]', 'X', 'abcdef')
Out[21]: 'XbcdXf'

# 按指定次数1次，进行替换
In [22]: re.sub('[ae]', 'X', 'abcdef', 1)
Out[22]: 'Xbcdef'

通过re.subn(正则表达式，字符， my_string，次数)， 功能和re.sub一样，返回结果是一个元组，指出替换次数

# 没有指定次数，全部替换
In [23]: re.subn('[ae]', 'X', 'abcdef')
Out[23]: ('XbcdXf', 2)

# 按指定次数1次进行替换
In [24]: re.subn('[ae]', 'X', 'abcdef', 1)
Out[24]: ('Xbcdef', 1)

3-8， re.split()

通过re.split(正则表达式)，分割字符串，默认全部分割，也可以指定分割次数，返回一个列表

# 没有指定次数， 全部分割
In [28]: re.split(r':', 'str1:str2:str3')
Out[28]: ['str1', 'str2', 'str3']

# 按指定次数进行分割
In [19]: re.split(r':', 'str1:str2:str3', 1)
Out[19]: ['str1', 'str2:str3']