python怎么在字符串中查找子字符串_python字符串查找方法详解

下次还敢

发布时间：2025-09-12 18:46:01

565人浏览过

来源于php中文网

原创

答案：Python中查找子字符串最简洁的方法是使用in操作符，它返回布尔值表示是否存在；若需获取位置可用find()或index()，前者未找到时返回-1，后者抛出异常；统计次数用count()；复杂模式匹配则推荐re模块。

python怎么在字符串中查找子字符串_python字符串查找方法详解

Python在字符串中查找子字符串的方法非常丰富且灵活，从简单的存在性判断到复杂模式匹配，你总能找到一个趁手的工具。核心方法包括利用

in

操作符进行快速布尔检查，使用

find()

或

index()

获取子字符串的起始位置，以及

count()

来统计出现次数，当然，如果需要更高级的模式匹配，

re

模块（正则表达式）则是不可或缺的利器。选择哪种方法，很大程度上取决于你的具体需求：是只需要知道有没有，还是要精确位置，或者需要匹配某种模式。

解决方案

说实话，在Python里处理字符串查找，我个人觉得是件挺舒服的事，因为它提供了太多直观的API。我们来一步步看看这些方法，以及我通常会怎么选择它们。

首先，最基础也是最常用的，就是

in

操作符。这玩意儿简单粗暴，直接告诉你一个子字符串在不在另一个字符串里，返回一个布尔值。比如：

main_string = "Hello, world! This is a test."
sub_string = "world"
sub_string_not_found = "python"

print(sub_string in main_string)        # 输出: True
print(sub_string_not_found in main_string) # 输出: False

它不给你位置，也不告诉你出现了多少次，就一个“是”或“否”，但很多时候，这已经足够了。

立即学习“Python免费学习笔记（深入）”；

接下来，如果你不仅想知道“有没有”，还想知道“在哪里”，那么

str.find()

方法就派上用场了。它会返回子字符串第一次出现的起始索引。如果没找到，它会很“友好”地返回

-1

。这在我看来，是个非常安全的设计，你不需要额外处理异常。

main_string = "Python programming is fun. Python is versatile."
sub_string = "Python"
sub_string_not_found = "Java"

print(main_string.find(sub_string))           # 输出: 0 (第一个'P'的索引)
print(main_string.find("is"))                 # 输出: 19 (第一个'is'的索引)
print(main_string.find(sub_string_not_found)) # 输出: -1

# 你还可以指定搜索的起始和结束位置
print(main_string.find("Python", 1))          # 从索引1开始找，找到第二个'Python'，输出: 27
print(main_string.find("is", 20, 30))         # 在索引20到29之间找'is'，输出: 22

与

find()

异曲同工的，是str.index()
。它也返回子字符串第一次出现的起始索引。但它有个“脾气”：如果没找到子字符串，它会抛出一个

ValueError

异常。所以，如果你非常确定子字符串肯定存在，或者你希望在找不到时程序能够报错并被捕获，那么

index()

会更合适。

main_string = "Learning Python is great."
sub_string = "Python"
sub_string_not_found = "Ruby"

print(main_string.index(sub_string)) # 输出: 9

try:
    print(main_string.index(sub_string_not_found))
except ValueError as e:
    print(f"出错了: {e}") # 输出: 出错了: substring not found

有时候，我们不想要第一次出现的位置，而是想知道最后一次出现的位置。这时候，

str.rfind()

和str.rindex()
就登场了。它们的工作方式和

find()

、

index()

类似，只不过是从字符串的右侧（或者说从末尾）开始查找，返回的依然是子字符串在原字符串中的起始索引。

main_string = "banana is a yellow fruit, banana is tasty."
print(main_string.rfind("banana")) # 输出: 29
print(main_string.rindex("is"))   # 输出: 26

如果你想知道一个子字符串出现了多少次，

str.count()

方法就是你的不二之选。它会返回子字符串在主字符串中非重叠出现的次数。

main_string = "abracadabra, abracadabra!"
print(main_string.count("abra")) # 输出: 2
print(main_string.count("a"))    # 输出: 8

最后，当你的查找需求变得复杂，比如要匹配某种模式（例如，所有以数字开头的单词，或者特定的日期格式），那么Python的

re

模块（正则表达式）就成了你的超级英雄。它提供了强大的模式匹配能力，远超简单的字面量查找。

import re

text = "My phone number is 123-456-7890. Call me at 987-654-3210."
# 查找所有电话号码模式
phone_numbers = re.findall(r'\d{3}-\d{3}-\d{4}', text)
print(phone_numbers) # 输出: ['123-456-7890', '987-654-3210']

# 查找第一个匹配项
match = re.search(r'phone number is (\d{3}-\d{3}-\d{4})', text)
if match:
    print(f"第一个电话号码是: {match.group(1)}") # 输出: 第一个电话号码是: 123-456-7890

re

模块的功能非常强大，从

re.search()

（找到第一个匹配项）、

re.findall()

（找到所有非重叠匹配项）、

re.finditer()

（返回一个迭代器，包含所有匹配项的详细信息）到

re.sub()

（替换匹配项），几乎能满足所有复杂的字符串模式处理需求。当然，它的学习曲线会稍微陡峭一些，但投入绝对是值得的。

Python中判断子字符串是否存在最简洁的方法是什么？

要判断一个子字符串是否存在于另一个字符串中，最简洁、最Pythonic的方法无疑是使用

in

操作符。这玩意儿写起来简单，读起来也一目了然，完全符合Python的“可读性优先”哲学。它直接返回一个布尔值（

True

或

False

），不需要你处理索引，也不需要捕获异常，非常适合做快速的存在性检查。

sentence = "The quick brown fox jumps over the lazy dog."

# 检查是否存在 "fox"
if "fox" in sentence:
    print("找到了狐狸！") # 输出: 找到了狐狸！

# 检查是否存在 "cat"
if "cat" not in sentence:
    print("没有找到猫。") # 输出: 没有找到猫。

我个人在日常编码中，如果仅仅是想知道某个元素是否在集合（包括字符串、列表、元组等）中，几乎都会下意识地用

in

。它不仅效率高，而且语义清晰，让代码更易于理解。如果你不需要知道子字符串的具体位置，也不关心它出现了多少次，那么

in

就是你的首选。它的缺点也很明显，就是无法提供位置信息，如果你需要位置，就得考虑其他方法了。

如何获取子字符串在主字符串中的具体位置？

find()

和

index()

有什么区别？

要获取子字符串在主字符串中的具体位置，Python主要提供了

str.find()

和

str.index()

这两个方法。它们都能返回子字符串第一次出现的起始索引，但处理未找到子字符串的情况时，它们的行为截然不同，这正是它们之间最核心的区别，也是我们在选择时需要权衡的地方。

str.find(sub[, start[, end]])

功能： 返回子字符串
```
sub
```
在原字符串中第一次出现的索引。
未找到时的行为： 如果子字符串未找到，它会返回
```
-1
```
。
优点： 安全，不会中断程序流程，适合在不确定子字符串是否存在时使用。
缺点： 你需要手动检查返回值是否为
```
-1
```
。

text = "Python is a great language, Python is widely used."
position1 = text.find("great")
position2 = text.find("Java")
position3 = text.find("Python", 10) # 从索引10开始查找

print(f"'great' 的位置: {position1}") # 输出: 'great' 的位置: 12
print(f"'Java' 的位置: {position2}")  # 输出: 'Java' 的位置: -1
print(f"从索引10开始找 'Python' 的位置: {position3}") # 输出: 从索引10开始找 'Python' 的位置: 25

str.index(sub[, start[, end]])

功能： 返回子字符串
```
sub
```
在原字符串中第一次出现的索引。
未找到时的行为： 如果子字符串未找到，它会抛出一个
```
ValueError
```
异常。
优点： 当你确信子字符串应该存在时，它能快速地让你知道程序逻辑是否有误，可以结合
```
try-except
```
块进行错误处理。
缺点： 如果不处理异常，程序可能会崩溃。

text = "Data science with Python is fascinating."
position_python = text.index("Python")
print(f"'Python' 的位置: {position_python}") # 输出: 'Python' 的位置: 17

try:
    position_r = text.index("R")
    print(f"'R' 的位置: {position_r}")
except ValueError as e:
    print(f"捕获到错误: {e}") # 输出: 捕获到错误: substring not found

何时选择？

选择
find()
：如果你不确定子字符串是否存在，或者你希望在找不到时程序能继续执行，并根据
```
-1
```
这个返回值来做后续判断，那么
```
find()
```
是更稳妥的选择。
选择
index()
：如果你期望子字符串一定存在，并且在它不存在时，你希望程序能立即报错并终止当前操作（或者通过异常处理机制跳转到备用逻辑），那么
```
index()
```
更符合你的需求。在我看来，
```
index()
```
更适合作为一种“断言”：我断言这个子字符串应该在这里，如果不在，那就是个问题。

这两个方法都支持可选的

start

和

end

参数，允许你在字符串的特定切片内进行查找，这在处理大字符串或分段查找时非常有用。

唱鸭

音乐创作全流程的AI自动作曲工具，集 AI 辅助作词、AI 自动作曲、编曲、混音于一体

下载

如果我想查找子字符串的所有出现次数或更复杂的模式，应该怎么做？

当你的需求从简单的“有没有”或“在哪里”升级到“有多少个”或“符合某种模式的所有匹配项”，Python的

str.count()

方法和强大的

re

模块（正则表达式）就成了你的主要工具。

1. 统计子字符串的出现次数：

str.count()

如果你只是想知道一个特定的子字符串在主字符串中出现了多少次，

str.count()

是最直接也最有效的方法。它会返回子字符串非重叠出现的次数。

document = "Apple is a fruit. I like apple. Apple pie is delicious."
print(f"'Apple' 出现了 {document.count('Apple')} 次。") # 输出: 'Apple' 出现了 2 次。
print(f"'apple' 出现了 {document.count('apple')} 次。") # 输出: 'apple' 出现了 1 次。
print(f"'is' 出现了 {document.count('is')} 次。")      # 输出: 'is' 出现了 3 次。

# 注意：count方法是区分大小写的。

count()

方法同样支持可选的

start

和

end

参数，让你可以在字符串的某个范围内统计出现次数。

long_text = "one two one three one four"
print(long_text.count("one", 5, 20)) # 在索引5到19之间查找'one'，输出: 1 (只找到'one three'中的那个'one')

2. 查找更复杂的模式或所有匹配项：

re

模块 (正则表达式)

当你的查找需求超越了简单的字面量匹配，比如你需要：

查找所有电话号码、邮箱地址。
查找所有以特定前缀或后缀开头的单词。
查找所有符合某种日期格式的字符串。
忽略大小写进行匹配。

这时候，就该请出

re

模块了。它通过正则表达式（Regular Expressions）提供了一种强大的、灵活的文本模式匹配语言。

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

这是我最常用的一种模式，它会找到字符串中所有与

pattern

匹配的非重叠子字符串，并以列表的形式返回它们。

import re

log_data = "Error: File not found (code 404). Warning: Low disk space. Error: Network timeout (code 500)."
# 查找所有错误代码
error_codes = re.findall(r'code (\d{3})', log_data)
print(f"所有错误代码: {error_codes}") # 输出: 所有错误代码: ['404', '500']

# 查找所有单词（忽略大小写）
words = re.findall(r'\b\w+\b', log_data.lower())
print(f"所有单词: {words}") # 输出: 所有单词: ['error', 'file', 'not', 'found', 'code', '404', 'warning', 'low', 'disk', 'space', 'error', 'network', 'timeout', 'code', '500']

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

如果你只需要找到第一个匹配项，

re.search()

会返回一个

Match object

。如果没有找到，则返回

None

。

Match object

包含了匹配的详细信息，比如匹配的起始和结束位置、匹配到的具体字符串以及捕获组等。

text = "The price is $12.99, but on sale for $9.50."
match = re.search(r'\$\d+\.\d{2}', text) # 查找第一个货币金额

if match:
    print(f"第一个金额: {match.group(0)}") # group(0)是整个匹配到的字符串，输出: 第一个金额: $12.99
    print(f"起始位置: {match.start()}, 结束位置: {match.end()}") # 输出: 起始位置: 13, 结束位置: 19

match_none = re.search(r'€\d+', text) # 查找欧元符号，不存在
print(f"查找欧元金额: {match_none}") # 输出: 查找欧元金额: None

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

这个方法返回一个迭代器，其中包含了所有匹配项的

Match object

。当处理非常大的字符串或需要对每个匹配项进行复杂操作时，

finditer()

比

findall()

更节省内存。

import re

code_snippet = "def func_a(): pass\nclass MyClass:\n    def method_b(): pass\ndef func_c(): pass"
# 查找所有函数或方法的定义
for match in re.finditer(r'(def|class)\s+(\w+)\s*\(.*?\):', code_snippet):
    print(f"类型: {match.group(1)}, 名称: {match.group(2)}")
# 输出:
# 类型: def, 名称: func_a
# 类型: class, 名称: MyClass
# 类型: def, 名称: method_b
# 类型: def, 名称: func_c

正则表达式的标志 (Flags):

re

模块还支持一些标志来修改匹配行为，比如：

```
re.IGNORECASE
```
或
```
re.I
```
: 忽略大小写。
```
re.MULTILINE
```
或
```
re.M
```
: 使
```
^
```
和
```
$
```
匹配每一行的开头和结尾，而不仅仅是整个字符串的开头和结尾。
```
re.DOTALL
```
或
```
re.S
```
: 使
```
.
```
匹配包括换行符在内的所有字符。

text_case_insensitive = "Python is great. python is powerful."
matches = re.findall(r'python', text_case_insensitive, re.IGNORECASE)
print(f"忽略大小写查找 'python': {matches}") # 输出: 忽略大小写查找 'python': ['Python', 'python']

总而言之，对于简单的计数，