Python String Contains: How to Check for a Substring in Python

By the end of this page, you will understand the Python way to test whether a string contains a substring. You will learn why the in operator is usually the best choice, when find() is useful, how this differs from methods like contains() in other languages, and how to avoid common mistakes.

In Python, the most common way to check whether a string contains another string is the in operator.

"blah" in somestring

This returns:

• True if the substring exists
• False if it does not

Python does not use string.contains() as the normal built-in way to do this. Instead, substring checks are written using a very readable expression:

if "blah" in somestring:
    print("Found it")

This matters because substring checks appear everywhere in real programs:

• validating user input
• filtering text
• searching logs
• processing files
• checking URLs, headers, and API responses

Python also provides string methods like find() and index(), but they are slightly different:

• find() returns the position of the substring, or -1 if not found

Think of a string as a long strip of text, like a sentence written on paper.

Using in is like asking:

“Does this piece of paper contain the word blah anywhere?”

You are not asking where it appears. You only care whether it is present.

• "blah" in somestring → asks yes or no
• somestring.find("blah") → asks at what position
• somestring.index("blah") → asks at what position, but complains if missing

So:

• use in for a simple existence check
• use find() when you also need the position

The most common syntax is:

substring in string

To check that a substring is not present:

substring not in string

Basic example

text = "hello world"

print("world" in text)      # True
print("python" in text)     # False
print("python" not in text) # True

Explanation:

• "world" in text is True because those characters appear in order
• "python" in text is False because that substring does not exist
• not in is the cleanest way to check for absence

Your example written in Python style

Consider this code:

text = "banana"

if "ana" in text:
    print("found")
else:
    print("not found")

Step by step:

1. text is assigned the value "banana".
2. Python evaluates "ana" in text.
3. It checks whether the sequence of characters a, n, a appears anywhere inside "banana".
4. It finds "ana" starting at index 1.
5. The expression becomes True.
6. Because the condition is true, Python runs:

print("found")

Output:

found

Another trace with

Substring checks are used constantly in real programs.

Validating input

email = "user@example.com"

if "@" not in email:
    print("Invalid email address")

Filtering log lines

line = "ERROR: database connection failed"

if "ERROR" in line:
    print("Important log entry")

Checking file names

filename = "report.pdf"

if ".pdf" in filename:
    print("This looks like a PDF")

Detecting keywords in text

message = "Your order has shipped"

if "shipped" in message:
    print("Send tracking update")

Working with URLs or API responses

In real codebases, developers usually choose substring checks based on what they need next.

Simple boolean checks

Use in when all you need is true/false.

if "Bearer " not in auth_header:
    raise ValueError("Missing token prefix")

Guard clauses

A common pattern is to exit early when expected text is missing.

def parse_line(line):
    if ":" not in line:
        return None
    key, value = line.split(":", 1)
    return key.strip(), value.strip()

Validation

def is_basic_email(value):
    return "@" in value and "." in value

Case-insensitive checks for user-facing text

1. Looking for a nonexistent contains() method

Broken code:

if somestring.contains("blah"):
    print("found")

Why it fails:

• Python strings do not normally use a built-in contains() method for this style

Correct version:

if "blah" in somestring:
    print("found")

2. Using find() incorrectly in a condition

Broken code:

text = "hello world"

if text.find("hello"):
    print("found")

Why this is a problem:

• find() returns 0 when the substring starts at the beginning
• 0 is treated as False in a condition

Quick substring checks

"sub" in text       # True if present
"sub" not in text   # True if absent

Get position

text.find("sub")    # returns index or -1
text.index("sub")   # returns index or raises ValueError

Recommended choice

• Need True/False only → use in
• Need the index → use find()
• Need the index and want an error if missing → use index()

Case sensitivity

"Hello" in "Hello world"   # True
"hello" in "Hello world"   # False

Case-insensitive version:

Is there a contains() method for Python strings?

The usual Python way is to use the in operator, not contains().

How do I check if a string contains a substring in Python?

Use:

substring in text

How do I check that a substring is not in a string?

Use:

substring not in text

What is the difference between in and find() in Python?

in returns True or False. find() returns the starting index or -1.

Is Python string matching case-sensitive?

Yes. "Hello" and "hello" are different unless you normalize case yourself.

When should I use instead of ?

• String methods — Related because substring checks are part of everyday string manipulation.
• Membership operators — Related because in and not in are Python membership operators.
• Boolean expressions — Related because substring checks produce True or False.
• Conditional statements — Related because these checks are often used inside if statements.
• Case sensitivity — Related because string matching often depends on uppercase and lowercase letters.
• String slicing — Related because once you find a substring, you may extract nearby text.
• find() and index() — Related because they solve similar search problems with different return behavior.
• Regular expressions — Related when simple substring checks are not enough and pattern matching is needed.