Python bool int Relationship: Subclass and Pitfalls
Understand how Python's bool, a subclass of int, affects truthiness, arithmetic, comparisons, and type checks, and learn to avoid common pitfalls.

The relationship between Python's bool and int is a core part of the language's type system: bool is a subclass of int. That means True and False are not just independent constants; they are instances of int with fixed values. True equals 1, and False equals 0. This is not a quirk of the interpreter; it is a deliberate design decision that simplifies the language's type hierarchy. You can verify it directly:
issubclass(bool, int) # True
isinstance(True, int) # TrueBecause of this relationship, bool inherits all of int's methods, including arithmetic operators, bitwise operations, and comparison methods. This has practical consequences for everyday code, from how you count items to how you validate conditions.
Truthiness and Boolean Contexts
The bool type is the usual result of comparison expressions such as ==, <, or in. It is also the type returned by bool(), which converts any object to its truth value. In a condition like if some_value:, Python implicitly calls bool() on the value. For built-in types, the rule is simple: False, None, numeric zero, empty sequences, and empty mappings are falsy; most other objects are truthy. Custom classes can change this by defining __bool__ or __len__.
Because bool is a subclass of int, bool(0) is False and bool(1) is True. But be careful: bool(2) is also True, because any non-zero integer is truthy. This can lead to confusion when you compare a non-boolean integer with True:
value = 2
if value == True: # This is False, because 2 == 1 is False
print("not reached")The comparison value == True is evaluated as 2 == 1, which is False. If you intended to check whether value is truthy, use if value: instead. This distinction is one of the most common sources of bugs when developers forget that True is literally the integer 1.
Arithmetic Operations and Type Conversion
Since bool inherits from int, you can perform arithmetic with True and False directly. Adding booleans works, but the result is an int, not a bool:
True + True # 2
False * 5 # 0
True - False # 1The result type is int because arithmetic operations on bool return int; Python does not preserve the bool type through arithmetic. This is useful in some contexts, such as counting the number of True values in a list:
flags = [True, False, True, True]
count = sum(flags) # 3sum() iterates over the list and adds each element. Since True is 1 and False is 0, the total is the count of True values. Some developers find this idiom concise, but it can obscure intent. If you need a count, an explicit sum(1 for f in flags if f) is clearer, though slightly more verbose.
Arithmetic with booleans also affects code that mixes bool and int in expressions. For example, True + 2 yields 3, and False * 3 yields 0. This behavior is consistent with the subclass relationship, but it can surprise developers who expect a type error or a bool result.
Comparisons and Equality Semantics
Because True is 1 and False is 0, comparisons between booleans and integers follow normal numeric rules:
True == 1 # True
False == 0 # True
True < 2 # True
False > -1 # TrueThis also means that True and 1 are equal, and False and 0 are equal. However, they are not the same object. The is operator checks identity, not equality:
True is 1 # False
False is 0 # FalseIn practice, you rarely need is for these constants; however, True and 1 are distinct objects. The equality semantics can cause subtle bugs when you use a boolean in a dictionary key or a set. For example:
d = {True: "yes", 1: "no"}
len(d) # 1Because True and 1 have the same hash and compare equal, the second assignment overrides the first. The dictionary ends up with one key. This is a direct consequence of the bool/int relationship and is worth remembering when you design data structures that mix these types.
Type Checking and isinstance()
The subclass relationship affects how you check types. isinstance(True, int) returns True, so code that validates an integer input will also accept a boolean. If your function expects an integer but receives a boolean, it may behave unexpectedly. For example:
def double(value):
if not isinstance(value, int):
raise TypeError("expected int")
return value * 2
double(True) # returns 2If you need to reject booleans, you must check for bool explicitly:
if isinstance(value, bool) or not isinstance(value, int):
raise TypeError("expected int, not bool")Alternatively, you can use type(value) is int to exclude subclasses, but that is often too strict because it also excludes user-defined subclasses of int. The safest approach depends on whether you want to allow subclasses. In most APIs, accepting a boolean as an integer is harmless, but in domain-specific logic it can lead to incorrect calculations. Consider whether your function should treat True as 1 or reject it.
Pitfalls and Common Mistakes
Several common mistakes stem from the bool/int relationship. One is using True and False in arithmetic when you meant to use a numeric value. Another is relying on the integer value of a boolean in a context where the intent is unclear. For example:
def is_active(user):
return user.status == "active"
# Later:
points = is_active(user) * 10 # points is either 0 or 10This works, but it obscures the fact that is_active returns a boolean. A reviewer might not immediately see that points depends on a boolean value. A clearer version would use an explicit conditional:
points = 10 if is_active(user) else 0Another mistake is using True and False as indices. Since False is 0 and True is 1, you can index a list with a boolean:
choice = [ "no", "yes" ][is_ok]This is clever but fragile. If is_ok is not a boolean but an integer, the behavior changes. It is better to use an explicit conditional.
Also, be cautious with sum() on a list of booleans when you need a count. It works, but if the list contains non-boolean values, the result may be surprising. For instance, sum([True, 2]) returns 3, which is likely not what you intended.
When to Use bool vs int in APIs and Data Models
The choice between bool and int in your own code should reflect the semantics of the value. If a value has only two states, use bool. If it has more than two, or if arithmetic operations are meaningful, use int. For example, a flag like is_verified should be bool, while a counter like retry_count should be int. Mixing them can lead to confusion because True and 1 are interchangeable in many contexts, but not all.
When designing a function that accepts a numeric parameter, decide whether booleans are valid input. If your function performs arithmetic that only makes sense for true integers, you may want to reject booleans. If you are building a configuration system where True and 1 are equivalent, you can allow them, but document the behavior.
In data models, storing a boolean as an integer in a database is sometimes necessary, but you should convert it explicitly at the boundary. For example, when reading from a database, map 0 to False and 1 to True rather than relying on the implicit conversion. This makes the code more readable and avoids surprises if the database returns other integers.
Performance and Memory Considerations
True and False are singletons: the two bool instances are pre-allocated and reused, so using a boolean does not create new objects. The integers 0 and 1 are also cached in CPython, the reference implementation, so lists of booleans and lists of those small integers have very similar memory profiles. For integers outside the small-integer cache, new objects may be created, but that is a separate concern from using booleans as flags.
Since bool is a subclass of int, operations on booleans go through the same integer machinery. The performance difference between using bool and int for simple flags is negligible in most applications. The real cost comes from the semantics: if you use an integer where a boolean is intended, you may need extra checks to validate the value, which adds overhead.
In terms of performance, avoid relying on arithmetic with booleans for critical paths. The overhead is tiny, but the code becomes harder to read. If you need to count true values, a generator expression with a conditional is often clearer and just as fast:
sum(1 for x in flags if x)This avoids the implicit conversion and makes the intent explicit.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.