How to Count a Specific Letter in a Text File in Python

Counting how many times a particular character appears in a text file is a common task in log analysis, text processing, and data validation. While the core logic is simple, the right approach depends on the size of the file you are working with. Loading a small configuration file into memory is perfectly fine, but doing the same with a multi-gigabyte log file can crash your application.

In this guide, you will learn how to count a specific letter in a text file using several methods, including full-file reads, memory-efficient chunked reads, line-by-line processing, and multi-character counting. Each approach is explained with examples, output expectations, and guidance on when to use it.

Small Files: Read the Entire Content

For files that fit comfortably in memory, the simplest approach is to read the entire content into a string and use the built-in .count() method:

def count_letter(filepath, letter):
    with open(filepath, "r", encoding="utf-8") as file:
        content = file.read()
        return content.count(letter)

count = count_letter("document.txt", "e")
print(f"Letter 'e' appears {count} times")

Example output:

Letter 'e' appears 47 times

Large Files: Chunked Reading

For files that may be hundreds of megabytes or even gigabytes in size, reading the entire content at once can exhaust your system's memory. Instead, read the file in fixed-size chunks:

def count_letter_chunked(filepath, letter, chunk_size=1024 * 1024):
    total = 0

    with open(filepath, "r", encoding="utf-8") as file:
        while chunk := file.read(chunk_size):
            total += chunk.count(letter)

    return total

count = count_letter_chunked("large_log.txt", "a")
print(f"Found {count} occurrences")

Example output:

Found 238451 occurrences

The default chunk_size of 1024 * 1024 bytes (1 MB) provides a good balance between memory usage and read efficiency. You can adjust it based on your system's resources.

Line-by-Line Reading

Reading a file line by line is another memory-efficient approach. It is especially useful when you also need to process or inspect individual lines during counting:

def count_letter_lines(filepath, letter):
    total = 0

    with open(filepath, "r", encoding="utf-8") as file:
        for line in file:
            total += line.count(letter)

    return total

count = count_letter_lines("access.log", "x")
print(f"Found {count} occurrences")

Example output:

Found 1024 occurrences

Case-Insensitive Counting

To count both uppercase and lowercase versions of a letter, normalize the text before counting:

def count_letter_insensitive(filepath, letter, chunk_size=1024 * 1024):
    letter = letter.lower()
    total = 0

    with open(filepath, "r", encoding="utf-8") as file:
        while chunk := file.read(chunk_size):
            total += chunk.lower().count(letter)

    return total

count = count_letter_insensitive("mixed_case.txt", "A")
print(f"Found {count} occurrences of 'a' or 'A'")

Example output:

Found 312 occurrences of 'a' or 'A'

Counting Multiple Letters in a Single Pass

When you need to count several different characters at once, iterating through the file character by character with a Counter avoids multiple passes over the same data:

from collections import Counter

def count_multiple_letters(filepath, letters, chunk_size=1024 * 1024):
    targets = set(letters)
    counts = Counter()

    with open(filepath, "r", encoding="utf-8") as file:
        while chunk := file.read(chunk_size):
            for char in chunk:
                if char in targets:
                    counts[char] += 1

    return counts

result = count_multiple_letters("novel.txt", "aeiou")
print(result)

Example output:

Counter({'e': 120, 'a': 95, 'i': 80, 'o': 70, 'u': 30})

Adding Error Handling for Production Use

A production-ready implementation should validate inputs and handle common errors gracefully:

from pathlib import Path

def safe_count_letter(filepath, letter, chunk_size=1024 * 1024):
    if len(letter) != 1:
        raise ValueError(f"Expected exactly one character, got {len(letter)}")

    path = Path(filepath)
    if not path.is_file():
        raise FileNotFoundError(f"File not found: {filepath}")

    total = 0

    try:
        with open(path, "r", encoding="utf-8") as file:
            while chunk := file.read(chunk_size):
                total += chunk.count(letter)
    except UnicodeDecodeError:
        raise ValueError(f"File contains invalid UTF-8 characters: {filepath}")

    return total

A Common Mistake: Forgetting to Specify Encoding

A frequent source of bugs is opening a file without specifying the encoding:

with open("data.txt", "r") as f:
    content = f.read()

On Windows, the default encoding is often cp1252, while on Linux and macOS it is typically utf-8. This means the same code can produce different results or crash on different operating systems. Always pass encoding="utf-8" explicitly:

with open("data.txt", "r", encoding="utf-8") as f:
    content = f.read()

Method Comparison

Conclusion

For small files, reading the entire content with file.read().count() is the simplest and fastest approach. For large files, the chunked reading method provides the best balance of memory efficiency and speed, processing files of any size while keeping memory usage constant. Use line-by-line reading when you need to inspect or process individual lines alongside counting. When tracking multiple characters simultaneously, a Counter with chunked reading handles everything in a single pass.

Regardless of which method you choose, always open files with an explicit encoding="utf-8" parameter and add appropriate error handling for production code.