什么是正则表达式 ？

正则表达式是一组由字母和符号组成的特殊文本，它可以用来从文本中找出满足你想要的格式的句子。

一个正则表达式是一种从左到右匹配主体字符串的模式，常使用缩写的术语“regex”或“regexp”。

1. 正则表达式的基本语法

1.1 字符匹配

• .：匹配任意单个字符（除了换行符）。
• \d：匹配数字，等价于[0-9]。
• \D：匹配非数字，等价于[^0-9]。
• \w：匹配字母、数字或下划线，等价于[a-zA-Z0-9_]。
• \W：匹配非字母、数字或下划线，等价于[^a-zA-Z0-9_]。
• \s：匹配空白字符，包括空格、制表符和换行符。
• \S：匹配非空白字符。

1.2 字符集

• [abc]：匹配a、b或c中的任意一个字符。
• [^abc]：匹配除a、b、c之外的任意字符。
• [a-z]：匹配小写字母中的任意一个字符。
• [0-9]：匹配数字中的任意一个字符。

1.3 量词

*：匹配前面的字符零次或多次。

+：匹配前面的字符一次或多次。

?：匹配前面的字符零次或一次。

{n}：匹配前面的字符恰好n次。

{n,}：匹配前面的字符至少n次。

{n,m}：匹配前面的字符至少n次，但不超过m次，一个范围。

1.4 边界匹配

• ^：匹配字符串的开始位置。
• $：匹配字符串的结束位置。
• \b：匹配单词边界。
• \B：匹配非单词边界。

2. 正则表达式示例

2.1 基本匹配示例

下面是一些Python中使用正则表达式的基本示例。

示例 1：匹配邮箱地址

import re

# 正则表达式
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'

# 测试邮箱
emails = ["test@example.com", "invalid-email@", "user123@domain.co.uk"]

for email in emails:
    if re.match(pattern, email):
        print(f"{email} 是有效的邮箱")
    else:
        print(f"{email} 不是有效的邮箱")

解读

1. ^ - 表示匹配字符串的开始位置，确保电子邮件地址从这里开始
2. [a-zA-Z0-9._%+-]+ - 匹配电子邮件地址中的用户名部分：

[a-zA-Z0-9._%+-]：允许的字符集

• a-zA-Z：所有大小写字母
• 0-9：所有数字
• .：点号
• _：下划线
• %：百分号
• +：加号
• -：减号 / 连字符
• +：表示前面的字符集可以出现 1 次或多次

3. @ - 匹配电子邮件地址中的 @符号，这是邮箱地址的必备元素
4. [a-zA-Z0-9.-]+ - 匹配域名的主部分（如 gmail、yahoo、company 等）：

• [a-zA-Z0-9.-]：允许的字符集
• 字母、数字
• .：点号（用于子域名，如mail.yahoo.com）
• -：连字符（某些域名中允许）
• +：表示前面的字符集可以出现 1 次或多次

5. \. - 匹配域名中的点号（如.com、.org 中的点），这里用反斜杠转义，因为点在正则中有特殊含义
6. [a-zA-Z]{2,} - 匹配顶级域名（如 com、org、cn 等）：

• [a-zA-Z]：只允许字母
• {2,}：表示至少需要 2 个字符（如 cn、uk 等）

7. $ - 表示匹配字符串的结束位置，确保电子邮件地址在这里结束

运行结果

test@example.com 是有效的邮箱
invalid-email@ 不是有效的邮箱
user123@domain.co.uk 是有效的邮箱

2.2 复杂匹配示例

示例 2：匹配手机号码

import re

# 正则表达式
pattern = r'^\+?(\d{1,3})?[-.\s]?(\d{10})$'

# 测试手机号码
phone_numbers = ["+123-4567890123", "4567890123", "12345", "123-456-7890"]

for number in phone_numbers:
    if re.match(pattern, number):
        print(f"{number} 是有效的手机号码")
    else:
        print(f"{number} 不是有效的手机号码")

运行结果

+123-4567890123 是有效的手机号码
4567890123 是有效的手机号码
12345 不是有效的手机号码
123-456-7890 不是有效的手机号码

2.3 替换示例

示例 3：替换文本中的特定内容

import re

text = "Hello, my email is test@example.com. Please contact me!"
# 正则表达式
pattern = r'\S+@\S+'

# 替换邮箱为“[邮箱隐藏]”
new_text = re.sub(pattern, "[邮箱隐藏]", text)
print(new_text)

运行结果

Hello, my email is [邮箱隐藏]. Please contact me!

正则表达式是处理字符串和文本数据的强大工具，能够高效地进行匹配、查找和替换等操作。掌握其基本语法和用法，可以帮助您在编程和数据处理时更为轻松。本文通过多个示例展示了正则表达式在Python中的使用，希望对您有所帮助。

3.正则表达式函数

python的re模块还比较简单，包括以下几个方法：

• re.search()：查找符合模式的字符，只返回第一个，返回Match对象
• re.match()：和search一样，但要求必须从字符串开头匹配
• re.findall()：返回所有匹配的字符串列表
• re.finditer()：返回一个迭代器，其中包含所有的匹配，也就是Match对象
• re.sub()：替换匹配的字符串，返回替换完成的文本
• re.subn()：替换匹配的字符串，返回替换完成的文本和替换的次数
• re.split()：用匹配表达式的字符串做分隔符分割原字符串
• re.compile()：把正则表达式编译成一个对象，方便后面使用

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

• 作用：在字符串中搜索匹配的模式，找到第一个匹配后返回一个Match对象，如果没有找到匹配，则返回None。
• 示例

import re
result = re.search(r'\d+', 'hello 123 world')
print(result.group())  # 输出: 123

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

• 作用：与search()类似，但是它只匹配字符串的开始。如果字符串的开始不符合模式，则返回None。
• 示例

result = re.match(r'\d+', '123 hello world')
print(result.group())  # 输出: 123

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

• 作用：返回字符串中所有与模式匹配的非重叠匹配项的列表。
• 示例

results = re.findall(r'\d+', 'hello 123 world 456')
print(results)  # 输出: ['123', '456']

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

• 作用：返回一个迭代器，产生所有匹配的Match对象。
• 示例

for match in re.finditer(r'\d+', 'hello 123 world 456'):
    print(match.group())  # 分别输出: 123 和 456

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

• 作用：用repl替换string中所有匹配pattern的部分，返回替换后的字符串。count参数可以指定最大替换次数。
• 示例

new_string = re.sub(r'\d+', 'number', 'hello 123 world 456')
print(new_string)  # 输出: hello number world number

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

• 作用：与sub()相同，但是返回一个元组，包含替换后的字符串和替换的次数。
• 示例

new_string, n = re.subn(r'\d+', 'number', 'hello 123 world 456')
print(new_string)  # 输出: hello number world number
print(n)  # 输出: 2

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

• 作用：根据模式对字符串进行分割，返回一个列表。maxsplit参数可以指定最大分割次数。
• 示例

parts = re.split(r'\s+', 'hello   world')
print(parts)  # 输出: ['hello', 'world']

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

• 作用：编译正则表达式模式为正则表达式对象，这样可以在后续的操作中复用这个对象，提高效率。
• 示例

pattern = re.compile(r'\d+')
result = pattern.search('hello 123 world')
print(result.group())  # 输出: 123

以上就是关于re模块中一些常用方法的简介和示例，希望对您有所帮助。如果您有任何具体的问题或需要进一步的帮助，请随时提问！

4.一些经验之谈

[]（字符集）和{}（量词）前后顺序区别

a.本质区别

• []（字符集）：定义 "允许出现的单个字符范围"，只能匹配一个字符。例如：[abc] 表示匹配 "a"、"b" 或 "c" 中的任意一个字符；[0-9] 表示匹配任意一个数字。
• {}（量词）：定义 "前面元素的出现次数"，不能单独使用，必须跟在某个元素（字符、字符集、分组等）后面。例如：a{2} 表示 "a" 连续出现 2 次；[0-9]{3} 表示任意数字连续出现 3 次。

b. 前后顺序规则--->[字符集]{次数}

[] 通常在 {} 前面，因为量词（{}）是用来修饰它前面的元素（可以是 [] 定义的字符集）的。即：[字符集]{次数} → 表示 "字符集中的字符允许出现的次数"。

示例：

• [0-9]{3}：[0-9] 定义了 "单个数字"，{3} 修饰这个字符集，表示 "连续 3 个数字"（如 "123"）。
• [a-zA-Z]{2,5}：[a-zA-Z] 定义了 "单个字母"，{2,5} 表示 "2 到 5 个连续字母"（如 "abc"、"xyz12" 不匹配，因为包含数字）。

c. 反例（错误顺序）--->反过来则是拼接

• 正常逻辑：[]（定义单个字符范围）在前，{}（定义该范围的出现次数）在后 → [字符集]{次数}。
• 核心关系：{} 是 "修饰符"，[] 是 "被修饰的元素"，修饰符必须跟在被修饰元素后面。
• 特殊情况：[] 内部的 {} 仅作为普通符号处理，不表示量词。