The count() Method for Counting Substring Occurrences

From Quantity to Position

The title of this topic focuses on count(), which answers a quantity question: how many times does a substring occur? The supplied concept focuses on the closely related find() method, which answers a position question: where does the substring start? Understanding both viewpoints helps you choose the result your program needs.

When find() searches a string, it returns one integer. If the substring is found, the integer is the starting index of that substring. If the substring is not found, the result is -1. Because the result is an integer, your code can inspect it directly in a conditional statement.

Reading the Returned Index

Index positions are zero-indexed. That means the first character is at position 0, the next character is at position 1, and so on. The number returned by find() points to the position where the searched substring begins, not to the position after the substring.

address = "person@example.com"
position = address.find("@")
print(position)

6

Branching on -1

The most useful conditional pattern is to compare the result of find() with -1. If the result is -1, the substring is absent. If the result is not -1, the substring was found, and the returned integer gives its starting position.

position = line.find("From:") if position == -1: continue print(line)

Filtering File Lines

The practical pattern combines a file loop, rstrip(), find(), and a conditional. The source example opens mbox-short.txt, processes each line, removes trailing whitespace, searches for a substring, and prints only lines in which the substring is present.

fhand = open("mbox-short.txt")
for line in fhand:
    line = line.rstrip()
    if line.find("From:") == -1:
        continue
    print(line)

fhand = open("mbox-short.txt") for line in fhand: line = line.rstrip() if line.find("From:") == -1: continue print(line)

Debugging the Search

When a substring filter behaves unexpectedly, inspect the integer returned by find() before changing the conditional. The integer tells you whether a match exists and, when it does, where the match begins. Tracing that value against the zero-indexed characters often reveals whether the search text or the expected position is incorrect.

• Treating the find() result as an occurrence count

  find() returns a starting index when the substring is found, not an occurrence quantity.

  Fix: Read the integer as the substring's starting position. Use count() when the required result is an occurrence quantity.

• Forgetting that indexes start at 0

  The source convention is zero-indexing: the first character is at position 0.

  Fix: Begin the character trace at index 0 before checking the returned position.

• Printing every line after a failed search

  -1 means the substring was not found.

  Fix: Use the -1 case to continue to the next line, and print only when the result is not -1.

• Searching a file line before removing trailing whitespace

  A line read from a file includes a newline character and other trailing whitespace may also be present.

  Fix: Call rstrip() before searching the line.

Practice and Review

1. find() returns a single integer. A valid result identifies the substring's starting index, while -1 means that the substring was not found. Since indexes are zero-indexed, trace the returned number against character positions when debugging. For file filtering, remove trailing whitespace with rstrip(), search each line, skip lines whose result is -1, and print lines whose result is not -1. count() and find() serve different purposes: count() reports an occurrence quantity, while find() reports a position or absence.