5 Best Ways to Find the Index of a Substring in a Python String

💡 Problem Formulation: When working with text in Python, a common task is to find the position of a specific substring within a larger string. For instance, given the string “Search the substring index” and the substring “the”, the desired output is the index 8, which is the starting position of the first occurrence of “the” in the string.

Method 1: Using the find() Method

The find() method in Python is used to locate the index of the first occurrence of a substring. If the substring is not found, it returns -1. This method is case-sensitive and can also accept parameters to limit the search within a range of indices.

Here’s an example:

text = "Search the substring index"
substring = "the"
index = text.find(substring)
print(index)

Output:

8

This code snippet searches for the substring “the” in the given text, printing out the starting index of its first occurrence, which is 8.

Method 2: Using the index() Method

The index() method is similar to find() but raises a ValueError if the substring is not found. This can be useful in scenarios where the absence of the substring is unexpected and should be treated as an error.

Here’s an example:

text = "Search the substring index"
substring = "substring"
try:
    index = text.index(substring)
    print(index)
except ValueError:
    print("Substring not found.")

Output:

14

In this snippet, the index() method locates the substring “substring” in the text, outputting its index, 14. If the substring were not found, it would print “Substring not found.”

Method 3: Using List Comprehension and enumerate()

This method utilizes list comprehension with the enumerate() function to find the starting index of all occurrences of a substring. The enumerate() function adds counter to the iterable and returns it in a form of an enumerate object.

Here’s an example:

text = "Repeat the beat in the heat"
substring = "ea"
indices = [i for i, part in enumerate(text) if text[i:i+len(substring)] == substring]
print(indices)

Output:

[3, 13, 25]

This code uses list comprehension to go through the text and check if the substring “ea” matches at each position. It then prints out the list of starting indices.

Method 4: Using Regular Expressions with the re Module

The re module allows for advanced string searching using regular expressions. The search() method can be used to find the first occurrence of a pattern. If you want all occurrences, you can use finditer().

Here’s an example:

import re

text = "Seek the unique technique"
substring = "ique"
match = re.search(substring, text)
if match:
    print(match.start())
else:
    print("Substring not found.")

Output:

9

The code snippet uses regular expressions to find the substring “ique”. On finding a match, it prints the starting index of the substring in the text.

Bonus One-Liner Method 5: Using a Lambda with filter()

This one-liner method employs a lambda function in combination with filter() to find all indices at which a substring begins.

Here’s an example:

text = "Can a canal be a plan?"
substring = "an"
indices = list(filter(lambda i: text.startswith(substring, i), range(len(text))))
print(indices)

Output:

[3, 5, 17, 23]

This concise line of code uses filter() to check each index of the text to see if it is the start of the substring, creating a list of starting positions.

Summary/Discussion

• Method 1: find(). Simple and commonly used. However, it does not throw an error if the substring is not found, which may be a disadvantage in error-checking situations.
• Method 2: index(). Very similar to find() but raises an error if the substring isn’t found, which can be helpful for debugging.
• Method 3: List Comprehension with enumerate(). Offers a way to find all occurrences of a substring. It is more complex but very powerful in processing all matches.
• Method 4: Regular Expressions with the re module. Provides the most flexibility and power for pattern matching, but has a steeper learning curve.
• Method 5: Lambda with filter(). A one-liner that’s elegant for simple cases but might be less readable and efficient for larger text data.