python学习——正则表达式详解

标签：字符匹配 string re python pattern 正则表达式详解

正则表达式（Regular Expression，简称Regex）是一种用于匹配字符串中字符组合的模式。它是一种强大、灵活且高效的文本处理工具，广泛应用于数据验证、数据抽取、文本搜索和替换等场景。

文章目录

元字符

Python正则表达式中的元字符及其用途：

`.` (点号)

用途：匹配除换行符 \n 之外的任意单个字符。

示例：

import re
text = "p\ython\t\n"
pattern = r"."
matches = re.findall(pattern, text)
print(matches)  # 输出: ['p', 'y', 't', 'h', 'o', 'n', '\t']

在这个例子中，. 匹配了每个字符，除了换行符 \n。

`\w`

用途：匹配任何字母数字字符，等同于 [a-zA-Z0-9_]。它包括了所有小写和大写字母、数字以及下划线。

示例：

text = "python\n123"
pattern = r"\w"
matches = re.findall(pattern, text)
print(matches)  # 输出: ['p', 'y', 't', 'h', 'o', 'n', '1', '2', '3']

在这个例子中，\w 匹配了所有的字母和数字，不包括换行符 \n。

`\W`

用途：匹配任何非字母数字字符，等同于 [^a-zA-Z0-9_]。它是 \w 的反义，匹配所有不在 \w 范围内的字符。

示例：

text = "python\n123"
pattern = r"\W"
matches = re.findall(pattern, text)
print(matches)  # 输出: ['\n']

在这个例子中，\W 只匹配了换行符 \n。

`\s`

用途：匹配任何空白字符，包括空格、制表符 \t、换行符 \n 等。

示例：

text = "python\t123"
pattern = r"\s"
matches = re.findall(pattern, text)
print(matches)  # 输出: ['\t']

在这个例子中，\s 匹配了制表符 \t。

`\S`

用途：匹配任何非空白字符，是 \s 的反义。

示例：

text = "python\t123"
pattern = r"\S"
matches = re.findall(pattern, text)
print(matches)  # 输出: ['p', 'y', 't', 'h', 'o', 'n', '1', '2', '3']

在这个例子中，\S 匹配了所有的非空白字符。

`\d`

用途：匹配任何十进制数字，等同于 [0-9]。
示例：
```
text = "python\t123"
pattern = r"\d"
matches = re.findall(pattern, text)
print(matches)  # 输出: ['1', '2', '3']
```
在这个例子中，\d 匹配了所有的数字字符。
这些元字符在正则表达式中非常有用，因为它们可以让你用简洁的方式表达复杂的匹配规则。在实际应用中，你可以将这些元字符与其他正则表达式特性（如量词、分组、断言等）结合起来，以实现更高级的文本处理需求。

限定符

Python正则表达式中的限定符（quantifiers），用于指定前面的元素需要出现的次数。

? （问号）

描述说明: 匹配前面的字符0次或1次。
举例: colou?r
结果: 可以匹配“color”或“colour”。

+ （加号）

描述说明: 匹配前面的字符1次或多次。
举例: colou+r
结果: 可以匹配“colour”或“colouur”等等。

* （星号）

描述说明: 匹配前面的字符0次或多次。
举例: colou*r
结果: 可以匹配“color”或“colouur”等等。

{n} （花括号内为n）

描述说明: 匹配前面的字符恰好n次。
举例: colou{2}r
结果: 可以匹配“colouur”。

{n,} （花括号内为n逗号）

描述说明: 匹配前面的字符至少n次。
举例: colou{2,}r
结果: 可以匹配“colouur”或“colouuur”等等。

{n,m} （花括号内为n逗号m）

描述说明: 匹配前面的字符最少n次，最多m次。
举例: colou{2,4}r
结果: 可以匹配“colouur”、“colouuur”或“colouuuur”。
这些限定符可以帮助你在进行文本搜索时更加灵活地控制匹配的模式，从而满足不同的需求。
这张图片展示了Python中的正则表达式（Regular Expressions）的一些基本符号和它们的用途。下面是对这些内容的详细解释：

区间字符 [ ]

描述：匹配方括号中所指定的字符。
举例：[0-9] 匹配数字 0 到 9。

排除字符 ^

描述：匹配不在方括号中指定的字符。
举例：[^0-9] 匹配除了数字 0 到 9 以外的任何字符。

选择字符 |

描述：用于匹配左、右任意一个字符串。
举例：\d{18}|\d{15} 匹配 18 位或 15 位的身份证号码。

转义字符

描述：同 Python 中的转义字符。
用法：将某些字符作为普通字符使用，例如：\ 将反斜杠作为普通字符处理。

汉字匹配 [\u4e00-\u9fa5]

描述：匹配任意一个汉字。
示例：[\u4e00-\u9fa5]+ 可以用来匹配一个或多个汉字。

分组 ()

描述：改变限定符的作用。
举例：six|fourth(six|four)th 匹配 “six” 或 “fourth”，其中 “(six|four)th” 是一个整体被分组的部分。
这些符号在编写复杂的文本搜索和处理任务时非常有用，可以帮助开发者精确地定义需要匹配的模式。

re模块

re模块是Python标准库中的一个模块，它提供了对正则表达式的支持。正则表达式是一个强大的工具，用于字符串的搜索、替换、匹配等操作。以下是re模块的一些主要功能和函数的详解：

1. 匹配字符

.: 匹配除换行符之外的任意字符。
[...]: 匹配字符集合中的任意一个字符。
[^...]: 匹配不在字符集合中的任意一个字符。
\: 转义字符，用于匹配特殊字符或者表示特殊序列。
*: 匹配前面的子表达式零次或多次。
+: 匹配前面的子表达式一次或多次。
?: 匹配前面的子表达式零次或一次，或指明非贪婪搜索。
{m,n}: 匹配前面的子表达式至少m次，不超过n次。

2. `re`模块的主要函数

`re.compile(pattern, flags=0)`

编译正则表达式 pattern 为一个正则表达式对象，可以用于后续的匹配。

pattern: 要编译的正则表达式。
flags: 可选，表示匹配模式，如忽略大小写、多行模式等。

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

在字符串中搜索正则表达式的第一个匹配项。

pattern: 要搜索的正则表达式。
string: 要搜索的字符串。
flags: 可选，匹配模式标志。

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

从字符串的开始位置匹配正则表达式。

pattern: 要匹配的正则表达式。
string: 要匹配的字符串。
flags: 可选，匹配模式标志。

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

如果整个字符串匹配正则表达式，则返回一个匹配对象，否则返回None。

pattern: 要匹配的正则表达式。
string: 要匹配的字符串。
flags: 可选，匹配模式标志。

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

用正则表达式指定的模式拆分字符串。

pattern: 用于拆分的正则表达式。
string: 要拆分的字符串。
maxsplit: 最大拆分次数。
flags: 可选，匹配模式标志。

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

找到字符串中所有正则表达式的非重叠匹配，并以列表形式返回。

pattern: 要查找的正则表达式。
string: 要搜索的字符串。
flags: 可选，匹配模式标志。

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

找到字符串中所有正则表达式的非重叠匹配，并返回一个迭代器。

pattern: 要查找的正则表达式。
string: 要搜索的字符串。
flags: 可选，匹配模式标志。

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

替换字符串中与正则表达式匹配的模式。

pattern: 要搜索的正则表达式。
repl: 替换字符串或一个替换函数。
string: 要搜索和替换的字符串。
count: 替换的最大次数。
flags: 可选，匹配模式标志。

`re.escape(string)`

转义字符串中的特殊字符。

string: 要转义的字符串。

3. 匹配对象

当使用re.search()、re.match()等函数时，如果匹配成功，会返回一个匹配对象（Match对象），它具有以下方法和属性：

group(): 返回被匹配的字符串。
start(): 返回匹配开始的位置。
end(): 返回匹配结束的位置。
span(): 返回一个元组包含匹配开始和结束的位置。

4. 匹配标志

re.I (.IGNORECASE): 忽略大小写。
re.M (MULTILINE): 多行模式，^和$匹配每一行的开始和结束。
re.S (DOTALL): 点任意匹配模式，使.匹配包括换行符在内的任意字符。
re.X (VERBOSE): 详细模式，忽略正则表达式中的空白字符并允许加入注释。
使用re模块进行正则表达式操作时，应该注意正则表达式的编写和匹配标志的正确使用，以确保能够正确地处理字符串。

实操

1. match函数的使用

import re
pattern = '\d\.\d+'  # +限定符，\d 0-9数字出现1次或多次， 点当成普通字符
'''
正则表达式分析
\d: 匹配任何十进制数字（0-9）。
\.: 由于点（.）在正则表达式中是一个特殊字符，它用于匹配除换行符之外的任何单个字符。在这里，我们使用反斜杠（\）进行转义，使得点被当作普通字符处理，即匹配字面上的点（.）字符。
\d+: + 是一个限定符，表示前面的表达式（在这个例子中是 \d）可以出现一次或多次。
所以，整个表达式 '\d\.\d+' 的意思是匹配一个数字，紧接着是一个点，然后是一个或多个数字。
'''
s = 'I study Python 3.11 every day'  # 待匹配字符串
match = re.match(pattern, s, re.I)  # ignore忽略大小写
print(match)  # None为什么：因为match是从头开始匹配的，开头没有数字，不符合查找规则
s2 = '3.11Python I study everyday3.12' # re.match 只在字符串的开始位置进行匹配。一旦找到匹配项，它就不会继续在字符串的其余部分查找。这就是为什么在第二个例子中，尽管 ‘3.12’ 也符合模式，但 re.match 只返回第一个匹配项 ‘3.11’。
match2 = re.match(pattern, s2)
print(match2)
print('匹配值的其实位置：', match2.start())
print('匹配值的结束位置：', match2.end())
print('匹配区间的位置元素：', match2.span())
print('待匹配的字符串：', match2.string)
print('匹配的数据：', match2.group())

None
<re.Match object; span=(0, 4), match=‘3.11’>
匹配值的其实位置： 0
匹配值的结束位置： 4
匹配区间的位置元素： (0, 4)
待匹配的字符串： 3.11Python I study everyday
匹配的数据： 3.11

2. search函数的使用

import re
pattern = '\d\.\d+'
s = 'I study Python3.11 every day Python2.7 I love you'
match = re.search(pattern, s)  # re.search 只会返回第一个匹配的结果
print(match)
print(match.group())

s2 = '4.10 Python I study every day'
match2 = re.search(pattern, s2)
print(match2)
print(match2.group())

s3 = 'I study Python every day'
match3 = re.search(pattern, s3)
print(match3)

<re.Match object; span=(14, 18), match=‘3.11’>
3.11
<re.Match object; span=(0, 4), match=‘4.10’>
4.10
None

3. findall函数的使用

import re
pattern = '\d\.\d+'
s = 'I study Python3.11 every day Python2.7 I love you'
s2 = '4.10 Python I study every day'
s3 = 'I study Python every day'
lst = re.findall(pattern, s)
lst2 = re.findall(pattern, s2)
lst3 = re.findall(pattern, s3)

print(lst)
print(lst2)
print(lst3)

[‘3.11’, ‘2.7’]
[‘4.10’]
[]

4. sub函数使用

import re
# sub替换
pattern = '黑客|破解|反爬'
s = '我想学习python，向破解一些VIP视频，用python可以实现无底线反爬'
new_s = re.sub(pattern, '***', s)
print(new_s)

我想学习python，向一些VIP视频，用python可以实现无底线

5. split函数使用

import re
s = 'https://www.baidu.com/s?wd=aly&rsv_spt=1&rsv_iqid=0xb9b42cc1000bd454&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&tn=baiduhome_pg&rsv_enter=1&rsv_dl=ib&rsv_sug3=8&rsv_sug1=12&rsv_sug7=100&rsv_sug2=0&rsv_btype=i&inputT=7953&rsv_sug4=7953'
pattern = '[?|&]'  # 分割符
lst = re.split(pattern, s)
print(lst)

[‘https://www.baidu.com/s’, ‘wd=aly’, ‘rsv_spt=1’, ‘rsv_iqid=0xb9b42cc1000bd454’, ‘issp=1’, ‘f=8’, ‘rsv_bp=1’, ‘rsv_idx=2’, ‘ie=utf-8’, ‘tn=baiduhome_pg’, ‘rsv_enter=1’, ‘rsv_dl=ib’, ‘rsv_sug3=8’, ‘rsv_sug1=12’, ‘rsv_sug7=100’, ‘rsv_sug2=0’, ‘rsv_btype=i’, ‘inputT=7953’, ‘rsv_sug4=7953’]

标签：字符,匹配,string,re,python,pattern,正则表达式,详解
From： https://blog.csdn.net/Qhumaing/article/details/144317190