在 Python 字符串中查找第一次、最后一次或第 N 次出现的索引

作者

目录

Find index of first occurrence of substring in Python String

  1. 在 Python String 中查找 First occurrence of substring 的索引
  2. 在 Python 字符串中查找最后一次出现的子字符串的索引
  3. 在 Python 中查找字符串中第 N 次出现的子字符串
  4. 在 Python 中查找第一个非空白字符的索引

查找 Python 字符串中第一次出现的子字符串的索引

使用该str.find()方法查找字符串中子字符串第一次出现的索引。

该str.find()方法返回字符串中提供的子字符串第一次出现的索引，或者-1如果子字符串不存在于字符串中。

主程序
my_str = 'apple, avocado'

index = my_str.find('a')
print(index)  # 👉️ 0

str.find方法返回字符串中提供的子字符串第一次出现的索引。

主程序
print('test'.find('t')) # 👉️ 0
-1如果在字符串中找不到子字符串，则该方法返回。

您可以使用语句处理字符串中不存在子字符串的情况if/else。

主程序
my_str = 'apple, avocado'

index = my_str.find('a')

if index != -1:
    print(my_str[index]) # 👉️ 'a'
else:
    raise IndexError('Provided substring not in string')

查找第一次出现的索引使用str.index

或者，您可以使用该str.index()方法。

主程序
my_str = 'apple, avocado'

index = my_str.index('a')
print(index)  # 👉️ 0

str.index方法返回字符串中提供的子字符串第一次出现的
索引。

ValueError如果在字符串中找不到子字符串，则该方法会引发 a 。

主程序
my_str = 'apple, avocado'


# ⛔️ ValueError: substring not found
index = my_str.index('z')
该str.index()方法与 非常相似str.find() ，但它会引发ValueError，而不是-1在字符串中不存在子字符串时返回。

如果您需要以任何方式处理错误，您可以使用
try/except 块。

主程序
my_str = 'apple, avocado'

try:
    index = my_str.index('z')
except ValueError:
    # 👇️ this runs
    print('provided substring not in string')

pass如果您只想忽略错误，可以使用该语句。

主程序
my_str = 'apple, avocado'

try:
    index = my_str.index('z')
except ValueError:
    # 👇️ this runs
    pass

pass语句什么都不做，当语法上需要语句但程序不需要任何操作时使用。

查找 Python 字符串中最后一次出现的子字符串的索引

使用该str.rfind()方法查找字符串中子字符串的最后一次出现。

该rfind()方法返回在字符串中找到提供的子字符串的最高索引。

主程序
my_str = 'apple, apricot'

index = my_str.rfind('a')
print(index)  # 👉️ 7

我们使用该str.rfind()方法获取字符串中最后一次出现的字符的索引。

str.rfind
方法返回字符串中找到提供的子字符串的最高索引。

主程序
print('test'.rfind('t')) # 👉️ 3

-1如果子字符串不包含在字符串中，则该方法返回。

您可以使用语句处理字符串中不存在子字符串的情况if/else。

主程序
my_str = 'apple, apricot'

index = my_str.rfind('a')

if index != -1:
    result = my_str[index:]
else:
    result = my_str

print(result)  # 👉️ 'apricot'

您还可以在块中引发异常else。

主程序
my_str = 'apple, apricot'

index = my_str.rfind('Z')

if index != -1:
    result = my_str[index:]
else:
    # 👇️ this runs
    raise IndexError('Provided character not in string')

查找最后一次出现的索引使用str.rindex

或者，您可以使用该str.rindex()方法。

主程序
my_str = 'apple, apricot'

index = my_str.rindex('a')
print(index)  # 👉️ 7

str.rindex
方法返回字符串中找到提供的子字符串的最高索引。

主程序
print('test'.rindex('t')) # 👉️ 3

ValueError当在字符串中找不到提供的子字符串时，该方法将引发。

主程序
my_str = 'apple, apricot'

# ⛔️ ValueError: substring not found
index = my_str.rindex('z')
该str.rindex()方法与 非常相似，但它会引发，而不是在字符串中不存在子字符串时返回。 str.rfind()ValueError-1

try/except如果您需要以任何方式处理错误，您可以使用块。

主程序
my_str = 'apple, apricot'

try:
    index = my_str.rindex('z')
except ValueError:
    # 👇️ this runs
    print('specified substring not in string')

pass如果您只想忽略错误，可以使用该语句。

主程序
my_str = 'apple, apricot'

try:
    index = my_str.rindex('z')
except ValueError:
    # 👇️ this runs
    pass

pass语句什么都不做，当语法上需要语句但程序不需要任何操作时使用。

在Python中查找String中第N次出现的Substring

要查找字符串中第 N 次出现的子字符串：

  1. 使用该str.find()方法查找第一个匹配项。
  2. 使用while循环迭代直到找到第 N 次出现。
  3. 使用str.find()带有start索引的方法来查找第 N 次出现。
主程序
def find_nth_occurrence(string, substring, n):
    start = string.find(substring)

    while start >= 0 and n > 1:
        start = string.find(substring, start + 1)
        n -= 1

    return start


print(find_nth_occurrence('one one one', 'one', 2))  # 👉️ 4
print(find_nth_occurrence('one one one', 'one', 3))  # 👉️ 8

我们使用该str.find()方法来查找字符串中子字符串的第一次出现。

str.find方法返回字符串中提供的子字符串第一次出现的索引。

主程序
print('one one one'.find('one')) # 👉️ 0

-1如果在字符串中找不到子字符串，则该方法返回。

该str.find()方法可以选择传递第二个参数——start
索引。

如果start指定了索引，该find()方法将开始在指定索引处查找子字符串。

我们的while循环检查start值是否大于或等于，0
因为如果子字符串不包含在字符串中则str.find()返回。-1

主程序
while start >= 0 and n > 1:
    start = string.find(substring, start + 1)
    n -= 1

我们还检查是否n大于，1因为如果消费者需要第一次出现的索引，则无需迭代。

在每次迭代中，我们将start索引增加 以1查找下一次出现并n减少1.

如果字符串中第 N 次出现的子字符串不存在，-1则返回。

主程序
def find_nth_occurrence(string, substring, n):
    start = string.find(substring)

    while start >= 0 and n > 1:
        start = string.find(substring, start + 1)
        n -= 1

    return start


print(find_nth_occurrence('one one one', 'one', 10))  # 👉️ -1

我们仅将start索引递增以1找到下一个匹配项，因此该函数可能会返回字符串中子字符串第 N 次重叠出现的索引。

主程序
def find_nth_occurrence(string, substring, n):
    start = string.find(substring)

    while start >= 0 and n > 1:
        start = string.find(substring, start + 1)
        n -= 1

    return start

# 👇️ 4
print(
    find_nth_occurrence('one one one one', 'one one', 2)
)

查找字符串中第 N 个不重叠的事件

如果需要获取子字符串第 N 次非重叠出现的索引，则在确定索引时使用子字符串的长度start。

主程序
def find_nth_occurrence(string, substring, n):
    start = string.find(substring)

    while start >= 0 and n > 1:
        start = string.find(substring, start + len(substring))
        n -= 1

    return start

# 👇️ 8
print(
    find_nth_occurrence('one one one one', 'one one', 2)
)

我们没有添加1到start索引，而是添加了子字符串的长度。

使用 str.split() 在 String 中找到第 N 次出现的 Substring

这是一个两步过程：

  1. 使用该str.split()方法将字符串拆分 N 次。
  2. 从字符串的长度中减去子字符串的长度和列表最后一个元素的长度。
主程序
def find_nth_occurrence(string, substring, n):
    parts = string.split(substring, n)
    print(parts)

    if len(parts) <= n:
        return -1

    return len(string) - len(substring) - len(parts[-1])


print(find_nth_occurrence('one two one two one', 'one', 2))  # 👉️ 8
print(find_nth_occurrence('one two one two one', 'one', 3))  # 👉️ 16

我们使用该str.split()方法将一个字符串最多拆分 N 次。

str.split ()方法使用分隔符将字符串拆分为子字符串列表。

该方法采用以下 2 个参数：

姓名 描述
分隔器 在每次出现分隔符时将字符串拆分为子字符串
最大分裂 最多maxsplit完成拆分（可选）
主程序
# 👇️ ['', ' two ', ' two one']
print('one two one two one'.split('one', 2))

我们只在子字符串上将字符串拆分两次。

列表中的最后一项包含字符串的其余部分。

如果列表包含少于或等于N项，则子字符串未在字符串中包含 N 次，我们返回-1。

主程序
def find_nth_occurrence(string, substring, n):
    parts = string.split(substring, n)
    print(parts)

    if len(parts) <= n:
        return -1

    return len(string) - len(substring) - len(parts[-1])

否则，我们从字符串的长度中减去子字符串的长度和字符串剩余部分的长度，以获得第 N 次出现的索引。

额外资源

您可以通过查看以下教程来了解有关相关主题的更多信息：