Python String Contains: Complete Guide

Python does not have a built-in string.contains() method like some other programming languages such as JavaScript or indexOf() methods like Java. Instead, Python uses the in keyword and several other methods to check if a string contains a substring.

Contents

• Python Approaches for Substring Checking
• The in Keyword (Most Pythonic Approach)
• Using str.find() Method
• Using str.index() Method
• Regular Expressions Approach
• Performance Considerations
• Complete Examples
• Conclusion

Python Approaches for Substring Checking

Python doesn’t provide a direct contains() method on string objects, but offers several elegant and efficient ways to check for substrings. The language philosophy emphasizes readability and simplicity, which is reflected in its substring handling approaches.

The most common and Pythonic way to check if a string contains a substring is using the in keyword, which returns a boolean result. This approach is both readable and efficient.

text = "Hello, world!"
if "world" in text:
    print("Substring found!")

Other approaches include using string methods like find(), index(), or regular expressions for more complex pattern matching scenarios.

The in Keyword (Most Pythonic Approach)

The in keyword is the most straightforward and Pythonic way to check if a string contains a substring. It returns True if the substring is found and False otherwise.

# Basic usage
somestring = "Hello, world!"
substring = "world"

if substring in somestring:
    print("Substring found!")

# Using with not (as requested in the question)
if not substring in somestring:
    continue  # This would skip to next iteration

The in keyword works with any iterable, not just strings, making it versatile and consistent across Python.

# Multiple substring checks
text = "Python is awesome"
substrings = ["Python", "is", "awesome", "missing"]

for substring in substrings:
    if substring in text:
        print(f"'{substring}' found in text")
    else:
        print(f"'{substring}' not found in text")

This approach is generally the preferred method due to its readability and performance.

Using str.find() Method

The str.find() method returns the lowest index where the substring is found, or -1 if the substring is not present. This makes it useful when you need to know the position of the substring.

somestring = "Hello, world!"
substring = "world"

position = somestring.find(substring)
if position != -1:
    print(f"Substring found at position: {position}")
else:
    print("Substring not found")

The find() method is case-sensitive and allows specifying start and end positions:

text = "Hello, hello, HELLO!"
substring = "hello"

# Find first occurrence
print(text.find(substring))  # Returns 7

# Find within specific range
print(text.find(substring, 0, 5))  # Returns -1 (not in range)
print(text.find(substring, 5, 10))  # Returns 7

Using str.index() Method

The str.index() method is similar to find() but raises a ValueError if the substring is not found instead of returning -1.

somestring = "Hello, world!"
substring = "world"

try:
    position = somestring.index(substring)
    print(f"Substring found at position: {position}")
except ValueError:
    print("Substring not found")

The index() method is useful when you expect the substring to be present and want to handle the error case explicitly:

def find_substring_position(text, substring):
    try:
        return text.index(substring)
    except ValueError:
        return -1  # Or raise a custom exception

# Usage
text = "Hello, world!"
print(find_substring_position(text, "world"))  # Returns 7
print(find_substring_position(text, "missing"))  # Returns -1

Regular Expressions Approach

For more complex pattern matching, Python’s re module provides powerful regular expression capabilities:

import re

text = "The price is $123.45"
pattern = r'\$\d+\.\d+'

if re.search(pattern, text):
    print("Price pattern found!")
    match = re.search(pattern, text)
    print(f"Found: {match.group()}")

Regular expressions are particularly useful for:

• Case-insensitive matching
• Pattern matching (not just exact substrings)
• Multiple matches
• Complex text parsing

# Case-insensitive search
text = "Hello World"
if re.search(r'hello', text, re.IGNORECASE):
    print("Found regardless of case")

# Multiple matches
text = "apple banana apple"
matches = re.findall(r'apple', text)
print(f"Found {len(matches)} matches")

Performance Considerations

For substring checking, there are some performance differences between methods:

import timeit

text = "This is a sample text for performance testing"
substring = "sample"

# Test in keyword
def test_in():
    return substring in text

# Test find method
def test_find():
    return text.find(substring) != -1

# Test index method
def test_index():
    try:
        text.index(substring)
        return True
    except ValueError:
        return False

# Performance comparison
print(f"'in' keyword: {timeit.timeit(test_in, number=1000000):.6f} seconds")
print(f"'find' method: {timeit.timeit(test_find, number=1000000):.6f} seconds")
print(f"'index' method: {timeit.timeit(test_index, number=1000000):.6f} seconds")

Generally, the in keyword is the fastest and most readable option for simple substring existence checks. The performance difference is usually negligible unless you’re performing millions of checks.

Complete Examples

Here are complete examples showing different ways to achieve the user’s original requirement:

Example 1: Using in keyword (Recommended)

def process_string(somestring):
    if "blah" not in somestring:
        return  # Continue to next iteration
    
    # Process the string
    print(f"Processing string: {somestring}")
    # ... rest of processing logic

# Usage
strings_to_process = ["hello blah world", "no blah here", "blah at the beginning"]
for s in strings_to_process:
    process_string(s)

Example 2: Creating a custom contains method

If you really want a contains method, you can create one:

class StringHelper:
    @staticmethod
    def contains(s, substring):
        return substring in s

# Usage
if not StringHelper.contains(somestring, "blah"):
    continue

Example 3: Using with lists and comprehensions

strings = ["hello world", "python programming", "data science"]
filtered_strings = [s for s in strings if "python" in s]

print(filtered_strings)  # ['python programming']

Conclusion

Python doesn’t have a direct string.contains() method, but provides several excellent alternatives:

1. Use the in keyword - This is the most Pythonic and readable approach for simple substring existence checks
2. Use str.find() - When you need the position of the substring and want to handle missing substrings gracefully
3. Use str.index() - When you expect the substring to be present and want explicit error handling
4. Use regular expressions - For complex pattern matching and advanced text processing

The in keyword is generally the best choice for most use cases, offering the best balance of readability, performance, and simplicity. For the user’s specific need, the code would be:

if "blah" not in somestring:
    continue

This approach is concise, readable, and efficient - embodying Python’s philosophy of simplicity and clarity.