Booleans

The Boolean type and truth testing

A Boolean value answers a truth question. Python's built-in type is bool, and it has exactly two instances: True and False. Capitalization matters: True is the Boolean object, whereas true is not a predefined Boolean name in Python. A Boolean is a value with its own type, so type(True) is bool.

Python also has a broader operation called truth-value testing. Almost any object can be used where Python needs a yes-or-no result. The standard documentation describes the default rule: an object is considered true unless its class supplies __bool__() returning False, or supplies __len__() returning zero. That protocol is why a custom object can define what it means to be empty without giving up the rest of its behavior. An exception raised while computing one of those methods propagates; it is not silently treated as either answer.

Several built-in values are falsey: False, None, numeric zero such as 0 or 0.0, and empty sequences or collections such as '', [], {}, and set(). A nonempty string such as '0' is truthy because it contains a character; Python does not parse its text during truth testing. Likewise, [0] is truthy because the list has one element, even though that element is itself falsey. Everything not on the falsey side is normally truthy.

Truthy and falsey are descriptions of a value's behavior in a truth test, not alternate names for True and False. For example, bool([]) produces False, but the list remains a list; [] == False is false. This distinction matters when a program must tell apart an absent value, a numeric measurement of zero, and an empty collection. The separate Type Conversion lesson owns detailed conversion practice; here, bool() is useful only as a way to display the result of a truth test.

The bool and int nuance

Python documents bool as a subclass of int. In many numeric contexts, False behaves like 0 and True behaves like 1; for example, True + True evaluates to 2, and isinstance(True, int) is true. That historical and language-level relationship can be useful when reading existing code or counting results, but it should not erase the conceptual distinction. A Boolean records truth, while an integer represents a whole number.

Clear code normally keeps that distinction visible. If an API or calculation genuinely needs an integer, use an explicit int(flag) conversion rather than relying on implicit numeric behavior. Conversely, do not use 1 and 0 as substitutes for True and False merely because they compare equal. Python's own documentation discourages relying on the numeric relationship. In particular, an equality result is not an identity claim: True == 1 is true, yet True is the Boolean singleton and 1 is an integer object. This lesson does not catalog equality, identity, arithmetic, or comparison operators; the Operators lesson treats those tools in depth.

The type relationship also does not mean that every expression involving Boolean values is best thought of as arithmetic. A list of checks such as [True, False, True] may be summed intentionally to count successful checks, but naming the result passed_count communicates the purpose. When the result is meant to steer later program behavior, preserve it as a Boolean. Good names such as has_access and is_empty also make the intended truth question easier to inspect.

Boolean operations and short circuiting

Python provides the logical operators and, or, and not. not performs a truth test and always returns a Boolean: not [] is True, while not [1] is False. and and or are different: they use truth testing to decide which operand to return. For x or y, Python returns x if x is truthy; otherwise it returns y. For x and y, it returns x if x is falsey; otherwise it returns y. Therefore 0 or 'fallback' evaluates to 'fallback', and [1] and 'next' evaluates to 'next', not to Boolean objects.

These operators are short-circuit operators. x or y evaluates y only if x is falsey, because a truthy x already decides which operand will be returned. x and y evaluates y only if x is truthy, because a falsey x already decides the result. This is observable behavior, not merely a speed improvement. A guard such as items and items[0] can avoid indexing an empty list: when items is empty, Python returns it and never attempts items[0]. Reversing the terms would not be safe.

Use short-circuit expressions when the returned operand is useful and the ordering is obvious. If a program needs a strict Boolean result, wrap the final value with bool() or use not where its inversion is actually intended. Conditional statements and branch structure are deliberately outside this lesson; the conditionals lessons own how a truth result selects code. The key point here is narrower: Python can test any object for truth, and its logical operators use that test while retaining useful operand values.