Python find all word in string

Many times while working with strings, we have problems dealing with substrings. This may include the problem of finding all positions of a particular substrings in a string. Let’s discuss certain ways in which this task can be performed. 

Method #1 : Using list comprehension + startswith() This task can be performed using the two functionalities. The startswith function primarily performs the task of getting the starting indices of substring and list comprehension is used to iterate through the whole target string. 

The original string is : GeeksforGeeks is best for Geeks
The substring to find : Geeks
The start indices of the substrings are : [0, 8, 26]

Time Complexity: O(n*m), where n is the length of the original string and m is the length of the substring to find
Auxiliary Space: O(k), where k is the number of occurrences of the substring in the string

Method #2 : Using re.finditer() The finditer function of the regex library can help us perform the task of finding the occurrences of the substring in the target string and the start function can return the resultant index of each of them. 

The original string is : GeeksforGeeks is best for Geeks
The substring to find : Geeks
The start indices of the substrings are : [0, 8, 26]

Method #3 : Using find() and replace() methods

The original string is : GeeksforGeeks is best for Geeks
The substring to find : Geeks
The start indices of the substrings are : [0, 8, 26]

Time Complexity: O(n*m), where n is the length of the original string and m is the length of the substring to find.
Auxiliary Space: O(k), where k is the number of occurrences of the substring in the string.

Method #4 : Using find()

The find() method is used to find the index of the first occurrence of the substring in the string. We start searching for the substring from the beginning of the string and continue searching until the substring is not found in the remaining part of the string. If the substring is found, we add its start index to the list of indices and update the start index to start searching for the next occurrence of the substring.

The original string is: GeeksforGeeks is best for Geeks
The substring to find: Geeks
The start indices of the substrings are: [0, 8, 26]

Time complexity: O(nm) 
Auxiliary space: O(1)

Method #5: Using string slicing and while loop

1. Initialize an empty list to store the indices of all occurrences of the substring.
2. Set the starting index i to 0.
3. Use a while loop to keep searching for the substring in the string.
4. Inside the while loop, use the find() method to find the first occurrence of the substring in the string, starting from the current index i.
5. If find() returns -1, it means that there are no more occurrences of the substring in the string, so break out of the loop.
6. If find() returns a non-negative value, append the index of the first character of the substring to the list, and update the starting index i to the next character after the end of the substring.
7. Repeat steps 4-6 until there are no more occurrences of the substring in the string.
8. Return the list of indices.

Time complexity: O(nm), where n is the length of the string and m is the length of the substring. 
Auxiliary space: O(k), where k is the number of occurrences of the substring in the string.

Method #6 : Using re.finditer() and reduce(): 

Algorithm:

1. Import the required modules – re and functools.
2.Initialize the input string test_str and the substring to be searched test_sub.
3.Use re.finditer() to find all the occurrences of the substring test_sub in the string test_str.
4. Use reduce() to get the start indices of all the occurrences found in step 3.
5. The lambda function inside the reduce() takes two arguments – the first one is the list x that accumulates the start 6.indices and the second one is the Match object y returned by finditer(). The function adds the start index of the 7.current Match object to the list x.
8. Convert the final result to a string and print it.

The start indices of the substrings are : [0, 8, 26]

Time Complexity: O(n), where n is the length of the input string.

Auxiliary Space: O(m), where m is the number of occurrences of the substring in the input string. This is because we need to store the start indices of all the occurrences in a list.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Check if a Python String Contains a Substring

If you’re new to programming or come from a programming language other than Python, you may be looking for the best way to check whether a string contains another string in Python.

Identifying such substrings comes in handy when you’re working with text content from a file or after you’ve received user input. You may want to perform different actions in your program depending on whether a substring is present or not.

In this tutorial, you’ll focus on the most Pythonic way to tackle this task, using the membership operator in. Additionally, you’ll learn how to identify the right string methods for related, but different, use cases.

Finally, you’ll also learn how to find substrings in pandas columns. This is helpful if you need to search through data from a CSV file. You could use the approach that you’ll learn in the next section, but if you’re working with tabular data, it’s best to load the data into a pandas DataFrame and search for substrings in pandas.

>>> raw_file_content = """Hi there and welcome.
... This is a special hidden file with a SECRET secret.
... I don't want to tell you The Secret,
... but I do want to secretly tell you that I have one."""

>>> "secret" in raw_file_content
True

>>> if "secret" in raw_file_content:
...    print("Found!")
...
Found!

>>> title_cased_file_content = """Hi There And Welcome.
... This Is A Special Hidden File With A Secret Secret.
... I Don't Want To Tell You The Secret,
... But I Do Want To Secretly Tell You That I Have One."""

>>> "secret" in title_cased_file_content
False

>>> file_content = title_cased_file_content.lower()

>>> print(file_content)
hi there and welcome.
this is a special hidden file with a secret secret.
i don't want to tell you the secret,
but i do want to secretly tell you that i have one.

>>> "secret" in file_content
True

>>> file_content = """hi there and welcome.
... this is a special hidden file with a secret secret.
... i don't want to tell you the secret,
... but i do want to secretly tell you that i have one."""

>>> file_content.index("secret")
59

>>> file_content.index("secret", 60)
66

>>> file_content.count("secret")
4

>>> for word in file_content.split():
...    if "secret" in word:
...        print(word)
...
secret
secret.
secret,
secretly

>>> import re

>>> file_content = """hi there and welcome.
... this is a special hidden file with a secret secret.
... i don't want to tell you the secret,
... but i do want to secretly tell you that i have one."""

>>> re.search(r"secretw+", file_content)
<re.Match object; span=(128, 136), match='secretly'>

>>> m = re.search(r"secretw+", file_content)

>>> m.group()
'secretly'

>>> m.span()
(128, 136)

>>> re.search(r"secret[.,]", file_content)
<re.Match object; span=(66, 73), match='secret.'>

>>> re.findall(r"secret[.,]", file_content)
['secret.', 'secret,']

>>> re.findall(r"(secret)[.,]", file_content)
['secret', 'secret']

>>> for match in re.finditer(r"(secret)[.,]", file_content):
...    print(match)
...
<re.Match object; span=(66, 73), match='secret.'>
<re.Match object; span=(103, 110), match='secret,'>

>>> for match in re.finditer(r"(secret)[.,]", file_content):
...    print(match.group(1))
...
secret
secret

>>> import pandas as pd

>>> companies = pd.read_csv("companies.csv")

>>> companies.shape
(1000, 2)

>>> companies.head()
             company                                     slogan
0      Kuvalis-Nolan      revolutionize next-generation metrics
1  Dietrich-Champlin  envisioneer bleeding-edge functionalities
2           West Inc            mesh user-centric infomediaries
3         Wehner LLC               utilize sticky infomediaries
4      Langworth Inc                 reinvent magnetic networks

>>> companies[companies.slogan.str.contains("secret")]
              company                                  slogan
7          Maggio LLC                    target secret niches
117      Kub and Sons              brand secret methodologies
654       Koss-Zulauf              syndicate secret paradigms
656      Bernier-Kihn  secretly synthesize back-end bandwidth
921      Ward-Shields               embrace secret e-commerce
945  Williamson Group             unleash secret action-items

>>> companies[companies.slogan.str.contains(r"secretw+")]
          company                                  slogan
656  Bernier-Kihn  secretly synthesize back-end bandwidth

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Check if a Python String Contains a Substring

In this Python tutorial, we will discuss everything on Python find substring in string with a few more examples.

Python provides several methods to find substrings in a string. Here we will discuss 12 different methods to check if Python String contains a substring.

• Using the in operator
• Using The find() method
• Using the index() method
• Using the re module
• Using the startswith() method
• Using the endswith() method
• Using the split() method
• Using the partition() method
• Using the count() method
• Using the rfind() method
• Using the list comprehension
• Using the re.findall()

Method-1: Using the in operator

The in operator is one of the simplest and quickest ways to check if a substring is present in a string. It returns True if the substring is found and False otherwise.

# Define the main string
string = "I live in USA"

# Define the substring to be searched
substring = "USA"

# Use 'in' operator to check if substring is present in string
if substring in string:
    print("Substring found")
else:
    print("Substring not found")

The above code checks if a given substring is present in a given string.

• The main string is stored in the variable string and the substring to be searched is stored in the variable substring.
• The code uses the in operator to check if the substring is present in the string. If it is, the code outputs “Substring found” to the console. If not, the code outputs “Substring not found”.

Read: Slicing string in Python + Examples

Method-2: Using The find() method

The find() method is another simple way to find substrings in a string. It returns the index of the first occurrence of the substring in the string. If the substring is not found, it returns -1.

# Define the main string
string = "I live in USA"

# Define the substring to be searched
substring = "USA"

# Use the find() method to get the index of the substring
index = string.find(substring)

# Check if the substring is found
if index != -1:
    print("Substring found at index", index)
else:
    print("Substring not found")

The above code uses the find() method to search for the index of a given substring in a given string.

• The find() method is used to search for the index of the substring in the string, and the result is stored in the variable index.
• If the substring is found, the index will be set to the index of the first character of the substring in the string. If the substring is not found, index will be set to -1.
• The code then checks if index is not equal to -1. If it is not, the substring was found and the code outputs “Substring found at index” followed by the value of the index.
• If the index is equal to -1, the substring was not found and the code outputs “Substring not found”.

Read: Convert string to float in Python

Method-3: Using the index() method

The index() method is similar to the find() method, but it raises a ValueError exception if the substring is not found in the string.

# Search for substring in a given string
string = "I live in USA"

# The substring we want to search for
substring = "live"

# Use try-except block to handle potential ValueError if substring is not found
try:
    # Find the index of the substring in the string using the index() method
    index = string.index(substring)
    # Print a success message with the index of the substring
    print("Substring found at index", index)
except ValueError:
    # If the substring is not found, print a message indicating that it was not found
    print("Substring not found")

The code above is checking if a given substring is present in a string.

• The input string is “I live in USA” and the substring we want to search for is “live”.
• The code uses a try-except block to handle the potential error of not finding the substring in the string.
• The index() method is used to find the index of the substring in the string. If the substring is found, the code prints a message indicating the index of the substring in the string.
• If the substring is not found, a ValueError is raised, which is caught by the except block, and a message indicating that the substring was not found is printed.

Read: Append to a string Python + Examples

Method-4: Using the re module

The re (regular expression) module provides powerful methods for matching and searching for substrings in a string.

# Use the re module for pattern matching
import re

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "in"

# Use the search() method from the re module to find a match
match = re.search(substring, string)

# Check if a match was found
if match:
    # If a match was found, print a success message
    print("Substring found")
else:
    # If no match was found, print a failure message
    print("Substring not found")

The code above is checking if a given substring is present in a string using regular expressions (regex).

• The first line import re imports the re module which provides functions for pattern matching in strings.
• The input string is “I live in USA” and the substring we want to search for is “in”. The code then uses the re.search() method to find a match between the substring and the input string.
• The re.search() method returns a match object if there is a match between the substring and the input string, otherwise it returns None.
• The code then uses an if statement to check if a match was found. If a match was found, the code prints a message indicating that the substring was found.
• If no match was found, the code prints a message indicating that the substring was not found.

Read: Python compare strings

Method-5: Using the startswith() method

The startswith() method returns True if the string starts with the specified substring and False otherwise.

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "I"

# Use the startswith() method to check if the string starts with the substring
if string.startswith(substring):
    # If the string starts with the substring, print a success message
    print("Substring found")
else:
    # If the string does not start with the substring, print a failure message
    print("Substring not found")

The code above checks if a given substring is at the beginning of a string.

• The input string is “I live in USA” and the substring we want to search for is “I”. The code uses the startswith() method to check if the input string starts with the substring.
• The startswith() method returns True if the input string starts with the substring and False otherwise. The code then uses an if statement to check the result of the startswith() method.
• If the input string starts with the substring, the code prints a message indicating that the substring was found. If the input string does not start with the substring, the code prints a message indicating that the substring was not found.

Read: Python program to reverse a string with examples

Method-6: Using the endswith() method

The endswith() method is similar to the startswith() method, but it returns True if the string ends with the specified substring and False otherwise.

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "USA"

# Use the endswith() method to check if the string ends with the substring
if string.endswith(substring):
    # If the string ends with the substring, print a success message
    print("Substring found")
else:
    # If the string does not end with the substring, print a failure message
    print("Substring not found")

The code above checks if a given substring is at the end of a string.

• The input string is “I live in USA” and the substring we want to search for is “USA”. The code uses the endswith() method to check if the input string ends with the substring.
• The endswith() method returns True if the input string ends with the substring and False otherwise. The code then uses an if statement to check the result of the endswith() method.
• If the input string ends with the substring, the code prints a message indicating that the substring was found. If the input string does not end with the substring, the code prints a message indicating that the substring was not found.

Read: Python string formatting with examples.

Method-7: Using the split() method

The split() method splits a string into a list of substrings based on a specified delimiter. The resulting substrings can then be searched for the desired substring.

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "USA"

# Split the string into substrings using the split() method and store the result in a list
substrings = string.split(" ")

# Check if the substring is in the list of substrings
if substring in substrings:
    # If the substring is in the list, print a success message
    print("Substring found")
else:
    # If the substring is not in the list, print a failure message
    print("Substring not found")

The code above checks if a given substring is contained within a string.

• The input string is “I live in USA” and the substring we want to search for is “USA”. The code splits the input string into substrings using the split() method and stores the result in a list substrings.
• The split() method splits a string into substrings using a specified delimiter (in this case, a space character).
• Next, the code uses the in operator to check if the substring is in the list of substrings. If the substring is in the list, the code prints a message indicating that the substring was found.
• If the substring is not in the list, the code prints a message indicating that the substring was not found.

Method-8: Using the partition() method

The partition() method splits a string into a tuple of three substrings: the substring before the specified delimiter, the specified delimiter, and the substring after the specified delimiter.

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "I"

# Use the partition() method to split the string into three parts
before, delimiter, after = string.partition(" ")

# Check if the first part of the split string is equal to the substring
if before == substring:
    # If the first part is equal to the substring, print a success message
    print("Substring found")
else:
    # If the first part is not equal to the substring, print a failure message
    print("Substring not found")

The code above checks if a given substring is at the beginning of a string.

The input string is “I live in USA” and the substring we want to search for is “I”. The code uses the partition() method to split the input string into three parts:

• The part before the specified delimiter, the delimiter itself, and the part after the delimiter. In this case, the delimiter is a space character.
• The partition() method returns a tuple with three elements: the part before the delimiter, the delimiter itself, and the part after the delimiter.
• The code uses tuple unpacking to assign the three parts to the variables before, delimiter, and after.
• Next, the code uses an if statement to check if the first part of the split string (i.e., before) is equal to the substring.
• If the first part is equal to the substring, the code prints a message indicating that the substring was found. If the first part is not equal to the substring, the code prints a message indicating that the substring was not found.

Method-9: Using the count() method

The count() method returns the number of times a substring appears in a string.

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "live"

# Use the count() method to count the number of times the substring appears in the string
count = string.count(substring)

# Print the result
print("Substring found", count, "times")

The code above counts the number of times a given substring appears in a string.

• The input string is “I live in USA” and the substring we want to search for is “live”. The code uses the count() method to count the number of times the substring appears in the string.
• Finally, the code uses the print() function to print the result, indicating how many times the substring was found in the string.

Method-10: Using the rfind() method

The rfind() method is similar to the find() method, but it returns the index of the last occurrence of the substring in the string. If the substring is not found, it returns -1.

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "USA"

# Use the rfind() method to find the last index of the substring in the string
index = string.rfind(substring)

# Check if the substring was found
if index != -1:
    # If the substring was found, print the index
    print("Substring found at index", index)
else:
    # If the substring was not found, print a message
    print("Substring not found")

The code above searches for the last occurrence of a given substring in a string.

• The input string is “I live in USA” and the substring we want to search for is “USA”. The code uses the rfind() method to find the last index of the substring in the string.
• The rfind() method returns the index of the last occurrence of the substring in the string, or -1 if the substring is not found. So the code checks if the returned value is not equal to -1, indicating that the substring was found in the string.
• Finally, the code uses the print() function to print the result, indicating the index of the last occurrence of the substring in the string.

Method-11: Using the list comprehension

# The string we want to search in
string = "I live in USA"

# The substring we want to search for
substring = "USA"

# Use a list comprehension to find if the substring exists in the string split into words
result = [word for word in string.split() if word == substring]

# Check if the result list is not empty
if result:
    # If the result list is not empty, the substring was found
    print("Substring found")
else:
    # If the result list is empty, the substring was not found
    print("Substring not found")

The code above checks if a given substring exists in a string.

• The input string is “I live in USA” and the substring we want to search for is “USA”. The code uses a list comprehension to create a list of words from the input string, where each word is checked if it is equal to the given substring.
• The list comprehension iterates over the words in the input string, which is split using the split() method, and adds the word to the result list if it is equal to the given substring.
• Finally, the code uses an if statement to check if the result list is not empty. If the result list is not empty, it means that the substring was found in the input string, so the code prints “Substring found”.
• If the result list is empty, the substring was not found in the input string, so the code prints “Substring not found”.

Method-12: Using the re.findall()

The re.findall() function returns a list of all non-overlapping matches of the specified pattern within the string. We can use this function to find all occurrences of a substring within a string by specifying the substring as the pattern.

# Import the regular expression library 're'
import re

# The input text to search for the substring
text = "I live in USA"

# The substring to search for in the text
substring = "USA"

# Find all occurrences of the substring in the text using the 'findall' method from the 're' library
result = re.findall(substring, text)

# Print the result
print(result)

In the above code, the regular expression library re is imported and used to find all occurrences of the given substring “USA” in the input text “I live in USA”.

• The re.findall method is used to search for all occurrences of the substring in the text and return them as a list.
• Finally, the result is printed on the console.

You may like the following Python examples:

• How to concatenate strings in python
• Find Last Number in String in Python
• Find first number in string in Python

In this Python tutorial, we learned, Python find substring in string using the below methods:

• Python find substring in string using the in operator
• Python find substring in string using The find() method
• Python find substring in string using the index() method
• Python find substring in string using the re module
• Python find substring in string using the startswith() method
• Python find substring in string using the endswith() method
• Python find substring in string using the split() method
• Python find substring in string using the partition() method
• Python find substring in string using the count() method
• Python find substring in string using the rfind() method
• Python find substring in string using the list comprehension
• Python find substring in string using the re.findall()

16 ответов

import re
[m.start() for m in re.finditer('test', 'test test test test')]
#[0, 5, 10, 15]

[m.start() for m in re.finditer('(?=tt)', 'ttt')]
#[0, 1]

search = 'tt'
[m.start() for m in re.finditer('(?=%s)(?!.{1,%d}%s)' % (search, len(search)-1, search), 'ttt')]
#[1]

>>> help(str.find)
Help on method_descriptor:

find(...)
    S.find(sub [,start [,end]]) -> int

def find_all(a_str, sub):
    start = 0
    while True:
        start = a_str.find(sub, start)
        if start == -1: return
        yield start
        start += len(sub) # use start += 1 to find overlapping matches

list(find_all('spam spam spam spam', 'spam')) # [0, 5, 10, 15]

>>> string = "test test test test"
>>> [i for i in range(len(string)) if string.startswith('test', i)]
[0, 5, 10, 15]

>>> import re
>>> aString = 'this is a string where the substring "is" is repeated several times'
>>> print [(a.start(), a.end()) for a in list(re.finditer('is', aString))]
[(2, 4), (5, 7), (38, 40), (42, 44)]

In [1]: aString="ababa"

In [2]: print [(a.start(), a.end()) for a in list(re.finditer('aba', aString))]
Output: [(0, 3)]

def findall(p, s):
    '''Yields all the positions of
    the pattern p in the string s.'''
    i = s.find(p)
    while i != -1:
        yield i
        i = s.find(p, i+1)

x = 'banananassantana'
[(i, x[i:i+2]) for i in findall('na', x)]

[(2, 'na'), (4, 'na'), (6, 'na'), (14, 'na')]

def locations_of_substring(string, substring):
    """Return a list of locations of a substring."""

    substring_length = len(substring)    
    def recurse(locations_found, start):
        location = string.find(substring, start)
        if location != -1:
            return recurse(locations_found + [location], location+substring_length)
        else:
            return locations_found

    return recurse([], 0)

print(locations_of_substring('this is a test for finding this and this', 'this'))
# prints [0, 27, 36]

def find_all(a_string, sub):
    result = []
    k = 0
    while k < len(a_string):
        k = a_string.find(sub, k)
        if k == -1:
            return result
        else:
            result.append(k)
            k += 1 #change to k += len(sub) to not search overlapping results
    return result

string = "dooobiedoobiedoobie"
match = 'o'
reduce(lambda count, char: count + 1 if char == match else count, string, 0)
# produces 7

string = "test test test test"
match = "test"
len(string.split(match)) - 1
# produces 4

numberString = "onetwothreefourfivesixseveneightninefiveten"
testString = "five"

marker = 0
while marker < len(numberString):
    try:
        print(numberString.index("five",marker))
        marker = numberString.index("five", marker) + 1
    except ValueError:
        print("String not found")
        marker = len(numberString)

import re

text = 'This is sample text to test if this pythonic '
       'program can serve as an indexing platform for '
       'finding words in a paragraph. It can give '
       'values as to where the word is located with the '
       'different examples as stated'

#  find all occurances of the word 'as' in the above text

find_the_word = re.finditer('as', text)

for match in find_the_word:
    print('start {}, end {}, search string '{}''.
          format(match.start(), match.end(), match.group()))

>>> string = "test test test test"
>>> for index,value in enumerate(string):
    if string[index:index+(len("test"))] == "test":
        print index

0
5
10
15

  def find_all (строка, подстрока):    ""   Функция: Возврат всего индекса подстроки в строку   Аргументы: Строка и строка поиска   Возврат: возврат списка    ""   length = len (подстрока)   с = 0   indexes = []   в то время как c < Len (строка):       if string [c: c + length] == substring:           indexes.append(с)       с = с + 1   индексы возврата
Код>

  class newstr (str):
def find_all (строка, подстрока):    ""   Функция: Возврат всего индекса подстроки в строку   Аргументы: Строка и строка поиска   Возврат: возврат списка    ""   length = len (подстрока)   с = 0   indexes = []   в то время как c < Len (строка):       if string [c: c + length] == substring:           indexes.append(с)       с = с + 1   индексы возврата
Код>

from flashtext import KeywordProcessor
words = ['test', 'exam', 'quiz']
txt = 'this is a test'
kwp = KeywordProcessor()
kwp.add_keywords_from_list(words)
result = kwp.extract_keywords(txt, span_info=True)

mystring = 'Hello World, this should work!'
find_all = lambda c,s: [x for x in range(c.find(s), len(c)) if c[x] == s]

# s represents the search string
# c represents the character string

find_all(mystring,'o')    # will return all positions of 'o'

[4, 7, 20, 26] 
>>> 

#!/usr/bin/env python
# coding:utf-8
'''黄哥Python'''


def get_substring_indices(text, s):
    result = [i for i in range(len(text)) if text.startswith(s, i)]
    return result


if __name__ == '__main__':
    text = "How much wood would a wood chuck chuck if a wood chuck could chuck wood?"
    s = 'wood'
    print get_substring_indices(text, s)

In this post, you’ll learn how to find an index of a substring in a string, whether it’s the first substring or the last substring. You’ll also learn how to find every index of a substring in a string.

Knowing how to work with strings is an important skill in your Python journey. You’ll learn how to create a list of all the index positions where that substring occurs.

The Quick Answer:

How to Use Python to Find the First Index of a Substring in a String

If all you want to do is first index of a substring in a Python string, you can do this easily with the str.index() method. This method comes built into Python, so there’s no need to import any packages.

Let’s take a look at how you can use Python to find the first index of a substring in a string:

a_string = "the quick brown fox jumps over the lazy dog. the quick brown fox jumps over the lazy dog"

# Find the first index of 'the'
index = a_string.index('the')
print(index)

# Returns: 0

We can see here that the .index() method takes the parameter of the sub-string that we’re looking for. When we apply the method to our string a_string, the result of that returns 0. This means that the substring begins at index position 0, of our string (i.e., it’s the first word).

Let’s take a look at how you can find the last index of a substring in a Python string.

How to Use Python to Find the Last Index of a Substring in a String

There may be many times when you want to find the last index of a substring in a Python string. To accomplish this, we cannot use the .index() string method. However, Python comes built in with a string method that searches right to left, meaning it’ll return the furthest right index. This is the .rindex() method.

Let’s see how we can use the str.rindex() method to find the last index of a substring in Python:

a_string = "the quick brown fox jumps over the lazy dog. the quick brown fox jumps over the lazy dog"

# Find the last index of 'the'
index = a_string.rindex('the')
print(index)

# Returns: 76

In the example above, we applied the .rindex() method to the string to return the last index’s position of our substring.

How to Use Regular Expression (Regex) finditer to Find All Indices of a Substring in a Python String

The above examples both returned different indices, but both only returned a single index. There may be other times when you may want to return all indices of a substring in a Python string.

For this, we’ll use the popular regular expression library, re. In particular, we’ll use the finditer method, which helps you find an iteration.

Let’s see how we can use regular expressions to find all indices of a substring in a Python string:

import re

a_string = "the quick brown fox jumps over the lazy dog. the quick brown fox jumps over the lazy dog"

# Find all indices of 'the'
indices_object = re.finditer(pattern='the', string=a_string)
indices = [index.start() for index in indices_object]
print(indices)

# Returns: [0, 31, 45, 76]

This example has a few more moving parts. Let’s break down what we’ve done step by step:

1. We imported re and set up our variable a_string just as before
2. We then use re.finditer to create an iterable object containing all the matches
3. We then created a list comprehension to find the .start() value, meaning the starting index position of each match, within that
4. Finally, we printed our list of index start positions

In the next section, you’ll learn how to use a list comprehension in Python to find all indices of a substring in a string.

How to Use a Python List Comprehension to Find All Indices of a Substring in a String

Let’s take a look at how you can find all indices of a substring in a string in Python without using the regular expression library. We’ll accomplish this by using a list comprehension.

Want to learn more about Python list comprehensions? Check out my in-depth tutorial about Python list comprehensions here, which will teach you all you need to know!

Let’s see how we can accomplish this using a list comprehension:

a_string = "the quick brown fox jumps over the lazy dog. the quick brown fox jumps over the lazy dog"

# Find all indices of 'the'
indices = [index for index in range(len(a_string)) if a_string.startswith('the', index)]

print(indices)

# Returns: [0, 31, 45, 76]

Let’s take a look at how this list comprehension works:

1. We iterate over the numbers from 0 through the length of the list
2. We include the index position of that number if the substring that’s created by splitting our string from that index onwards, begins with our letter
3. We get a list returned of all the instances where that substring occurs in our string

In the final section of this tutorial, you’ll learn how to build a custom function to return the indices of all substrings in our Python string.

Check out some other Python tutorials on datagy, including our complete guide to styling Pandas and our comprehensive overview of Pivot Tables in Pandas!

How to Build a Custom Function to Find All Indices of a Substring in a String in Python

Now that you’ve learned two different methods to return all indices of a substring in Python string, let’s learn how we can turn this into a custom Python function.

Why would we want to do this? Neither of the methods demonstrated above are really immediately clear a reader what they accomplish. This is where a function would come in handy, since it allows a future reader (who may, very well, be you!) know what your code is doing.

Let’s get started!

# Create a custom function to return the indices of all substrings in a Python string
a_string = "the quick brown fox jumps over the lazy dog. the quick brown fox jumps over the lazy dog"

def find_indices_of_substring(full_string, sub_string):
    return [index for index in range(len(full_string)) if full_string.startswith(sub_string, index)]

indices = find_indices_of_substring(a_string, 'the')
print(indices)

# Returns: [0, 31, 45, 76]

In this sample custom function, we use used our list comprehension method of finding the indices of all substrings. The reason for this is that it does not create any additional dependencies.

Conclusion

In this post, you leaned how to use Python to find the first index, the last index, and all indices of a substring in a string. You learned how to do this with regular string methods, with regular expressions, list comprehensions, as well as a custom built function.

To learn more about the re.finditer() method, check out the official documentation here.