Python 字符串查找包含方法详解：从基础到进阶
在 Python 编程中，字符串是一种重要的数据类型，我们经常需要对字符串进行各种操作，其中最常见且实用的操作之一就是判断一个字符串是否包含另一个特定的子字符串。Python 提供了多种灵活且功能各异的方法来实现这一目标，从简单的布尔判断到查找子字符串的具体位置，再到更复杂的模式匹配。理解并熟练掌握这些方法，能帮助我们更高效地处理文本数据。
本文将深入探讨 Python 中用于字符串查找包含的各种方法，包括它们的基本用法、特点、适用场景以及一些进阶技巧。我们将从最简单直观的方法开始，逐步过渡到更强大的工具。
1. 使用 in 运算符：最简洁的判断
in 运算符是 Python 中检查成员资格的标准方法，它不仅适用于字符串，也适用于列表、元组、集合等序列类型。在字符串操作中，in 运算符用于判断一个子字符串是否存在于主字符串中。
基本语法：
python
sub_string in main_string
功能：
判断 main_string 是否包含 sub_string。
返回值：
一个布尔值：如果 main_string 包含 sub_string，返回 True；否则，返回 False。
特点：
- 简洁易读： 这是判断字符串是否包含子字符串的最 Pythonic 方式，代码清晰直观。
- 只判断是否存在： 它只关心是否存在，不提供子字符串出现的位置信息。
- 区分大小写： 默认情况下，
in运算符是区分大小写的。
示例：
“`python
text = “Hello, world! Welcome to Python.”
substring1 = “world”
substring2 = “Python”
substring3 = “java”
substring4 = “World” # 注意大小写
print(f”‘{text}’ 包含 ‘{substring1}’ 吗? {substring1 in text}”)
print(f”‘{text}’ 包含 ‘{substring2}’ 吗? {substring2 in text}”)
print(f”‘{text}’ 包含 ‘{substring3}’ 吗? {substring3 in text}”)
print(f”‘{text}’ 包含 ‘{substring4}’ 吗? {substring4 in text}”)
输出:
‘Hello, world! Welcome to Python.’ 包含 ‘world’ 吗? True
‘Hello, world! Welcome to Python.’ 包含 ‘Python’ 吗? True
‘Hello, world! Welcome to Python.’ 吗? False
‘Hello, world! Welcome to Python.’ 包含 ‘World’ 吗? False
“`
应用场景：
当你只需要快速判断一个字符串是否包含某个特定子串，而无需知道其位置时，in 运算符是最佳选择。
进阶：空字符串的判断
有趣的是，对于空字符串 ""，in 运算符的行为是返回 True，因为一个空字符串可以被认为是存在于任何字符串（包括空字符串本身）的任意位置。
python
print("Hello" in "") # False (非空字符串不包含空字符串，这是反直觉的，但符合定义)
print("" in "Hello") # True
print("" in "") # True
2. 使用 find() 方法：查找并返回位置
find() 方法不仅可以判断一个字符串是否包含另一个子字符串，还能返回子字符串第一次出现的起始索引。
基本语法：
python
main_string.find(sub_string, start, end)
参数：
sub_string: 要查找的子字符串。start(可选): 查找的起始索引，默认为 0。end(可选): 查找的结束索引（不包含），默认为字符串的长度。
功能：
在 main_string 的指定范围内（从 start 到 end-1）查找 sub_string 第一次出现的索引。
返回值：
- 如果找到
sub_string，返回它在main_string中第一次出现的起始索引（一个非负整数）。 - 如果未找到
sub_string，返回-1。
特点：
- 提供位置信息： 这是与
in运算符的主要区别。 - 未找到时返回 -1： 这是一种安全的行为，不会引发错误。
- 支持指定查找范围：
start和end参数使得可以在字符串的特定部分进行查找。 - 区分大小写： 默认区分大小写。
示例：
“`python
text = “Python is fun, and Python is powerful.”
substring = “Python”
基本查找
index1 = text.find(substring)
print(f”‘{substring}’ 在 ‘{text}’ 中第一次出现的位置是: {index1}”) # 输出: 0
查找不存在的子串
index2 = text.find(“java”)
print(f”‘{‘java’}’ 在 ‘{text}’ 中第一次出现的位置是: {index2}”) # 输出: -1
指定查找范围
从索引 1 开始查找
index3 = text.find(substring, 1)
print(f”从索引 1 开始，'{substring}’ 第一次出现的位置是: {index3}”) # 输出: 19 (第二个 ‘Python’)
在指定范围内查找
index4 = text.find(“is”, 10, 20) # 在索引 10 到 19 之间查找 ‘is’
print(f”在索引 10 到 20 之间，'{‘is’}’ 第一次出现的位置是: {index4}”) # 输出: 10
在指定范围内查找，但不存在
index5 = text.find(“fun”, 20, 30)
print(f”在索引 20 到 30 之间，'{‘fun’}’ 第一次出现的位置是: {index5}”) # 输出: -1
“`
应用场景：
当你不仅需要判断字符串是否包含子串，还需要知道子串首次出现的位置时，或者当你需要在字符串的特定区域内进行查找时，find() 方法非常有用。通过检查返回值是否为 -1，你也可以变相实现判断是否存在的功能。
3. 使用 index() 方法：与 find() 类似但会引发错误
index() 方法与 find() 方法功能类似，也是用于查找子字符串第一次出现的索引。但它们在处理子字符串不存在的情况时有所不同。
基本语法：
python
main_string.index(sub_string, start, end)
参数：
sub_string: 要查找的子字符串。start(可选): 查找的起始索引，默认为 0。end(可选): 查找的结束索引（不包含），默认为字符串的长度。
功能：
在 main_string 的指定范围内查找 sub_string 第一次出现的索引。
返回值：
- 如果找到
sub_string，返回它在main_string中第一次出现的起始索引。 - 如果未找到
sub_string，则 引发ValueError异常。
特点：
- 提供位置信息： 同
find()。 - 未找到时引发
ValueError： 这是与find()的关键区别。如果你预期子字符串应该存在，并且它的缺失应该被视为一个错误，那么index()更适合。 - 支持指定查找范围： 同
find()。 - 区分大小写： 默认区分大小写。
示例：
“`python
text = “Python is fun.”
substring1 = “is”
substring2 = “java”
找到子串
index1 = text.index(substring1)
print(f”‘{substring1}’ 在 ‘{text}’ 中第一次出现的位置是: {index1}”) # 输出: 7
找不到子串，会引发 ValueError
try:
index2 = text.index(substring2)
print(f”‘{substring2}’ 在 ‘{text}’ 中第一次出现的位置是: {index2}”)
except ValueError as e:
print(f”查找 ‘{substring2}’ 时发生错误: {e}”) # 输出: 查找 ‘java’ 时发生错误: substring not found
“`
应用场景：
当你确信某个子字符串 一定 存在于主字符串中，并且如果它不存在，则表明程序逻辑有问题或数据异常时，使用 index() 方法可以利用其异常机制来处理这种情况。在使用 index() 时，通常会结合 try...except ValueError 块进行错误处理。
4. 使用 rfind() 和 rindex()：从右边开始查找
除了从左到右查找 (find(), index())，Python 还提供了从右到左查找子字符串的方法：rfind() 和 rindex()。
基本语法：
python
main_string.rfind(sub_string, start, end)
main_string.rindex(sub_string, start, end)
参数和功能与 find() 和 index() 类似，只是查找方向是从字符串的右端开始，返回的是子字符串 最后 一次出现的起始索引。
返回值：
rfind(): 如果找到，返回最后一次出现的起始索引；未找到，返回-1。rindex(): 如果找到，返回最后一次出现的起始索引；未找到，引发ValueError。
特点：
- 从右边开始查找： 适用于需要找到子字符串最后一次出现的位置的场景。
- 行为与
find()/index()对应：rfind()安全返回-1，rindex()未找到时引发异常。 - 支持指定查找范围： 注意这里的
start和end仍然是基于从左到右的索引。查找会在main_string[start:end]这个切片中从右往左进行。 - 区分大小写： 默认区分大小写。
示例：
“`python
text = “Python is fun, and Python is powerful. Python rocks!”
substring = “Python”
从右边查找，找到最后一次出现的位置
last_index_rfind = text.rfind(substring)
print(f”‘{substring}’ 在 ‘{text}’ 中最后一次出现的位置 (rfind): {last_index_rfind}”) # 输出: 44
try:
last_index_rindex = text.rindex(substring)
print(f”‘{substring}’ 在 ‘{text}’ 中最后一次出现的位置 (rindex): {last_index_rindex}”) # 输出: 44
except ValueError:
print(f”查找 ‘{substring}’ (rindex) 时未找到”)
从右边查找不存在的子串
last_index_rfind_notfound = text.rfind(“java”)
print(f”‘{‘java’}’ 在 ‘{text}’ 中最后一次出现的位置 (rfind): {last_index_rfind_notfound}”) # 输出: -1
try:
last_index_rindex_notfound = text.rindex(“java”)
print(f”‘{‘java’}’ 在 ‘{text}’ 中最后一次出现的位置 (rindex): {last_index_rindex_notfound}”)
except ValueError as e:
print(f”查找 ‘{‘java’}’ (rindex) 时发生错误: {e}”) # 输出: 查找 ‘java’ (rindex) 时发生错误: substring not found
指定范围从右边查找
在索引 0 到 30 之间从右往左查找 ‘is’
last_index_rfind_range = text.rfind(“is”, 0, 30)
print(f”在索引 0 到 30 之间，'{‘is’}’ 最后一次出现的位置 (rfind): {last_index_rfind_range}”) # 输出: 10
“`
应用场景：
当你需要找到某个子字符串在主字符串中最后一次出现的位置时，rfind() 或 rindex() 是首选方法。例如，查找一个文件路径字符串中最后一个斜杠的位置，以提取文件名。
5. 使用 startswith() 和 endswith()：检查前缀和后缀
虽然 in、find() 和 index() 可以用来判断是否包含任何位置的子字符串，但 Python 提供了更专门且高效的方法来检查字符串是否以某个前缀开始或以某个后缀结束。
基本语法：
python
main_string.startswith(prefix, start, end)
main_string.endswith(suffix, start, end)
参数：
prefix/suffix: 要检查的前缀/后缀。注意，这两个方法也可以接受一个 元组，元组中包含多个可能的前缀或后缀，只要匹配其中任何一个就返回True。start(可选): 从指定索引开始检查，默认为 0。end(可选): 检查到指定索引结束（不包含），默认为字符串的长度。
功能：
startswith(): 检查main_string（或其指定切片）是否以prefix开始。endswith(): 检查main_string（或其指定切片）是否以suffix结束。
返回值：
布尔值：如果匹配，返回 True；否则，返回 False。
特点：
- 高效： 对于检查字符串的开头或结尾，这两个方法通常比使用切片和
in或find()更高效和清晰。 - 支持元组： 可以方便地检查多种可能的前缀或后缀。
- 支持指定范围： 可以检查字符串的某个特定切片是否以某个前缀或后缀开始/结束。
- 区分大小写： 默认区分大小写。
示例：
“`python
filename = “document.txt”
url = “https://www.python.org”
检查前缀
print(f”‘{filename}’ 以 ‘doc’ 开头吗? {filename.startswith(‘doc’)}”) # 输出: True
print(f”‘{url}’ 以 ‘http’ 开头吗? {url.startswith(‘http’)}”) # 输出: True
print(f”‘{url}’ 以 ‘https’ 开头吗? {url.startswith(‘https’)}”) # 输出: True
print(f”‘{url}’ 以 ‘ftp’ 开头吗? {url.startswith(‘ftp’)}”) # 输出: False
检查后缀
print(f”‘{filename}’ 以 ‘.txt’ 结尾吗? {filename.endswith(‘.txt’)}”) # 输出: True
print(f”‘{filename}’ 以 ‘.csv’ 结尾吗? {filename.endswith(‘.csv’)}”) # 输出: False
print(f”‘{url}’ 以 ‘.org’ 结尾吗? {url.endswith(‘.org’)}”) # 输出: True
使用元组
print(f”‘{filename}’ 以 ‘.txt’ 或 ‘.doc’ 结尾吗? {filename.endswith((‘.txt’, ‘.doc’))}”) # 输出: True
print(f”‘{url}’ 以 ‘http://’ 或 ‘https://’ 开头吗? {url.startswith((‘http://’, ‘https://’))}”) # 输出: True
指定范围检查
print(f”‘{url}’ 的索引 8 到 14 (‘www.py’) 以 ‘www’ 开头吗? {url.startswith(‘www’, 8, 15)}”) # 输出: True
“`
应用场景：
当你需要判断文件名是否具有特定扩展名（如 .txt, .csv），判断 URL 是否使用 http 或 https 协议，或者处理任何需要检查字符串开头或结尾特征的场景时，startswith() 和 endswith() 是最适合的方法。
6. 使用正则表达式 re 模块：强大的模式匹配
对于更复杂的字符串查找需求，例如查找符合特定模式（而非固定子字符串）的内容，或者进行更灵活的匹配（如忽略大小写、查找多个可能的子串等），Python 的 re 模块（正则表达式）提供了强大的支持。
虽然正则表达式可以用来查找简单的子字符串，但对于本文讨论的“是否包含固定子字符串”的场景，使用前面的方法通常更简洁和高效。然而，了解如何使用 re 进行查找也是必要的。
使用 re.search() 函数可以查找字符串中是否包含匹配某个正则表达式模式的内容。
基本语法：
“`python
import re
re.search(pattern, string, flags)
“`
参数：
pattern: 要匹配的正则表达式模式（字符串）。string: 要搜索的字符串。flags(可选): 控制匹配行为的标志，如re.IGNORECASE（忽略大小写）。
功能：
扫描 string 查找第一个匹配 pattern 的位置。
返回值：
- 如果找到匹配项，返回一个
Match Object对象。 - 如果未找到匹配项，返回
None。
特点：
- 模式匹配： 极其灵活，可以查找复杂的模式，而不仅仅是固定子字符串。
- 功能强大： 支持分组、量词、边界匹配、前后查找等高级功能。
- 对于简单查找可能代码较长： 相较于
in或find()，导入模块和编写模式对于简单子串查找显得稍繁琐。 - 性能： 对于非常简单的子串查找，内置方法通常更快；对于复杂模式或大量文本处理，
re可能更高效。 - 默认区分大小写： 但可以通过
flags参数控制。
示例（简单包含）：
“`python
import re
text = “The quick brown fox.”
substring = “quick”
使用 re.search 查找固定子串
match = re.search(substring, text)
if match:
print(f”‘{text}’ 包含 ‘{substring}’ (使用 re.search)”) # 输出: ‘The quick brown fox.’ 包含 ‘quick’ (使用 re.search)
else:
print(f”‘{text}’ 不包含 ‘{substring}’ (使用 re.search)”)
查找不存在的子串
match_notfound = re.search(“zebra”, text)
if match_notfound:
print(f”‘{text}’ 包含 ‘{‘zebra’}’ (使用 re.search)”)
else:
print(f”‘{text}’ 不包含 ‘{‘zebra’}’ (使用 re.search)”) # 输出: ‘The quick brown fox.’ 不包含 ‘zebra’ (使用 re.search)
re.search 返回 Match Object，可以用 .start() 获取索引
if match:
print(f”‘{substring}’ 第一次出现的位置是: {match.start()}”) # 输出: ‘quick’ 第一次出现的位置是: 4
“`
示例（忽略大小写）：
“`python
import re
text = “Hello World”
substring = “world” # 注意大小写
默认是区分大小写的
match_case_sensitive = re.search(substring, text)
print(f”默认区分大小写查找 ‘{substring}’: {bool(match_case_sensitive)}”) # 输出: 默认区分大小写查找 ‘world’: False
使用 re.IGNORECASE 标志忽略大小写
match_case_insensitive = re.search(substring, text, re.IGNORECASE)
print(f”忽略大小写查找 ‘{substring}’: {bool(match_case_insensitive)}”) # 输出: 忽略大小写查找 ‘world’: True
“`
应用场景：
当你需要查找的“子字符串”是一个复杂的模式，或者需要进行不区分大小写、只匹配单词边界等更灵活的匹配时，re 模块是你的首选。对于简单的固定子串查找，除非有特定的需求（如忽略大小写且不使用 .lower() 的场景），否则通常建议使用内置方法。
7. 处理大小写不敏感的查找
前面提到的所有内置方法（in, find, index, startswith, endswith）默认都是区分大小写的。如果需要进行大小写不敏感的查找，最常用的方法是将主字符串和子字符串都转换为统一的大小写（通常是小写），然后再进行查找。
方法：
使用字符串的 .lower() 或 .upper() 方法。
示例：
“`python
text = “Python is Great!”
substring_mixed_case = “great” # 注意大小写
区分大小写 (False)
print(f”区分大小写查找 ‘{substring_mixed_case}’: {substring_mixed_case in text}”) # 输出: False
不区分大小写 (True) – 使用 .lower()
print(f”不区分大小写查找 ‘{substring_mixed_case}’: {substring_mixed_case.lower() in text.lower()}”) # 输出: True
使用 find() 不区分大小写
find_index_insensitive = text.lower().find(substring_mixed_case.lower())
print(f”不区分大小写查找 ‘{substring_mixed_case}’ 的位置: {find_index_insensitive}”) # 输出: 10
使用 startswith() 不区分大小写
prefix_mixed_case = “python”
print(f”不区分大小写检查前缀 ‘{prefix_mixed_case}’: {text.lower().startswith(prefix_mixed_case.lower())}”) # 输出: True
使用 re.search() 不区分大小写 (如前面示例所示)
import re
print(f”使用 re.search 忽略大小写查找 ‘{substring_mixed_case}’: {bool(re.search(substring_mixed_case, text, re.IGNORECASE))}”) # 输出: 使用 re.search 忽略大小写查找 ‘great’: True
“`
将字符串转换为统一大小写后再进行查找是一种非常常见且有效的方式来实现大小写不敏感的包含判断。
8. 总结：选择合适的方法
Python 为字符串查找包含提供了多种工具，选择哪种方法取决于你的具体需求：
-
in运算符：- 用途： 最简单、最直观地判断一个子字符串是否存在于主字符串中。
- 特点： 只返回布尔值，代码简洁。
- 适用场景： 只关心是否存在，不关心位置。
-
find()方法：- 用途： 查找子字符串第一次出现的索引。
- 特点： 返回索引，未找到返回
-1，不会出错。支持指定查找范围。 - 适用场景： 需要知道子串位置，或不确定子串是否存在时（避免异常）。
-
index()方法：- 用途： 查找子字符串第一次出现的索引。
- 特点： 返回索引，未找到引发
ValueError。支持指定查找范围。 - 适用场景： 预期子串一定存在，将其缺失视为错误情况处理。
-
rfind()和rindex()方法：- 用途： 从右边查找子字符串最后一次出现的索引。
- 特点：
rfind()返回索引或-1；rindex()返回索引或引发ValueError。 - 适用场景： 需要找到子串最后一次出现的位置。
-
startswith()和endswith()方法：- 用途： 专门检查字符串是否以某个前缀开始或以某个后缀结束。
- 特点： 高效，支持元组检查多个前缀/后缀。
- 适用场景： 检查固定的开头或结尾。
-
re模块 (re.search())：- 用途： 强大的模式匹配工具。
- 特点： 支持复杂模式查找，可以通过标志控制行为（如忽略大小写）。
- 适用场景： 查找复杂的模式，或者需要进行灵活匹配（如忽略大小写且不方便统一大小写）。
通常来说，对于简单的“是否包含”判断，优先使用 in 运算符，因为它最直观易读。如果需要位置信息，使用 find() 或 index()。对于前缀/后缀检查，使用 startswith()/endswith()。只有当需求超越了固定子字符串的查找，需要进行更复杂的模式匹配时，才考虑使用 re 模块。
处理大小写不敏感查找时，最通用的方法是将字符串转换为统一大小写后再使用上述任一方法，或者对于复杂模式使用 re.IGNORECASE 标志。
掌握这些方法，你就能在 Python 中游刃有余地处理各种字符串包含查找的需求了。