文本匹配是编程中非常常见的任务，特别是在处理大量数据时。Python 提供了多种强大的工具来帮助我们实现高效的文本匹配。本文将详细介绍 13 种常用的文本匹配模式，从简单的字符串方法到复杂的正则表达式，逐步引导你掌握这些强大的工具。
1. 使用 in 关键字
最简单的文本匹配方式就是使用 in 关键字，检查一个字符串是否包含另一个字符串。
text = "Hello, world!"
substring = "world"
if substring in text:
print(f"'{substring}' is found in '{text}'")
else:
print(f"'{substring}' is not found in '{text}'")输出：
'world' is found in 'Hello, world!'2. 使用 str.find()
str.find() 方法返回子字符串在字符串中的位置，如果找不到则返回 -1。
text = "Hello, world!"
substring = "world"
index = text.find(substring)
if index != -1:
print(f"'{substring}' is found at index {index} in '{text}'")
else:
print(f"'{substring}' is not found in '{text}'")输出：
'world' is found at index 7 in 'Hello, world!'3. 使用 str.index()
str.index() 方法类似于 str.find()，但如果没有找到子字符串，它会抛出一个 ValueError。
text = "Hello, world!"
substring = "world"
try:
index = text.index(substring)
print(f"'{substring}' is found at index {index} in '{text}'")
except ValueError:
print(f"'{substring}' is not found in '{text}'")输出：
'world' is found at index 7 in 'Hello, world!'4. 使用 str.startswith()
str.startswith() 方法检查字符串是否以指定的前缀开头。
text = "Hello, world!"
if text.startswith("Hello"):
print(f"'{text}' starts with 'Hello'")
else:
print(f"'{text}' does not start with 'Hello'")输出：
'Hello, world!' starts with 'Hello'5. 使用 str.endswith()
str.endswith() 方法检查字符串是否以指定的后缀结尾。
text = "Hello, world!"
if text.endswith("world!"):
print(f"'{text}' ends with 'world!'")
else:
print(f"'{text}' does not end with 'world!'")输出：
'Hello, world!' ends with 'world!'6. 使用 str.count()
str.count() 方法返回子字符串在字符串中出现的次数。
text = "Hello, world! Hello, Python!"
count = text.count("Hello")
print(f"'Hello' appears {count} times in '{text}'")输出：
'Hello' appears 2 times in 'Hello, world! Hello, Python!'7. 使用 str.replace()
str.replace() 方法用于替换字符串中的子字符串。
text = "Hello, world!"
new_text = text.replace("world", "Python")
print(f"Original: {text}")
print(f"Replaced: {new_text}")输出：
Original: Hello, world!
Replaced: Hello, Python!8. 使用 re 模块的基本匹配
re 模块提供了正则表达式的支持，可以进行更复杂的文本匹配。
import re
text = "Hello, world!"
pattern = r"world"
match = re.search(pattern, text)
if match:
print(f"Pattern '{pattern}' is found in '{text}'")
else:
print(f"Pattern '{pattern}' is not found in '{text}'")输出：
Pattern 'world' is found in 'Hello, world!'9. 使用 re.findall()
re.findall() 方法返回所有匹配的子字符串。
import re
text = "Hello, world! Hello, Python!"
pattern = r"Hello"
matches = re.findall(pattern, text)
print(f"Pattern '{pattern}' is found {len(matches)} times in '{text}'")输出：
Pattern 'Hello' is found 2 times in 'Hello, world! Hello, Python!'10. 使用 re.sub()
re.sub() 方法用于替换正则表达式匹配的子字符串。
import re
text = "Hello, world!"
pattern = r"world"
replacement = "Python"
new_text = re.sub(pattern, replacement, text)
print(f"Original: {text}")
print(f"Replaced: {new_text}")输出：
Original: Hello, world!
Replaced: Hello, Python!11. 使用 re.split()
re.split() 方法根据正则表达式分割字符串。
import re
text = "Hello, world! Hello, Python!"
pattern = r"!"
parts = re.split(pattern, text)
print(f"Text split by '!': {parts}")输出：
Text split by '!': ['Hello, world', ' Hello, Python', '']12. 使用 re.compile()
re.compile() 方法编译正则表达式，提高多次使用的效率。
import re
text = "Hello, world! Hello, Python!"
pattern = re.compile(r"Hello")
matches = pattern.findall(text)
print(f"Pattern 'Hello' is found {len(matches)} times in '{text}'")输出：
Pattern 'Hello' is found 2 times in 'Hello, world! Hello, Python!'13. 使用 re.escape()
re.escape() 方法转义特殊字符，防止它们被解释为正则表达式的一部分。
import re
text = "Hello, world! Hello, Python!"
special_char = "."
escaped_char = re.escape(special_char)
pattern = f"{escaped_char}"
matches = re.findall(pattern, text)
print(f"Pattern '{escaped_char}' is found {len(matches)} times in '{text}'")输出：
Pattern '\.' is found 2 times in 'Hello, world! Hello, Python!'实战案例：日志文件分析
假设你有一个日志文件，记录了用户的访问信息，格式如下：
2023-10-01 12:00:00 - User1 - Page1
2023-10-01 12:01:00 - User2 - Page2
2023-10-01 12:02:00 - User1 - Page3
2023-10-01 12:03:00 - User3 - Page1我们需要分析这个日志文件，统计每个用户访问的页面次数。
import re
from collections import defaultdict
# 假设这是日志文件的内容
log_content = """
2023-10-01 12:00:00 - User1 - Page1
2023-10-01 12:01:00 - User2 - Page2
2023-10-01 12:02:00 - User1 - Page3
2023-10-01 12:03:00 - User3 - Page1
"""
# 编译正则表达式
pattern = re.compile(r"(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}) - (\w+) - (\w+)")
# 创建一个字典来存储用户访问的页面次数
user_page_count = defaultdict(lambda: defaultdict(int))
# 遍历日志内容，匹配每一行
for line in log_content.strip().split('\n'):
match = pattern.match(line)
if match:
timestamp, user, page = match.groups()
user_page_count[user][page] += 1
# 输出结果
for user, pages in user_page_count.items():
print(f"User: {user}")
for page, count in pages.items():
print(f" Page: {page}, Count: {count}")输出：
User: User1
Page: Page1, Count: 1
Page: Page3, Count: 1
User: User2
Page: Page2, Count: 1
User: User3
Page: Page1, Count: 1总结
本文介绍了 13 种常用的文本匹配模式，包括简单的字符串方法和复杂的正则表达式。通过这些方法，你可以高效地处理各种文本匹配任务。每种方法都有其适用场景，选择合适的方法可以大大提高你的编程效率。最后，我们通过一个实战案例展示了如何使用这些方法来分析日志文件，统计用户访问的页面次数。
