The count() method returns how many times a substring appears in a string. It is case-sensitive, counts non-overlapping matches, and optionally lets you limit the search to a slice using start and end. It is one of the most useful methods for quick text analysis in Python.
Count how many times sub appears.
sub, start, and end params.
Uppercase ≠ lowercase.
Limit range with start/end.
Count single letters too.
Frequency vs first index.
In Python, count() is a built-in string method that scans a string for a substring and returns the number of times it occurs without overlapping. For example, "banana".count("ana") returns 1, not 2, because the two possible "ana" spans share the middle "a".
If you only need to know whether a substring exists, use sub in string or find(). Use count() when you need the number of occurrences—word frequency, character totals, or validation checks.
The count() method accepts one required and two optional parameters:
string.count(sub, start, end)sub — the substring to search for (required).start — optional start index; search begins here (default 0).end — optional end index; search stops before this position (default end of string).int; returns 0 when sub is not found.sub — passing an empty string raises ValueError.| Expression | Result |
|---|---|
"hello hello".count("hello") | 2 |
"banana".count("ana") | 1 (non-overlapping) |
"Python".count("python") | 0 (case-sensitive) |
"abracadabra".count("a") | 5 |
"mississippi".count("ss", 2, 7) | 1 (slice only) |
text.count("python")Count word occurrences
text.count("a")Count one letter
text.count("is", 0, 10)Search within range
text.count("Java")Returns 0 if absent
Run these examples in any Python 3 interpreter. Each one shows a common counting pattern.
Count how many times a word appears in a sentence.
Count occurrences of the word "python" in a longer string.
text = "python is powerful, python is easy, python is fun"
word = "python"
total = text.count(word)
print(f"'{word}' appears {total} times.")count() scans the string from left to right.Count how many vowels appear in a sentence by counting each letter separately.
text = "programming is interesting"
vowels = "aeiou"
total = sum(text.count(v) for v in vowels)
print("Vowel count:", total)count() works on single characters too. Summing counts for each vowel gives the total vowel occurrences in the text.
Slice limits, case rules, and overlapping behavior in real scenarios.
Search only within part of the string by passing slice boundaries.
text = "mississippi"
full = text.count("ss")
partial = text.count("ss", 2, 7)
print("Full string:", full)
print("Index 2–7: ", partial)text.count("ss", 2, 7) only searches inside text[2:7], which is "sissi". One "ss" appears there, while the full string has two.
count() treats uppercase and lowercase as different characters.
sentence = "This is a simple sentence. Is it simple?"
lower_count = sentence.count("simple")
mixed_count = sentence.count("Simple")
print("'simple':", lower_count)
print("'Simple':", mixed_count)Both occurrences use lowercase "simple". The capitalized form does not match. For case-insensitive counting, fold both strings with casefold() first.
Understand why count() does not count overlapping substrings.
text = "aaa"
sub = "aa"
print("Text: ", repr(text))
print("Sub: ", repr(sub))
print("Count:", text.count(sub))Visually: aaa — one match at index 0. The second possible "aa" at index 1 overlaps the first, so it is not counted. For overlapping patterns, use regular expressions.
count(sub) > 0 as a simple existence check.count() WorksThe method uses start and end to slice the string, or the full string if they are omitted.
Python searches for sub starting at the current index, comparing characters case-sensitively.
Each non-overlapping match adds 1. The scan resumes immediately after the matched substring.
You get the total number of occurrences—or 0 if the substring was never found.
count() returns 0 when the substring is not found—it does not raise an error.sub raises ValueError: empty separator.start or end values are allowed and work like normal slice indices.re module instead of count().The count() method is a fast, readable way to measure substring frequency in Python. Whether you are counting words, letters, or checking that a marker appears the right number of times, count() gives you a clear integer answer in one line.
Keep three rules in mind: it is case-sensitive, matches do not overlap, and optional start/end let you search only part of the string.
count() when you need the number of occurrencescasefold() first for case-insensitive countingstart and end to search within a slicesub in string when you only need True/False0 as “not found”subcount() is case-insensitivecount() for regex-style pattern matchingcount() with find() (frequency vs index)count()Use these points when analyzing text in Python.
Number of occurrences.
Purposesub, start, end.
SyntaxA ≠ a.
RuleCount keywords easily.
Use case"aaa".count("aa") → 1.
Edge caseContinue with encode(), endswith(), and the rest of the string method reference.
9 people found this page helpful