Python String startswith() Method: Syntax, Examples and Use Cases

Introduction: Python String startswith() Method

When working with text, you often need to check whether a string begins with a specific word or pattern. The Python string startswith() method provides a simple way to perform this check.

What it is: It is a built-in Python string method that returns a Boolean value indicating whether a string begins with a specified prefix. Using this method, you can quickly and reliably check the start of any string without manual slicing or comparison.

This method is widely used in validation and filtering tasks. It allows programs to quickly verify patterns at the beginning of strings without manually slicing or comparing characters.
Developers commonly use it when validating URLs, filtering filenames, detecting commands in user input, or identifying patterns in structured text.

Next, we’ll explore the syntax, parameters, and return value of Python’s startswith() method before diving into hands-on examples.

Master More String Methods: Discover additional string methods that can make your code easier and cleaner.: Python String Methods List

Python String startswith() Method: Syntax, Parameters,Return Value and Examples

Before using the Python startswith() Method in real programs, it helps to understand how its syntax and parameters control the behavior of the check.

Syntax

The syntax is straightforward and can be applied to any string object.

str.startswith(prefix[, start[, end]])

This structure allows you to test a prefix against the entire string or restrict the check to a specific section of the string.

Parameters

The Python startswith() Method accepts one required argument and two optional ones. Together, they define what prefix should be checked and where the check should occur.

Parameter	Type	Description
prefix	str or tuple	Required. The substring or tuple of possible prefixes to check.
start	int	Optional. Index where the prefix check should begin. Default is 0.
end	int	Optional. Index where the check should stop (exclusive). Default is the full string length.

Return Value

The Python startswith() Method returns a Boolean result indicating whether the string begins with the specified prefix.

Return Type: bool
True → when the string begins with the given prefix
False → when the prefix does not match

A quick example makes this easier to visualize.

text = "Python Programming"
print(text.startswith("Python"))

# Output:
True

Since the string begins with the word “Python”, the method returns True.

How the Python String startswith() Method Works

Although the method appears simple, understanding its behavior helps when using it in real projects.

The method checks whether the string begins with the specified prefix.
The prefix can be a single string or a tuple containing multiple possible prefixes.
If a tuple is provided, Python returns True when any prefix matches.
The optional start and end parameters allow the check to occur within a specific portion of the string.

Because it only performs a comparison and does not modify the string, the method remains safe to use in validation and filtering logic.

Practical Example – Filtering filenames

In many scripts, it becomes necessary to filter files based on their names. The following example demonstrates a simple way to do that.

files = ["report.docx", "summary.pdf", "data.csv", "image.png"]

pdf_files = [file for file in files if file.startswith("summary") or file.endswith(".pdf")]

print(pdf_files)

# Output:
['summary.pdf']

Here the list comprehension selects files that either start with the word “summary” or end with the “.pdf” extension. Combining string checks like this is common when processing file lists.

Examples of Python String startswith() Method

The easiest way to understand this method is by seeing it in action. The following examples demonstrate how it behaves in different situations.

Example 1: Basic prefix check

Let’s begin with a simple example.

text = "Hello, world!"
print(text.startswith("Hello"))
print(text.startswith("world"))

# Output:
True
False

Explanation: Here’s what happens. The string begins with “Hello”, so the first check returns True. The second test fails because the string does not start with “world”.

Example 2: Checking multiple prefixes using a tuple

filename = "report.pdf"
print(filename.startswith(("rep", "doc", "file")))
print(filename.startswith(("doc", "file")))

# Output:
True
False

Explanation: Notice that a tuple allows multiple prefixes to be tested at once. Python checks each option until it finds a match.

Since “report.pdf” starts with “rep”, the first condition succeeds. None of the prefixes in the second tuple match, so that result becomes False.

Example 3: Using the start parameter

text = "Hello, world!"
print(text.startswith("world", 7))
print(text.startswith("world", 6))

# Output:
True
False

Explanation: A quick look at the index positions explains the result. Starting from index 7, the substring begins with “world”, so the method returns True.

Starting at index 6 introduces a leading space, which prevents the prefix from matching.

Example 4: Using both start and end parameters

text = "Hello, world!"
print(text.startswith("world", 7, 12))
print(text.startswith("world", 7, 11))

# Output:
True
False

Explanation: Watch this carefully. The slice from index 7 to 12 produces the word “world”, which matches the prefix.

Reducing the end index to 11 removes the final letter, leaving “worl”. Since the full prefix is not present, the method returns False.

Example 5: Edge case — empty prefix

text = "Hello"
print(text.startswith(""))

# Output:
True

Explanation: One thing to remember: an empty string is considered a prefix of every string in Python. Because of this rule, the result always evaluates to True.

Example 6: Case sensitivity

text = "Python Programming"
print(text.startswith("python"))
print(text.startswith("Python"))

# Output:
False
True

Explanation: This example highlights an important detail: the method is case-sensitive.

Lowercase “python” does not match the uppercase “Python” at the beginning of the string. Only the exact case produces a match.

Use Cases: Python String startswith() Method

Common use cases of this method

Filtering filenames: Identify files that begin with specific prefixes.
Validating URLs: Confirm whether a URL starts with http:// or https://.
Detecting commands: Check if user input begins with a command keyword.
Processing structured text: Identify lines that start with labels or markers.
Filtering text lists: Select strings that start with a given word.

Key Examples at a Glance: Python String startswith() Method

The table below summarizes a few common ways the method is used in everyday Python code.

Scenario	Code Snippet	Output	Explanation
Basic check	`"Hello".startswith("He")`	True	The string begins with “He”.
Tuple of prefixes	`"data.csv".startswith(("data","info"))`	True	Matches the prefix “data”.
Using start parameter	`"hello world".startswith("world",6)`	True	Substring starting at index 6 begins with “world”.
Using start and end	`"hello world".startswith("world",6,11)`	True	Slice between index 6 and 11 equals “world”.
Empty prefix	`"test".startswith("")`	True	An empty string is treated as a valid prefix.
Case sensitivity	`"Python".startswith("python")`	False	Case mismatch prevents a match.

Key Takeaways: Python String startswith() Method

Here are some important takeaways about the startswith() method:

Checks whether a string starts with a prefix.
Returns True or False.
Supports multiple prefixes using tuples.
Optional start and end limit the check.
Comparison is case-sensitive.

Understanding this method allows you to validate text efficiently and write cleaner Python code.

Python String startswith() Method: Check if a String Starts with a Substring | Syntax, Examples & Use Cases