What Is a Boolean in Python: Absolute Beginners Tutorial

Every decision your Python program makes comes down to one question: is this True or False? That question is answered by Booleans, one of the simplest and most important data types in the language. This tutorial covers exactly what a Boolean is, how Python represents truth values, and how to use them to control the flow of your code.

A Boolean is a data type that can hold only one of two values: True or False. The name comes from George Boole, a 19th-century mathematician who developed the branch of algebra that deals with logical operations on true/false values. In Python, the Boolean type is called bool, and it is one of the built-in types available without importing anything.

Booleans are everywhere in Python. When you write an if statement, run a while loop, or compare two numbers, a Boolean value is produced behind the scenes. Understanding how they work gives you control over every branching decision in your programs.

True, False, and the bool Type

Python spells its two Boolean constants with an uppercase first letter: True and False. These are reserved keywords, meaning you cannot use them as variable names. Attempting to write true or false in lowercase will raise a NameError because Python treats them as undefined variable names, not Boolean values.

is_active = True
is_deleted = False

print(type(is_active))   # <class 'bool'>
print(type(is_deleted))  # <class 'bool'>

The type() function confirms that both variables belong to the bool class. There are only two instances of bool in all of Python: True and False. No third value exists.

bool Is a Subclass of int

One detail that surprises many beginners is that bool is a subclass of int. This was established when the bool type was added to Python in version 2.3 through PEP 285. Because of this inheritance, True is numerically equal to 1 and False is numerically equal to 0.

print(isinstance(True, int))  # True
print(True == 1)              # True
print(False == 0)             # True
print(True + True)            # 2
print(False + 1)              # 1

# Counting passing scores with sum()
scores = [85, 42, 91, 68, 73, 55, 90]
passing = sum(score >= 70 for score in scores)
print(passing)  # 4

Comparison Operators and Logical Operators

Booleans are rarely typed out as literals in real programs. Far more often, they are produced by comparison operators and combined with logical operators. These are the two main tools for generating Boolean values on the fly.

Comparison Operators

Comparison operators take two values and return True or False depending on whether the relationship holds. Python provides six of them: == (equal to), != (not equal to), < (less than), > (greater than), <= (less than or equal to), and >= (greater than or equal to).

temperature = 72

print(temperature > 100)   # False
print(temperature == 72)   # True
print(temperature != 50)   # True
print(temperature <= 80)   # True

Logical Operators: and, or, not

Logical operators combine or invert Boolean values. Python provides three: and, or, and not. The and operator returns True only when both sides are truthy. The or operator returns True when at least one side is truthy. The not operator flips a Boolean to its opposite value.

has_ticket = True
is_adult = True

# and — both must be True
can_enter = has_ticket and is_adult
print(can_enter)  # True

# or — at least one must be True
has_pass = False
can_enter_vip = has_ticket or has_pass
print(can_enter_vip)  # True

# not — inverts the value
is_banned = False
print(not is_banned)  # True

Truthy Values, Falsy Values, and the bool() Function

Python does not require that an if statement or while loop receive a literal True or False. Any Python object can be evaluated in a Boolean context, and Python will interpret it as either truthy (treated as True) or falsy (treated as False).

The built-in bool() function lets you see how Python classifies any value. Pass an object to bool(), and it returns True or False based on the standard truth-value testing rules.

What Is Falsy?

The following values evaluate to False in Python: the constant False itself, the constant None, numeric zeros of any type (0, 0.0, 0j), empty strings (''), empty lists ([]), empty tuples (()), empty dictionaries ({}), empty sets (set()), and empty ranges (range(0)). Custom objects can also be falsy if they define a __bool__() method that returns False or a __len__() method that returns 0.

# All of these are falsy
print(bool(False))    # False
print(bool(None))     # False
print(bool(0))        # False
print(bool(0.0))      # False
print(bool(""))       # False
print(bool([]))       # False
print(bool({}))       # False

What Is Truthy?

Everything that is not falsy is truthy. That includes non-zero numbers, non-empty strings, non-empty collections, and objects that do not explicitly define themselves as falsy. One subtle point to keep in mind: a list that contains falsy values, such as [0, 0, 0], is still truthy because the list itself is not empty.

# All of these are truthy
print(bool(42))          # True
print(bool(-1))          # True
print(bool("hello"))     # True
print(bool([1, 2, 3]))   # True
print(bool([0, 0, 0]))   # True  (the list is not empty)
print(bool({"a": 1}))    # True

"The bool type would be a straightforward subtype of the int type." — PEP 285, Python Enhancement Proposals

Python Learning Summary Points

1. A Boolean in Python is the bool type with exactly two values: True and False. Both must be capitalized. The type was introduced in Python 2.3 through PEP 285 and is a subclass of int, making True equal to 1 and False equal to 0.
2. Comparison operators (==, !=, <, >, <=, >=) return Boolean values, and logical operators (and, or, not) combine them. Together, these form the foundation of all conditional logic in Python programs.
3. Every Python object has a truth value. Falsy values include False, None, zero, and empty collections. Everything else is truthy. The bool() function converts any object to its Boolean equivalent, and Python applies these same rules automatically in if statements and while loops.

With Booleans in your toolkit, you have the foundation for every if/else branch, every while loop, and every conditional expression you will write in Python. Practice with the exercises below to solidify what you have learned.