Introduction

Counting True values in a list is a surprisingly common task in Python, appearing in data validation, feature flags, and result aggregation. Python treats True as integer 1 and False as integer 0, which opens up several concise counting techniques. This article covers six approaches, from the most idiomatic to specialized alternatives, so you can pick the right tool for each situation.

Why True Equals 1 in Python

Python's bool type is a subclass of int. The interpreter stores True as 1 and False as 0, which means boolean values participate in arithmetic seamlessly.

1print(True + True)   # 2
2print(True * 5)      # 5
3print(False + 10)    # 10
4print(isinstance(True, int))  # True

This design decision is what makes most of the counting methods below work without any explicit conversion.

Using sum()

The most Pythonic approach is calling sum() directly on the list. Because True counts as 1 and False as 0, the sum equals the number of True values.

1bool_list = [True, False, True, True, False, True]
2
3count = sum(bool_list)
4print(count)  # 4

This runs in O(n) time with no extra memory allocation beyond the accumulator. It is the recommended approach for most use cases.

Using collections.Counter

The Counter class from the collections module tallies all distinct elements in an iterable. You can read the count for True directly from the resulting dictionary-like object.

1from collections import Counter
2
3bool_list = [True, False, True, True, False, True]
4
5counts = Counter(bool_list)
6print(counts[True])   # 4
7print(counts[False])  # 2

Counter is especially useful when you need both the True and False counts at the same time, or when the list contains more than just booleans and you want a full frequency breakdown.

Using a List Comprehension

A list comprehension can filter for truthy values and then count them. This approach is explicit about what it is counting.

1bool_list = [True, False, True, True, False, True]
2
3count = sum(1 for value in bool_list if value)
4print(count)  # 4

Using a generator expression (parentheses instead of brackets) avoids creating an intermediate list in memory. The version above is already a generator expression because sum() accepts a bare generator inside its parentheses.

Using operator.countOf

The operator module provides countOf, which counts occurrences of a specific value in a sequence.

1import operator
2
3bool_list = [True, False, True, True, False, True]
4
5count = operator.countOf(bool_list, True)
6print(count)  # 4

This method is implemented in C under the hood, making it marginally faster than a pure-Python loop. It is also very readable because the intent is explicit in the function name.

Using filter()

The built-in filter() function returns an iterator of elements that satisfy a condition. Wrapping the result with len() via a list() conversion gives the count.

1bool_list = [True, False, True, True, False, True]
2
3count = len(list(filter(None, bool_list)))
4print(count)  # 4

Passing None as the filter function keeps all truthy values. This approach creates an intermediate list, so for very large inputs the generator-based methods are more memory-efficient.

Using NumPy

When working inside a numerical computing context or when the list is very large, NumPy's vectorized operations are significantly faster.

1import numpy as np
2
3bool_list = [True, False, True, True, False, True]
4arr = np.array(bool_list)
5
6count_sum = np.sum(arr)
7print(count_sum)  # 4
8
9count_where = np.count_nonzero(arr)
10print(count_where)  # 4

np.count_nonzero() is purpose-built for this kind of counting and avoids the overhead of converting booleans to integers before summing.

Performance Comparison

Different methods perform better depending on list size. Here is a rough benchmark on a list of one million booleans.

1import timeit
2import numpy as np
3import operator
4from collections import Counter
5
6bool_list = [True, False] * 500_000
7
8print(timeit.timeit(lambda: sum(bool_list), number=10))
9print(timeit.timeit(lambda: Counter(bool_list)[True], number=10))
10print(timeit.timeit(lambda: operator.countOf(bool_list, True), number=10))
11print(timeit.timeit(lambda: np.count_nonzero(bool_list), number=10))

For pure Python, sum() and operator.countOf are typically the fastest. NumPy wins when the data is already stored as a NumPy array, but the cost of converting a Python list to an array can offset its speed advantage.

Common Pitfalls

• Truthy values are not the same as True - Integers like 1, non-empty strings, and other truthy objects will be counted by sum() and filter() even though they are not boolean True. Use == True checks or strict filtering if the list contains mixed types.
• Integer 1 equals True in Counter - Counter treats 1 and True as the same key because 1 == True and hash(1) == hash(True). A list like [True, 1, False] will report Counter({True: 2, False: 1}).
• Creating unnecessary intermediate lists - Using [1 for v in bool_list if v] builds a full list in memory. Switch to a generator expression sum(1 for v in bool_list if v) to avoid the allocation.
• Forgetting that empty lists return zero - All methods correctly return 0 for an empty list, but code that later divides by the count (to compute a ratio, for example) will trigger a ZeroDivisionError.
• Importing NumPy just for counting - Adding NumPy as a dependency solely to count booleans is overkill. Stick with sum() unless NumPy is already part of your project.

Summary

• Python's bool is a subclass of int, so True is 1 and False is 0, enabling direct arithmetic.
• sum(bool_list) is the most idiomatic and efficient pure-Python approach for counting True values.
• collections.Counter gives a full frequency breakdown and is useful when you need both True and False counts.
• operator.countOf provides a C-optimized, explicit counting function from the standard library.
• Generator expressions inside sum() avoid intermediate list allocation for memory efficiency.
• NumPy's np.count_nonzero() is the fastest option when data is already in a NumPy array.
• Watch out for truthy non-boolean values in mixed-type lists, which can silently inflate your count.