RDRYUSLOG DEV
Back to Blog
Python

Using Python's str.startswith() for Prefix Checks

Learn how to use Python's str.startswith() for prefix checks, including tuple prefixes, start and end indices, performance, and edge cases.

string methodsprefix matchingPython stringstext processingconditional logic
A stylized illustration of a string being checked for a prefix, with a checkmark indicating a successful startswith match.

When you need to check whether a string begins with a specific prefix, Python's str.startswith() is the direct tool. This method returns True if the string starts with the given prefix, and False otherwise. It is a built-in method on all string objects, so no import is required.

filename = "report_final.pdf"
print(filename.startswith("report"))  # True
print(filename.startswith("final"))   # False

The method is case-sensitive, so "Report" would not match "report". For case-insensitive checks, you would need to normalize the string first, for example with .lower() or .casefold().

Basic Syntax and Parameters

The full signature of startswith() is:

str.startswith(prefix[, start[, end]])
  • prefix is the string to look for at the beginning of the string. It can also be a tuple of strings (explained below).
  • start is an optional integer index that defines where the search begins. The string is treated as if it started at that index for the purpose of the check.
  • end is an optional integer index that defines where the search ends. The prefix must be found entirely before this index.

Here is an example that uses all three parameters:

text = "Hello, world!"
print(text.startswith("world", 7))   # True, because index 7 is 'w'
print(text.startswith("world", 0, 5)) # False, because the slice [0:5] is "Hello"

The start and end parameters behave like slice indices: start is inclusive, end is exclusive. They are useful when you want to check a substring without creating a new string object.

Using startswith with Tuples for Multiple Prefixes

Often you need to check if a string starts with any one of several prefixes. Instead of writing multiple or conditions, you can pass a tuple of strings as the prefix argument:

filename = "archive.zip"
if filename.startswith(("archive", "backup", "temp")):
    print("Recognized prefix")

The method returns True if the string starts with any of the tuple elements. Passing a tuple is clearer and more concise than chaining or conditions, especially when the list of prefixes is long.

A tuple is required; passing a list will raise a TypeError. If you have a list of prefixes, convert it with tuple(prefixes).

Checking a Prefix in a Specific Range

The start and end parameters allow you to check a prefix within a specific region of the string without slicing it. This avoids creating a temporary substring, which can matter in tight loops.

line = "2025-03-14,error,connection refused"
# Check if the timestamp part starts with "2025"
if line.startswith("2025", 0, 4):
    print("Log entry from 2025")

Here, the check is limited to the first four characters. Without start and end, you would need to write line[:4].startswith("2025"), which creates a new string. Using the indices is more memory-efficient when you are processing many lines.

Common Mistakes and Edge Cases

One frequent mistake is forgetting that startswith() is case-sensitive. Another is forgetting that start and end are ordinary character positions in the original string; they are applied before the prefix check. The method does not modify the string; it just restricts the region.

An empty prefix always returns True, because every string starts with an empty string:

print("anything".startswith(""))  # True

This can be surprising in validation logic. If you need to reject empty prefixes, check if prefix: before calling startswith().

Indices can be negative, just like slice indices. For example, startswith("end", -3) checks the last three characters. However, using negative indices with start and end can be confusing; it is often clearer to slice explicitly when the logic is complex.

Performance Considerations

startswith() is implemented in C and is fast. It does not create a temporary substring to test the start of a string. With a tuple, it checks the prefixes in order until one matches, so the cost depends on the number and length of the prefixes it has to try. Building a tuple once and reusing it avoids repeated tuple creation when checking many strings.

For matching a large set of prefixes, a precompiled regular expression with re.match and an alternation pattern can be a useful alternative; compiling the pattern has an upfront cost, and literal prefixes must be escaped. For most prefix checks, startswith() with a tuple is sufficient.

A common performance mistake is calling startswith() inside a loop while also slicing the string unnecessarily. Use the start and end parameters to avoid creating substrings.

Alternatives and When Not to Use startswith

If you need to check the end of a string, use endswith(). If you need to find a substring anywhere in the string, use in or find(). startswith() is specifically for anchored matches at the beginning.

For case-insensitive prefix checks, you might be tempted to call .lower().startswith(prefix.lower()). This works but creates new strings. For repeated checks, normalize the input once and compare it against normalized prefixes. A compiled regular expression with the re.IGNORECASE flag is another option, but it has its own overhead.

When you need to extract the part after the prefix, startswith() alone is not enough. You would combine it with slicing:

if url.startswith("https://"):
    rest = url[8:]

This pattern is common in URL parsing.

Real-World Example: Validating Image File Names

Consider a function that validates a filename by checking both a category prefix and a recognized image extension. This is useful when files are named with a category prefix:

def is_image_filename(name):
    image_prefixes = ("img_", "photo_", "pic_")
    return name.startswith(image_prefixes) and name.endswith((".png", ".jpg", ".jpeg"))

This combines startswith() with endswith() and demonstrates the tuple feature for both. The function returns True only if the name starts with one of the image prefixes and ends with a valid image extension.

This kind of validation is common in batch file processors, where you need to filter files based on naming conventions. The tuple argument keeps the logic compact and avoids a long chain of or conditions.

Handling Edge Cases in Production Code

In production code, you often need to handle strings that may be None or not strings at all. startswith() is a method on str, so calling it on None raises an AttributeError. If your data comes from external sources, guard the call:

if isinstance(value, str) and value.startswith("prefix"):
    pass

Alternatively, use a helper that returns False for non-string inputs. This is especially important when processing JSON payloads or database records where fields can be missing or null.

Another edge case is the interaction with Unicode. startswith() works on Unicode code points, not on bytes. If you are dealing with bytes, use bytes.startswith(), which behaves similarly. For multi-byte encodings, the method operates on the decoded string, so the indices refer to code points, not bytes.

Finally, because startswith() is a method on a string object, using it with functional helpers such as map() or filter() can be awkward. For example, filter(str.startswith, strings) fails because startswith() still needs a prefix argument. A list comprehension is usually clearer:

strings = ["draft_1.txt", "final_2.txt"]
drafts = [s for s in strings if s.startswith("draft_")]

By understanding the full behavior of startswith(), including its parameters and tuple support, you can write cleaner and more efficient string handling code.

Python's str.startswith(): Usage, Parameters, and Examples | RYUSLOG DEV