How to Check if a Python String Contains a Substring

I have spent over a decade writing Python code, and if there is one task I perform daily, it is searching for specific text within a larger body of data.

Whether I am filtering through US Census Bureau datasets or parsing address strings from a California real estate database, checking for a substring is a fundamental skill.

In this tutorial, I will walk you through the most efficient ways to check if a Python string contains a substring, using practical examples you’ll actually encounter in the field.

Table of Contents

Method 1: Use the in Operator in Python

When I need a quick true-or-false answer, I always reach for the in operator first. It is readable, fast, and follows the “Pythonic” philosophy of keeping code simple and clean.

Suppose I have a list of professional sports teams, and I want to verify if a specific city name exists within a full team title.

team_name = "Golden State Warriors"
substring = "Golden State"

# Using the 'in' operator to return a boolean
if substring in team_name:
    print(f"Match found! {team_name} is located in {substring}.")
else:
    print("No match found in the record.")

You can see the output in the screenshot below.

I prefer this method because it reads almost like English. It returns True if the substring exists and False otherwise.

Method 2: Use the Python string.find() Method

Sometimes, knowing if a word exists isn’t enough; I often need to know where it starts. When I am processing a list of U.S. presidential candidates or federal agencies, I use the find() method to locate the exact index.

Unlike the in operator, find() returns the lowest index of the substring if found, and -1 if it is absent.

us_address = "1600 Pennsylvania Avenue NW, Washington, DC 20500"
search_term = "Washington"

# Using find() to locate the starting position
position = us_address.find(search_term)

if position != -1:
    print(f"The term '{search_term}' starts at index {position}.")
else:
    print("The search term was not found in the address string.")

You can see the output in the screenshot below.

I find this incredibly useful when I need to slice a string or extract data following a specific keyword.

Method 3: Use the Python string.index() Method

The index() method is nearly identical to find(), but with one major difference in how it handles missing values. While find() gives you a -1, index() raises a ValueError if the substring is missing.

I use index() when I am certain the substring should be there, and I want my program to crash (or trigger an exception handler) if it isn’t.

price_string = "Total Price: $450.50 USD"
currency_symbol = "$"

try:
    # This will raise an error if '$' is missing
    idx = price_string.index(currency_symbol)
    print(f"Currency symbol found at index: {idx}")
except ValueError:
    print("Error: The price string does not contain a dollar sign.")

You can see the output in the screenshot below.

In my experience, using index() is a great way to enforce data validation during string parsing.

Method 4: Count Substring Occurrences with string.count()

There are times when I don’t just want to find one instance; I want to know how many times a term appears.

If I am analyzing a transcript from a NASA mission or a Congressional hearing, I might want to count how many times a specific keyword is mentioned.

text_block = "Liberty and justice for all. Liberty is a core American value."
keyword = "Liberty"

# Counting the number of occurrences
occurrences = text_block.count(keyword)

print(f"The word '{keyword}' appears {occurrences} times in the text.")

You can see the output in the screenshot below.

Keep in mind that this method is case-sensitive, so “liberty” and “Liberty” would be treated as different strings.

Advanced Searching with Python Regular Expressions (re)

When my search requirements get complex, like looking for a specific ZIP code pattern or a US phone number, standard string methods fall short.

This is where I bring in the re module. It allows for pattern matching rather than just literal string matching.

import re

# Example: Checking for a valid 5-digit US ZIP code in a string
shipping_info = "The package is bound for Beverly Hills, CA 90210."
zip_pattern = r"\d{5}" # Matches exactly 5 digits

# search() returns a match object if the pattern is found
match = re.search(zip_pattern, shipping_info)

if match:
    print(f"Found a valid ZIP code: {match.group()}")
else:
    print("No valid ZIP code detected in the string.")

I use re.search() when the exact substring is unknown, but the format (like an SSN or an EIN) is predictable.

Handle Case-Insensitive Substring Checks

One common headache I face is case sensitivity. Users often type in lowercase, while databases might store data in uppercase.

To ensure my Python script finds “New York” even if the user types “new york,” I normalize the strings using .lower().

# Example: Case-insensitive search for a US National Park
park_name = "YOSEMITE NATIONAL PARK"
user_search = "yosemite"

# Normalizing both strings to lowercase for a fair comparison
if user_search.lower() in park_name.lower():
    print("Match found! We are heading to Yosemite.")
else:
    print("Park not found.")

This is a professional standard I follow to make my Python applications more user-friendly and robust.

Check if a String Starts or Ends with a Substring

In some data cleanup tasks, I only care if a string begins or ends with a certain value. For instance, if I am filtering a list of American company names, I might want to find all those ending in “Inc.” or “LLC.”

Python provides the startswith() and endswith() methods for exactly this purpose.

# Example: Filtering US business entities
company_name = "Apple Inc."

# Checking the suffix
if company_name.endswith("Inc."):
    print("This is an incorporated business.")

# Checking the prefix
if company_name.startswith("Apple"):
    print("This company belongs to the Apple brand.")

These methods are much more efficient than using manual slicing like company_name[-4:] == “Inc.”.

Use any() to Check for Multiple Substrings

I often find myself needing to check if a string contains any one of several possible keywords.

Instead of writing five different if statements, I use the any() function combined with a list comprehension.

# Example: Checking if a US address contains common street types
address = "123 Main Street, Houston, TX"
street_types = ["Street", "Avenue", "Blvd", "Road"]

# any() returns True if any element in the list matches
if any(s_type in address for s_type in street_types):
    print("The address contains a recognized street type suffix.")
else:
    print("No common street type found.")

This is a clean, scalable way to handle multi-keyword searching in your Python projects.

In high-frequency trading or big-data applications, these small optimizations make a huge difference in my daily workflow.

I’ve found that the in operator is usually the best starting point for most substring tasks in Python. It’s clean, fast, and covers about 90% of use cases. If you need more control, find() or the re module are your best friends.

You may also read:

Bijay Kumar

I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.

enjoysharepoint.com/