Python怎么判断字符串是否包含子串_Python子串检查方法详解-Python教程-PHP中文网

答案：Python中判断字符串是否包含子串最常用in操作符，若需位置信息可用find()或index()，复杂模式匹配推荐re模块；大小写不敏感场景可统一转小写或使用re.IGNORECASE。

python怎么判断字符串是否包含子串_python子串检查方法详解

在Python里判断一个字符串是否包含另一个子串，其实方法不少，最直接、最Pythonic的莫过于使用

in

登录后复制

操作符。它能快速告诉你答案是

True

登录后复制

还是

False

登录后复制

，省心又高效。当然，如果你的需求更复杂，比如需要知道子串出现的位置，或者需要进行更高级的模式匹配，Python也提供了

find()

登录后复制

、

index()

登录后复制

方法，以及强大的

re

登录后复制

模块来应对。选择哪种，主要看你具体想要什么。

解决方案

在Python中检查字符串是否包含子串，主要有以下几种方法，每种都有其适用场景：

使用
```
in
```
登录后复制
操作符 这是最简洁、最推荐的方法，当只需要判断子串是否存在时，它返回一个布尔值。
```
main_string = "Hello, world! This is Python."
substring_1 = "world"
substring_2 = "Java"

print(substring_1 in main_string) # 输出: True
print(substring_2 in main_string) # 输出: False
```
登录后复制
我个人觉得，对于大多数“有没有”的问题，
```
in
```
登录后复制
操作符简直是神来之笔，代码读起来一目了然。
使用
```
str.find()
```
登录后复制
方法如果你不仅想知道子串是否存在，还想知道它首次出现的位置，
```
find()
```
登录后复制
方法就派上用场了。它返回子串在原字符串中首次出现的索引。如果找不到，它会返回
```
-1
```
登录后复制
。
```
main_string = "The quick brown fox jumps over the lazy dog."
substring = "fox"
not_found_substring = "cat"

print(main_string.find(substring)) # 输出: 19 (f的索引)
print(main_string.find(not_found_substring)) # 输出: -1
```
登录后复制
这个方法的好处是，即使找不到也不会抛出错误，你可以很优雅地处理找不到的情况。

立即学习“Python免费学习笔记（深入）”；
使用
```
str.index()
```
登录后复制
方法
```
index()
```
登录后复制
方法和
```
find()
```
登录后复制
很像，也是返回子串首次出现的索引。但关键区别在于，如果子串没有找到，
```
index()
```
登录后复制
会抛出一个
```
ValueError
```
登录后复制
异常。
```
main_string = "Python programming is fun."
substring = "programming"

try:
    print(main_string.index(substring)) # 输出: 7 (p的索引)
    print(main_string.index("Java"))
except ValueError as e:
    print(f"子串未找到: {e}") # 输出: 子串未找到: substring not found
```
登录后复制
在我看来，
```
index()
```
登录后复制
更适合那些你“预期”子串一定会存在，如果不存在就说明程序逻辑出了问题，需要立即报错的场景。
使用
```
re
```
登录后复制
模块（正则表达式） 当你的子串检查需求变得复杂，比如需要匹配某种模式而不是固定的字符串，或者需要进行不区分大小写的匹配，那么Python的
```
re
```
登录后复制
模块（正则表达式）就是你的利器了。
```
import re

main_string = "My email is test@example.com."
# 匹配一个简单的邮箱模式
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"

if re.search(pattern, main_string):
    print("找到了邮箱地址。")
else:
    print("未找到邮箱地址。")

# 简单的子串匹配也可以用re
if re.search("email", main_string):
    print("找到了'email'这个词。")
```
登录后复制
正则表达式的灵活性非常高，但学习曲线相对陡峭一些，不过一旦掌握，很多复杂的文本匹配问题都能迎刃而解。

Python中检查子串时，大小写敏感性如何处理？

这是一个非常常见的问题，因为默认情况下，Python的字符串比较操作（包括

in

登录后复制

、

find()

登录后复制

、

index()

登录后复制

）都是大小写敏感的。也就是说，

"Python"

登录后复制

和

"Python"

登录后复制

在Python看来是完全不同的两个东西。

如果你需要进行不区分大小写的子串检查，有几种方法可以实现：

将原字符串和子串都转换为统一大小写 这是最直接也最常用的方法。通常我们会选择都转换为小写，因为这样写起来比较方便，也符合大多数人的习惯。

main_string = "Python Programming Is Fun"
substring_lower = "python"
substring_mixed = "programming"

# 转换为小写后再比较
print(substring_lower.lower() in main_string.lower()) # 输出: True
print(substring_mixed.lower() in main_string.lower()) # 输出: True

# 也可以用find()
print(main_string.lower().find(substring_lower.lower())) # 输出: 0

登录后复制

这种方法简单粗暴，效果很好，而且对性能影响不大。

使用

re

登录后复制

模块并设置
re.IGNORECASE
登录后复制
标志当使用正则表达式进行匹配时，你可以通过传递

re.IGNORECASE

登录后复制

（或

re.I

登录后复制

）标志来忽略大小写。这对于更复杂的模式匹配尤其有用。

import re

main_string = "Python is a versatile language."
pattern = "python" # 注意这里模式可以是小写

# 使用re.IGNORECASE标志进行不区分大小写的匹配
if re.search(pattern, main_string, re.IGNORECASE):
    print(f"在 '{main_string}' 中找到了 '{pattern}' (不区分大小写)。")
else:
    print("未找到。")

# 也可以结合re.findall()等
matches = re.findall(pattern, main_string, re.IGNORECASE)
print(f"所有匹配项: {matches}") # 输出: 所有匹配项: ['Python']

登录后复制

如果你的匹配模式本身就比较复杂，或者需要同时处理多种匹配条件，那么正则表达式结合

re.IGNORECASE

登录后复制

是更强大的选择。

INFINITE ALBUM

面向游戏玩家的生成式AI音乐

144

查看详情

什么时候应该使用

in

登录后复制

操作符，什么时候考虑

find()

登录后复制

或

index()

登录后复制

？

这个问题其实挺关键的，因为它涉及到代码的意图和健壮性。

使用
```
in
```
登录后复制
操作符：
- 当你只关心子串是否存在时。 这是
```
in
```
  登录后复制
  操作符最核心的用途。比如，你只想知道一个句子中是否提到了某个关键词，而不需要知道它在哪里。
- 追求代码简洁性和可读性。
```
if "sub" in "main_string":
```
  登录后复制
  这种写法非常直观，几乎不需要额外解释。
- 作为首选方案。 在我看来，如果你没有特别的需求，总是先考虑
```
in
```
  登录后复制
  操作符。它通常是最高效且最Pythonic的。
使用
```
str.find()
```
登录后复制
方法：
- 当你需要子串首次出现的位置时。 比如，你找到一个分隔符后，想从那个位置开始截取字符串的剩余部分。
- 你希望在子串不存在时程序能够继续执行，而不是中断。
```
find()
```
  登录后复制
  返回
```
-1
```
  登录后复制
  的特性让你可以很方便地用
```
if result != -1:
```
  登录后复制
  这样的条件来处理找不到的情况，而不会让程序崩溃。这对于那些子串存在是“可选”的场景非常有用。
- 需要指定搜索的起始和结束位置。
```
find()
```
  登录后复制
  方法允许你传递
```
start
```
  登录后复制
  和
```
end
```
  登录后复制
  参数，限制搜索范围，这在处理局部字符串时很有用。
使用
```
str.index()
```
登录后复制
方法：
- 当你“预期”子串一定会存在，并且它的缺失应该被视为一个错误时。 比如，你的程序依赖于某个特定标识符的存在，如果它不存在，后续操作就无法进行，这时抛出
```
ValueError
```
  登录后复制
  能让你迅速发现问题。
- 在调试阶段，快速定位问题。 有时候，如果一个子串没有按预期出现，
```
index()
```
  登录后复制
  的异常能帮你更快地找到问题根源。
- 同样需要子串首次出现的位置，但对找不到的情况要求更严格。 它的用途和
```
find()
```
  登录后复制
  类似，但错误处理机制不同。

简单来说，如果你的问题是“是或否”，用

in

登录后复制

。如果你的问题是“在哪里，并且找不到也没关系”，用

find()

登录后复制

。如果你的问题是“在哪里，并且找不到就是个大问题”，用

index()

登录后复制

。

如何在Python中查找所有匹配的子串及其位置？

仅仅知道子串是否存在或者第一次出现的位置，很多时候是不够的。如果一个字符串中可能包含多个相同的子串，并且你需要获取所有这些子串的出现位置，或者它们本身，那么我们就需要更高级的工具了。

通过循环结合

str.find()

登录后复制

（略显繁琐但可行） 虽然

find()

登录后复制

默认只返回第一个匹配项，但我们可以通过指定搜索的起始位置来模拟查找所有匹配。

main_string = "banana_apple_banana_orange_banana"
substring = "banana"
found_indices = []
start_index = 0

while True:
    index = main_string.find(substring, start_index)
    if index == -1:
        break # 没找到就退出循环
    found_indices.append(index)
    start_index = index + len(substring) # 从当前匹配的子串之后开始搜索

print(f"子串 '{substring}' 在以下位置被找到: {found_indices}")
# 输出: 子串 'banana' 在以下位置被找到: [0, 13, 29]

登录后复制

这种方法虽然能实现，但代码写起来稍微有点绕，容易出错，而且如果子串很短，或者有重叠匹配的需求，处理起来会更复杂。

使用
```
re
```
登录后复制
模块的
re.finditer()
登录后复制
方法这是我个人非常推荐的方法，尤其当你需要获取所有匹配项的详细信息（如位置、匹配内容）时。
```
re.finditer()
```
登录后复制
会返回一个迭代器，其中包含所有非重叠匹配的
```
Match
```
登录后复制
对象。每个
```
Match
```
登录后复制
对象都包含了匹配的起始位置、结束位置以及匹配到的具体内容。
```
import re

main_string = "Python is great. python is powerful. PYTHON is everywhere."
pattern = "python"

# 使用re.IGNORECASE进行不区分大小写的全局查找
for match in re.finditer(pattern, main_string, re.IGNORECASE):
    print(f"匹配到: '{match.group()}'，起始位置: {match.start()}，结束位置: {match.end()}")
# 输出:
# 匹配到: 'Python'，起始位置: 0，结束位置: 6
# 匹配到: 'python'，起始位置: 16，结束位置: 22
# 匹配到: 'PYTHON'，起始位置: 36，结束位置: 42
```
登录后复制
```
re.finditer()
```
登录后复制
的强大之处在于它返回的是
```
Match
```
登录后复制
对象，你可以从中提取出非常多的信息，比如
```
match.group()
```
登录后复制
获取匹配的字符串，
```
match.start()
```
登录后复制
获取起始索引，
```
match.end()
```
登录后复制
获取结束索引等。这对于后续的数据处理非常方便。

使用

re

登录后复制

模块的
re.findall()
登录后复制
方法如果你只关心所有匹配到的子串本身，而不需要它们的具体位置，那么

re.findall()

登录后复制

会更简洁。它直接返回一个包含所有非重叠匹配字符串的列表。

import re

main_string = "The quick brown fox jumps over the lazy fox and another fox."
pattern = "fox"

all_foxes = re.findall(pattern, main_string)
print(f"所有找到的 '{pattern}'：{all_foxes}") # 输出: 所有找到的 'fox'：['fox', 'fox', 'fox']

# 结合re.IGNORECASE
main_string_case = "Apple, apple pie, APPLE juice."
pattern_case = "apple"
all_apples = re.findall(pattern_case, main_string_case, re.IGNORECASE)
print(f"所有找到的 '{pattern_case}' (不区分大小写)：{all_apples}")
# 输出: 所有找到的 'apple' (不区分大小写)：['Apple', 'apple', 'APPLE']

登录后复制