Python正则表达式使用教程

一分耕耘，一分收获！既然打开了这篇文章《python如何使用正则表达式匹配_python re模块正则表达式使用指南》，就坚持看下去吧！文中内容包含等等知识点...希望你能在阅读本文后，能真真实实学到知识或者帮你解决心中的疑惑，也欢迎大佬或者新人朋友们多留言评论，多给建议！谢谢！

Python中处理正则表达式的核心工具是re模块，它提供了re.match()、re.search()、re.findall()、re.finditer()和re.fullmatch()等核心函数。这些函数的区别在于匹配方式和范围：re.match()仅从字符串开头匹配，re.search()扫描整个字符串返回首个匹配，re.findall()返回所有非重叠匹配的列表，re.finditer()返回匹配对象的迭代器，re.fullmatch()要求整个字符串完全匹配。结合元字符（如.、^、$、*、+、?、[]、|、()）和特殊序列（如\d、\w、\s、\b），可构建复杂模式。使用原始字符串r""能避免反斜杠转义问题。re.sub()用于替换，支持反向引用和函数替换；re.split()用正则表达式分割字符串，支持捕获组保留分隔符。为提升性能，频繁使用的模式应通过re.compile()预编译成Pattern对象。常用标志位包括re.IGNORECASE（忽略大小写）、re.MULTILINE（多行模式，^和$匹配每行首尾）和re.DOTALL（.匹配包括换行符在内的所有字符）。合理选择函数、正确使用元字符与标志位，并利用编译模式，是高效进行文本处理的关键。

Python中处理正则表达式匹配的核心工具是内置的re模块。它提供了一套功能强大且灵活的函数，能够帮助我们高效地在字符串中查找、提取、替换或分割符合特定模式的内容。

解决方案

要使用Python的re模块进行正则表达式匹配，首先需要导入它。接着，你可以定义一个正则表达式模式（通常推荐使用原始字符串r"..."来避免反斜杠的转义问题），然后调用re模块提供的各种函数，如re.search()、re.findall()或re.sub()，根据你的需求来执行匹配、查找或替换操作。

一个最基本的例子是查找字符串中是否包含某个单词：

import re

text = "Hello, world! Python is amazing."
pattern = r"Python"

# 使用 re.search() 查找第一个匹配项
match = re.search(pattern, text)

if match:
    print(f"找到了匹配项: {match.group()}")
else:
    print("没有找到匹配项。")

# 查找所有数字
numbers_text = "我今年25岁，体重65公斤，身高175厘米。"
number_pattern = r"\d+" # \d 匹配数字，+ 匹配一个或多个

all_numbers = re.findall(number_pattern, numbers_text)
print(f"找到的所有数字: {all_numbers}")

Python re模块的核心匹配函数有哪些？它们之间有什么区别？

在Python的re模块中，有几个核心的匹配函数，它们各自有不同的侧重点和使用场景。理解它们的区别对于高效地进行正则表达式操作至关重要。

首先是re.match(pattern, string, flags=0)。这个函数尝试从字符串的起始位置匹配模式。如果匹配成功，它会返回一个Match对象；否则，返回None。这意味着，即使字符串中其他位置存在匹配项，如果不是从开头匹配的，re.match()也不会找到。我个人觉得，re.match()在验证字符串是否以特定模式开头时非常有用，比如检查一个文件名是否以“IMG_”开头。

import re

text = "Hello World"
pattern = r"World"
match_result = re.match(pattern, text)
print(f"re.match('{pattern}', '{text}'): {match_result}") # None，因为World不在开头

pattern = r"Hello"
match_result = re.match(pattern, text)
print(f"re.match('{pattern}', '{text}'): {match_result.group() if match_result else 'None'}") # Hello

接着是re.search(pattern, string, flags=0)。与re.match()不同，re.search()会扫描整个字符串，寻找模式的第一个匹配项。一旦找到，它就返回一个Match对象，不再继续查找。如果整个字符串都没有匹配项，则返回None。在大多数日常的查找任务中，re.search()往往比re.match()更常用，因为它不局限于字符串的开头。比如，你想知道一个日志文件中是否包含某个错误代码，re.search()就能派上用场。

import re

text = "The quick brown fox jumps over the lazy dog."
pattern = r"fox"
search_result = re.search(pattern, text)
print(f"re.search('{pattern}', '{text}'): {search_result.group() if search_result else 'None'}") # fox

pattern = r"cat"
search_result = re.search(pattern, text)
print(f"re.search('{pattern}', '{text}'): {search_result}") # None

然后是re.findall(pattern, string, flags=0)。这个函数会找到所有非重叠的匹配项，并以字符串列表的形式返回它们。如果没有找到任何匹配项，则返回一个空列表。re.findall()在需要提取所有符合特定模式的数据时非常方便，比如从一段文本中提取所有URL或所有电子邮件地址。

import re

text = "Emails: test@example.com, user@domain.org, info@mail.net"
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
findall_result = re.findall(pattern, text)
print(f"re.findall('{pattern}', '{text}'): {findall_result}")

与re.findall()类似但返回类型不同的是re.finditer(pattern, string, flags=0)。它返回一个迭代器，该迭代器生成所有非重叠的Match对象。当你需要对每个匹配项进行更复杂的操作（比如获取其起始和结束位置、捕获组等），并且数据量可能很大时，re.finditer()会比re.findall()更高效，因为它避免了一次性将所有匹配项加载到内存中。

import re

text = "Numbers: 123, 456, 789"
pattern = r"\d+"
finditer_result = re.finditer(pattern, text)
for match in finditer_result:
    print(f"Found number: {match.group()} at position {match.start()}-{match.end()}")

最后是re.fullmatch(pattern, string, flags=0)。这个函数要求整个字符串完全匹配给定的模式。如果字符串的任何部分不匹配模式，或者模式没有覆盖整个字符串，re.fullmatch()都会返回None。这在验证输入字符串是否严格符合某种格式时非常有用，比如验证一个字符串是否严格是一个日期格式，不多不少。

import re

text = "Python"
pattern = r"Python"
fullmatch_result = re.fullmatch(pattern, text)
print(f"re.fullmatch('{pattern}', '{text}'): {fullmatch_result.group() if fullmatch_result else 'None'}") # Python

text = "Python is great"
fullmatch_result = re.fullmatch(pattern, text)
print(f"re.fullmatch('{pattern}', '{text}'): {fullmatch_result}") # None

总结来说，re.match()注重开头，re.search()注重首次出现，re.findall()和re.finditer()注重所有出现，而re.fullmatch()则要求全字匹配。选择哪个函数取决于你具体想达成的匹配目标。

Python正则表达式的常用元字符和特殊序列有哪些？

正则表达式的强大之处在于它使用了一套特殊的字符和序列来描述复杂的文本模式，这些就是元字符（Metacharacters）和特殊序列（Special Sequences）。掌握它们是编写有效正则表达式的关键。

常用元字符：

• . (点号)：匹配除换行符\n之外的任何单个字符。这是最通用的匹配符，但有时也可能带来意想不到的匹配，需要小心使用。
• ^ (脱字符)：匹配字符串的开头。在多行模式（re.M）下，它也匹配每一行的开头。
• $ (美元符号)：匹配字符串的结尾。在多行模式下，它也匹配每一行的结尾。
• * (星号)：匹配前一个字符零次或多次。例如，a*匹配空字符串、a、aa、aaa等。
• + (加号)：匹配前一个字符一次或多次。例如，a+匹配a、aa、aaa等，但不匹配空字符串。
• ? (问号)：匹配前一个字符零次或一次。它也可以使量词变为非贪婪模式（如.*?）。
• {m}：匹配前一个字符恰好m次。
• {m,n}：匹配前一个字符m到n次（包含m和n）。
• [] (方括号)：定义一个字符集。匹配方括号中包含的任意一个字符。例如，[aeiou]匹配任何一个小写元音字母。[0-9]等同于\d。[^abc]表示匹配除了a、b、c之外的任何字符。
• \ (反斜杠)：用于转义特殊字符，使其失去特殊含义，或用于引入特殊序列。例如，\.匹配一个实际的点号，而不是任何字符。
• | (竖线)：作为“或”操作符。例如，cat|dog匹配“cat”或“dog”。
• () (圆括号)：用于创建捕获组，将多个字符组合成一个单元，并可以对匹配到的内容进行提取。例如，(ab)+匹配ab、abab等。

常用特殊序列：

• \d：匹配任何数字字符（0-9）。等同于[0-9]。
• \D：匹配任何非数字字符。等同于[^0-9]。
• \w：匹配任何字母数字字符（包括下划线）。等同于[a-zA-Z0-9_]。
• \W：匹配任何非字母数字字符。等同于[^a-zA-Z0-9_]。
• \s：匹配任何空白字符（空格、制表符、换行符等）。
• \S：匹配任何非空白字符。
• \b：匹配单词边界。例如，\bword\b会精确匹配独立的“word”单词，而不是“sword”或“wordy”中的“word”。
• \B：匹配非单词边界。
• \A：匹配字符串的开头，无论是否在多行模式下（与^在多行模式下有区别）。
• \Z：匹配字符串的结尾，无论是否在多行模式下（与$在多行模式下有区别）。

一个常见的陷阱是，当模式中包含很多反斜杠时，Python字符串的默认转义规则可能会导致混淆。这就是为什么强烈建议使用原始字符串（raw string），即在字符串前加上r前缀，例如r"\d+\s\w+"。这样，反斜杠就不会被Python解释器再次处理，而是直接传递给正则表达式引擎，大大简化了模式的编写。

import re

# 匹配一个或多个数字，后面跟着一个空格，再后面跟着一个或多个字母数字字符
text = "Item 123, Price 45.99, Quantity 10"
pattern = r"(\w+)\s(\d+)" # 捕获组：匹配单词和数字
matches = re.findall(pattern, text)
print(f"匹配单词和数字: {matches}") # [('Item', '123'), ('Quantity', '10')]

# 匹配一个以 'a' 开头，以 'c' 结尾，中间可以是任意字符的字符串
text = "abc, axc, ayyc, azzzc"
pattern = r"a.+c" # 贪婪匹配
print(f"贪婪匹配: {re.findall(pattern, text)}") # ['abc, axc, ayyc, azzzc']

pattern = r"a.+?c" # 非贪婪匹配
print(f"非贪婪匹配: {re.findall(pattern, text)}") # ['abc', 'axc', 'ayyc', 'azzc']

# 匹配电话号码格式 (XXX) XXX-XXXX
phone_numbers = "My phone is (123) 456-7890, and hers is (987) 654-3210."
phone_pattern = r"\(\d{3}\)\s\d{3}-\d{4}"
found_phones = re.findall(phone_pattern, phone_numbers)
print(f"找到的电话号码: {found_phones}")

如何在Python中使用正则表达式进行替换和分割操作？

正则表达式不仅仅用于查找和匹配，它在文本处理中更强大的应用之一是内容的替换和分割。re模块提供了re.sub()和re.split()这两个函数来完成这些任务。

替换操作：re.sub(pattern, repl, string, count=0, flags=0)

re.sub()函数用于将字符串中所有匹配pattern的子串替换为repl。

• pattern：要匹配的正则表达式。
• repl：替换字符串，或者是一个函数。
• string：要进行替换操作的原始字符串。
• count：可选参数，指定最多替换的次数。默认为0，表示替换所有匹配项。
• flags：可选参数，如re.IGNORECASE等。

repl参数可以是字符串，也可以是一个函数。当repl是字符串时，你可以使用反向引用（\1, \2等或\g）来引用pattern中捕获组匹配到的内容。这在重新组织文本结构时特别有用。

import re

text = "Date: 2023-10-26, Time: 14:30:00"
# 将日期格式从 YYYY-MM-DD 转换为 DD/MM/YYYY
# 捕获组 (YYYY), (MM), (DD)
pattern = r"(\d{4})-(\d{2})-(\d{2})"
# 使用反向引用 \3/\2/\1 来重新排列日期
replaced_text = re.sub(pattern, r"\3/\2/\1", text)
print(f"日期格式转换: {replaced_text}")

# 替换所有数字为 "[NUM]"
text_with_numbers = "Product A price is $120.50, and Product B is $99."
replaced_numbers = re.sub(r"\d+(\.\d+)?", "[NUM]", text_with_numbers)
print(f"替换数字: {replaced_numbers}")

当repl是一个函数时，每次找到匹配项，该函数都会被调用，并将Match对象作为参数传递。函数的返回值将作为替换字符串。这提供了极大的灵活性，可以根据匹配到的内容进行复杂的逻辑处理。

import re

# 将所有数字乘以2
def double_number(match):
    # match.group(0) 获取整个匹配到的字符串
    return str(int(match.group(0)) * 2)

text_for_double = "The numbers are 5, 10, and 15."
doubled_numbers = re.sub(r"\d+", double_number, text_for_double)
print(f"数字翻倍: {doubled_numbers}")

分割操作：re.split(pattern, string, maxsplit=0, flags=0)

re.split()函数使用正则表达式pattern作为分隔符来分割string，并返回一个字符串列表。

• pattern：用作分隔符的正则表达式。
• string：要分割的原始字符串。
• maxsplit：可选参数，指定最大分割次数。默认为0，表示无限制。
• flags：可选参数。

与字符串的split()方法相比，re.split()的优势在于可以使用任何复杂的正则表达式作为分隔符，而不仅仅是固定的字符串。

import re

# 使用多个分隔符分割字符串：逗号、分号或空格
text = "apple,banana;orange grape"
split_result = re.split(r"[,;\s]+", text) # 匹配一个或多个逗号、分号或空白字符
print(f"多分隔符分割: {split_result}")

# 如果模式中包含捕获组，那么捕获组匹配到的内容也会作为结果列表的一部分被返回
text_with_delimiters = "one<|>two<|>three"
split_with_capturing_group = re.split(r"(<\|>)", text_with_delimiters)
print(f"带捕获组分割: {split_with_capturing_group}") # ['one', '<|>', 'two', '<|>', 'three']

# 不带捕获组，分隔符不保留
split_without_capturing_group = re.split(r"<\|>", text_with_delimiters)
print(f"不带捕获组分割: {split_without_capturing_group}") # ['one', 'two', 'three']

在处理文本数据时，无论是清理、格式化还是提取特定信息，re.sub()和re.split()都是不可或缺的工具。它们与re.search()、re.findall()等匹配函数共同构成了re模块在Python中进行高级文本操作的基石。

Python正则表达式中的编译模式和标志位有什么作用？

在处理正则表达式时，尤其是在一个模式需要被多次使用的情况下，理解和利用编译模式以及各种标志位（flags）能显著提升代码的效率和可读性。

编译模式：re.compile(pattern, flags=0)

当你使用re.search()、re.findall()等函数时，re模块会在内部将你的正则表达式模式编译成一个Pattern对象。如果同一个模式被多次使用，每次调用函数时都会重复这个编译过程，这会带来不必要的开销。

re.compile()函数允许你预先编译一个正则表达式模式，生成一个Pattern对象。这个Pattern对象拥有与re模块函数类似的方法（如match(), search(), findall(), sub()等），但它避免了重复编译的性能损耗。

import re
import time

# 不使用编译模式
start_time = time.time()
for _ in range(100000):
    re.search(r"(\d{3})-(\d{3})-(\d{4})", "My phone is 123-456-7890.")
end_time = time.time()
print(f"不使用编译模式耗时: {end_time - start_time:.4f}秒")

# 使用编译模式
compiled_pattern = re.compile(r"(\d{3})-(\d{3})-(\d{4})")
start_time = time.time()
for _ in range(100000):
    compiled_pattern.search("My phone is 123-456-7890.")
end_time = time.time()
print(f"使用编译模式耗时: {end_time - start_time:.4f}秒")

从上面的例子可以看出，对于大量重复操作，编译模式可以带来明显的性能提升。当然，对于只使用一次的模式，直接使用re模块的函数并不会有太大性能差异，甚至可能因为少了一步编译调用而显得“更快”一点点。关键在于“重复使用”这个场景。

标志位（Flags）：

标志位是用于修改正则表达式匹配行为的特殊选项。它们可以作为re.compile()或re模块中其他函数的flags参数传入。常用的标志位包括：

• re.IGNORECASE (或 re.I)：忽略大小写。匹配时将不区分字母的大小写。

  text = "Hello World"
  match = re.search(r"hello", text, re.IGNORECASE)
  print(f"忽略大小写匹配: {match.group() if match else 'None'}") # Hello

• `re.MULTIL

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。