Skip to content
CodeMDD.io | Coding Tutorials

Python String Subset: How to Easily Extract a Substring

[

Python String Subset: Checking if a Python String Contains a Substring

Are you new to programming or have experience with other programming languages and looking for the best way to check whether a string contains another string in Python? In this Python tutorial, we will guide you through the most Pythonic approach to tackle this task using the membership operator in. We will also explore different use cases and string methods to handle various scenarios.

Confirming if a Python String Contains Another String

The simplest and recommended way to check if a string contains a substring in Python is by using the membership operator in. This operator allows you to quickly and easily confirm the existence of a substring within a string. Here’s an example:

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  # Output: True

In the above code, we create a string named raw_file_content which contains some text. By using the in operator, we check if the substring "secret" is present in the raw_file_content string. If the substring is found, the expression will return True.

If you want to check if the substring is not in the string, you can utilize the not in operator. Here’s an example:

"secret" not in raw_file_content  # Output: False

In the above code snippet, we use the not in operator to check if the substring "secret" is not present in the raw_file_content string. As the substring is indeed present, the expression will return False.

The membership operator in returns a boolean value:

  • True if the substring is found in the string.
  • False if the substring is not found in the string.

You can use this syntax in conditional statements to make decisions in your code. For example:

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

In the above code, we check if "secret" is a substring of raw_file_content. If it is, we print the message “Found!” to the terminal.

Generalizing Your Check by Removing Case Sensitivity

In some cases, you may want to perform a case-insensitive search for substrings. To achieve this, you can convert both the main string and the substring to lowercase or uppercase using the lower() or upper() string methods, and then perform the check. Here’s an example:

message = "Hello World"
substring = "world"


substring.lower() in message.lower()  # Output: True

In the above code, we create a string named message and a substring named substring. By converting both the message and substring to lowercase using the lower() string method, we make the comparison case-insensitive. As a result, the expression returns True even though there’s a difference in casing between the substring and the main string.

Learning More About the Substring

If you need additional information about the substring, such as its index or the number of occurrences, you can use various string methods available in Python. Here are some commonly used methods:

  • find(): Returns the index of the first occurrence of the substring. If the substring is not found, it returns -1.
  • index(): Returns the index of the first occurrence of the substring. If the substring is not found, it raises a ValueError.
  • count(): Returns the number of occurrences of the substring in the string.

Let’s explore these methods with some examples:

message = "Hello World"
substring = "o"


message.find(substring)  # Output: 4
message.index(substring)  # Output: 4
message.count(substring)  # Output: 2

In the above code, we find the index of the first occurrence of the substring "o" in the message string using both the find() and index() methods. Both methods return the same index, which is 4. Additionally, we use the count() method to count the occurrences of the substring, which is 2 in this case.

Finding a Substring With Conditions Using Regex

If you need to search for substrings that match specific patterns or conditions, using regular expressions (regex) can be an effective solution. The re module in Python provides powerful regex functionalities. Here’s an example:

import re


message = "Hello World"
pattern = r"[A-Z]+"


re.search(pattern, message)  # Output: <re.Match object; span=(0, 1), match='H'>

In the above code, we import the re module and create a regular expression pattern "[A-Z]+". This pattern matches any uppercase letters. By using the search() function from the re module, we search for the pattern in the message string. The search() function returns a re.Match object, indicating that a match was found.

If you need to find all occurrences of a substring that match a specific pattern, you can use the findall() function. Here’s an example:

import re


message = "Hello World"
pattern = r"[oO]+"


re.findall(pattern, message)  # Output: ['o', 'o']

In the above code, we use the findall() function to find all occurrences of the pattern "[oO]+" in the message string. This pattern matches any combination of lowercase or uppercase letter “o”. The findall() function returns a list containing all the matches found.

Finding a Substring in a pandas DataFrame Column

When working with tabular data, such as data stored in a CSV file, it’s often best to load the data into a pandas DataFrame. Pandas provides powerful tools for data manipulation, which includes searching for substrings in DataFrame columns. Here’s an example:

import pandas as pd


data = {
    "Name": ["John Doe", "Jane Smith", "Alice Johnson"],
    "Age": [25, 30, 35]
}


df = pd.DataFrame(data)


df["Name"].str.contains("mith")  # Output: [False, True, False]

In the above code, we create a DataFrame with a “Name” column and an “Age” column. By using the str.contains() method from pandas, we can check if a substring is present in each value of the “Name” column. In this case, we check if the substring "mith" is present, and the method returns a boolean Series indicating which rows contain the substring.

Key Takeaways

  • To check if a string contains a substring in Python, use the membership operator in.
  • The in operator returns True if the substring is present, and False if it’s not.
  • Use not in to check if a substring is not in the string.
  • Convert both the main string and the substring to lowercase or uppercase to perform a case-insensitive search.
  • Additional string methods such as find(), index(), and count() can provide more information about the substring.
  • For complex pattern matching, regular expressions (regex) can be used with the re module.
  • When working with tabular data, use the powerful string manipulation methods provided by pandas to find substrings in DataFrame columns.

This Python tutorial provided you with a comprehensive guide on how to check if a Python string contains a substring. By using the membership operator in, you can easily perform this task and make decisions based on the presence or absence of substrings. Additionally, we explored different techniques, including case-insensitive searches, string methods, regex pattern matching, and searching in pandas DataFrame columns.