Booleans

Beginner ~30 min read

Booleans are the simplest data type - they can only be True or False. Yet they're fundamental to programming, controlling decisions, loops, and logic in every program you write.

Boolean Values

Python's boolean type (bool) has exactly two values: True and False. Note the capital letters - true and false won't work!

# Boolean Basics in Python
# Booleans represent True or False values

print("=" * 50)
print("1. Boolean Values")
print("=" * 50)

# Direct assignment
is_active = True
is_deleted = False

print(f"is_active: {is_active}")
print(f"is_deleted: {is_deleted}")
print(f"Type: {type(is_active)}")

print("\n" + "=" * 50)
print("2. Booleans from Comparisons")
print("=" * 50)

age = 25
print(f"age = {age}")
print(f"age > 18: {age > 18}")       # True
print(f"age == 25: {age == 25}")     # True
print(f"age < 20: {age < 20}")       # False
print(f"age != 30: {age != 30}")     # True

print("\n" + "=" * 50)
print("3. Boolean in Conditions")
print("=" * 50)

logged_in = True
has_permission = True

if logged_in:
    print("User is logged in")
else:
    print("Please log in")

if logged_in and has_permission:
    print("Access granted!")

print("\n" + "=" * 50)
print("4. Booleans as Numbers")
print("=" * 50)

# True = 1, False = 0
print(f"True + True = {True + True}")     # 2
print(f"True * 10 = {True * 10}")         # 10
print(f"False + 5 = {False + 5}")         # 5

# Count True values in a list
results = [True, False, True, True, False]
print(f"\nResults: {results}")
print(f"Count of True: {sum(results)}")   # 3

print("\n" + "=" * 50)
print("5. Boolean Type Conversion")
print("=" * 50)

# Using bool() function
print(f"bool(1): {bool(1)}")         # True
print(f"bool(0): {bool(0)}")         # False
print(f"bool('hello'): {bool('hello')}")  # True
print(f"bool(''): {bool('')}")       # False
print(f"bool([1,2]): {bool([1,2])}")     # True
print(f"bool([]): {bool([])}")       # False

Output

Click Run to execute your code

Fun Fact: In Python, bool is actually a subclass of int. That's why True == 1 and False == 0, and you can use them in arithmetic!

Comparison Operators

Comparison operators compare values and return booleans. They're essential for conditions and filtering.

Operator	Description	Example
`==`	Equal to	`5 == 5` → True
`!=`	Not equal to	`5 != 3` → True
`<`	Less than	`3 < 5` → True
`>`	Greater than	`5 > 3` → True
`<=`	Less than or equal	`5 <= 5` → True
`>=`	Greater than or equal	`5 >= 3` → True
`is`	Same object	`x is None`
`in`	Member of	`"a" in "abc"` → True

# Comparison Operators in Python
# All comparison operators return boolean values

print("=" * 50)
print("1. Basic Comparison Operators")
print("=" * 50)

a, b = 10, 20
print(f"a = {a}, b = {b}")
print()
print(f"a == b (equal):              {a == b}")   # False
print(f"a != b (not equal):          {a != b}")   # True
print(f"a < b  (less than):          {a < b}")    # True
print(f"a > b  (greater than):       {a > b}")    # False
print(f"a <= b (less or equal):      {a <= b}")   # True
print(f"a >= b (greater or equal):   {a >= b}")   # False

print("\n" + "=" * 50)
print("2. Comparing Different Types")
print("=" * 50)

# Numbers can be compared across types
print(f"10 == 10.0: {10 == 10.0}")     # True
print(f"10 == '10': {10 == '10'}")     # False (int vs string)

# Strings compare lexicographically (dictionary order)
print(f"'apple' < 'banana': {'apple' < 'banana'}")   # True
print(f"'Apple' < 'apple': {'Apple' < 'apple'}")     # True (uppercase < lowercase)

print("\n" + "=" * 50)
print("3. Chained Comparisons")
print("=" * 50)

# Python allows chained comparisons!
x = 15
print(f"x = {x}")
print(f"10 < x < 20: {10 < x < 20}")       # True
print(f"0 < x < 10:  {0 < x < 10}")        # False
print(f"10 <= x <= 20: {10 <= x <= 20}")   # True

# Equivalent to:
print(f"(10 < x) and (x < 20): {(10 < x) and (x < 20)}")

print("\n" + "=" * 50)
print("4. Identity Operators (is, is not)")
print("=" * 50)

# 'is' checks if same object in memory, not just equal value
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(f"a = {a}")
print(f"b = {b}")
print(f"c = a")
print()
print(f"a == b: {a == b}")     # True (same values)
print(f"a is b: {a is b}")     # False (different objects)
print(f"a is c: {a is c}")     # True (same object)

# Common use: checking for None
value = None
print(f"\nvalue is None: {value is None}")    # True

print("\n" + "=" * 50)
print("5. Membership Operators (in, not in)")
print("=" * 50)

fruits = ["apple", "banana", "cherry"]
print(f"fruits = {fruits}")
print(f"'apple' in fruits: {'apple' in fruits}")       # True
print(f"'mango' in fruits: {'mango' in fruits}")       # False
print(f"'mango' not in fruits: {'mango' not in fruits}")  # True

# Works with strings too
text = "Hello World"
print(f"\n'World' in '{text}': {'World' in text}")   # True

Output

Click Run to execute your code

Chained Comparisons: Python uniquely allows 10 < x < 20 instead of 10 < x and x < 20. Use this feature - it's cleaner and more Pythonic!

Logical Operators

Logical operators combine boolean expressions. Python uses English words: and, or, not.

Operator	Description	Example
`and`	True if BOTH are True	`True and True` → True
`or`	True if AT LEAST ONE is True	`True or False` → True
`not`	Inverts the value	`not False` → True

# Logical Operators in Python
# and, or, not - for combining boolean expressions

print("=" * 50)
print("1. The 'and' Operator")
print("=" * 50)
print("Returns True if BOTH conditions are True")
print()

# Truth table for 'and'
print("and Truth Table:")
print(f"True  and True  = {True and True}")
print(f"True  and False = {True and False}")
print(f"False and True  = {False and True}")
print(f"False and False = {False and False}")

# Practical example
age = 25
has_license = True
print(f"\nage = {age}, has_license = {has_license}")
can_drive = age >= 18 and has_license
print(f"Can drive (age >= 18 and has_license): {can_drive}")

print("\n" + "=" * 50)
print("2. The 'or' Operator")
print("=" * 50)
print("Returns True if AT LEAST ONE condition is True")
print()

# Truth table for 'or'
print("or Truth Table:")
print(f"True  or True  = {True or True}")
print(f"True  or False = {True or False}")
print(f"False or True  = {False or True}")
print(f"False or False = {False or False}")

# Practical example
is_weekend = True
is_holiday = False
print(f"\nis_weekend = {is_weekend}, is_holiday = {is_holiday}")
day_off = is_weekend or is_holiday
print(f"Day off (is_weekend or is_holiday): {day_off}")

print("\n" + "=" * 50)
print("3. The 'not' Operator")
print("=" * 50)
print("Reverses the boolean value")
print()

print(f"not True  = {not True}")
print(f"not False = {not False}")

is_raining = False
print(f"\nis_raining = {is_raining}")
print(f"not is_raining: {not is_raining}")

print("\n" + "=" * 50)
print("4. Combining Logical Operators")
print("=" * 50)

# Operator precedence: not > and > or
a, b, c = True, False, True

print(f"a={a}, b={b}, c={c}")
print(f"a and b or c:   {a and b or c}")      # (a and b) or c = False or True = True
print(f"a or b and c:   {a or b and c}")      # a or (b and c) = True or False = True
print(f"not a or b:     {not a or b}")        # (not a) or b = False or False = False
print(f"not (a or b):   {not (a or b)}")      # not (True or False) = not True = False

print("\n" + "=" * 50)
print("5. Short-Circuit Evaluation")
print("=" * 50)
print("Python stops evaluating as soon as result is known")
print()

# 'and' short-circuits on first False
print("False and print('This never runs'):", False and print("This never runs"))

# 'or' short-circuits on first True
print("True or print('This never runs'):", True or print("This never runs"))

# Practical use: avoiding errors
x = 0
# Without short-circuit, would cause ZeroDivisionError
result = x != 0 and 10/x > 1  # Safe because x != 0 is False
print(f"Safe division check: {result}")

print("\n" + "=" * 50)
print("6. Logical Operators with Non-Booleans")
print("=" * 50)
print("'and' returns first falsy value or last value")
print("'or' returns first truthy value or last value")
print()

print(f"'hello' and 'world': {'hello' and 'world'}")  # 'world'
print(f"'' and 'world': {'' and 'world'}")            # ''
print(f"'hello' or 'world': {'hello' or 'world'}")    # 'hello'
print(f"'' or 'world': {'' or 'world'}")              # 'world'

# Common pattern: default values
name = ""
display_name = name or "Anonymous"
print(f"\nname = '', display_name = {display_name}")

Output

Click Run to execute your code

Operator Precedence: not > and > or. Use parentheses to make your intent clear: (a and b) or c vs a and (b or c).

Truthy and Falsy Values

In Python, any value can be used in a boolean context. Values that act like False are called falsy; values that act like True are called truthy.

Falsy Values:

False, None
Zero: 0, 0.0, 0j
Empty sequences: "", [], (), {}, set()

Everything else is truthy!

# Truthy and Falsy Values in Python
# Any value can be evaluated as a boolean

print("=" * 50)
print("FALSY VALUES (evaluate to False)")
print("=" * 50)

falsy_values = [
    False,      # The boolean False
    None,       # None/null value
    0,          # Integer zero
    0.0,        # Float zero
    0j,         # Complex zero
    "",         # Empty string
    [],         # Empty list
    (),         # Empty tuple
    {},         # Empty dictionary
    set(),      # Empty set
]

print("Value          | Type           | bool()")
print("-" * 50)
for val in falsy_values:
    val_str = repr(val)
    type_str = type(val).__name__
    print(f"{val_str:14} | {type_str:14} | {bool(val)}")

print("\n" + "=" * 50)
print("TRUTHY VALUES (evaluate to True)")
print("=" * 50)

truthy_values = [
    True,           # The boolean True
    1,              # Non-zero integer
    -1,             # Negative numbers too
    3.14,           # Non-zero float
    "hello",        # Non-empty string
    " ",            # String with just space (not empty!)
    [1, 2, 3],      # Non-empty list
    {"a": 1},       # Non-empty dictionary
    (1,),           # Non-empty tuple
]

print("Value          | Type           | bool()")
print("-" * 50)
for val in truthy_values:
    val_str = repr(val)[:14]
    type_str = type(val).__name__
    print(f"{val_str:14} | {type_str:14} | {bool(val)}")

print("\n" + "=" * 50)
print("Practical Examples")
print("=" * 50)

# Using truthy/falsy in conditions
name = ""
if name:
    print(f"Hello, {name}!")
else:
    print("Hello, stranger!")

# Checking if list has items
items = []
if items:
    print(f"Processing {len(items)} items")
else:
    print("No items to process")

# Non-empty list
items = [1, 2, 3]
if items:
    print(f"Processing {len(items)} items")

print("\n" + "=" * 50)
print("Common Patterns")
print("=" * 50)

# Default value with 'or'
user_input = ""
value = user_input or "default"
print(f"user_input='' => value = '{value}'")

user_input = "custom"
value = user_input or "default"
print(f"user_input='custom' => value = '{value}'")

# Check before access
data = {"name": "Alice"}
# Only access if key exists and has value
if data.get("name"):
    print(f"Name is: {data['name']}")

# Safe navigation with 'and'
user = None
# Only call method if user exists
username = user and user.get("name")
print(f"username = {username}")  # None (didn't crash!)

Output

Click Run to execute your code

Common Pattern: Use or for default values: name = user_input or "Anonymous". If user_input is empty/falsy, name becomes "Anonymous".

Common Mistakes

1. Using = instead of ==

# Wrong - this is assignment!
if x = 5:  # SyntaxError!

# Correct - comparison
if x == 5:
    print("x is 5")

2. Using 'is' for value comparison

a = 1000
b = 1000

# Wrong - compares object identity
if a is b:  # May be False!

# Correct - compares values
if a == b:  # True
    print("a equals b")

# 'is' is correct for None
if x is None:  # Correct way to check None

3. Confusing 'and' short-circuit behavior

# 'and' returns first falsy value, or last value
result = "" and "hello"  # Returns "", not False!
result = "hi" and "hello"  # Returns "hello", not True!

# If you need actual boolean, use bool()
result = bool("" and "hello")  # False

4. Checking empty containers wrong way

items = []

# Works, but not Pythonic
if len(items) == 0:
    print("empty")

# Pythonic way - use truthy/falsy
if not items:
    print("empty")

if items:  # Check if not empty
    print("has items")

Exercise: Boolean Logic Practice

Task: Predict the result of each boolean expression, then run to verify.

Skills tested:

Comparison operators
Logical operators (and, or, not)
Truthy/falsy understanding
Short-circuit evaluation

# Exercise: Boolean Logic Practice
# Test your understanding of booleans, comparisons, and logical operators

# Given values:
age = 17
score = 85
has_permission = True
name = ""
items = [1, 2, 3]

# TODO: Predict the result, then uncomment print to verify

# 1. What is: age >= 18
# Your prediction:

# 2. What is: score > 80 and score < 90
# Your prediction:

# 3. What is: age < 18 or has_permission
# Your prediction:

# 4. What is: not has_permission
# Your prediction:

# 5. What is: bool(name)
# Your prediction:

# 6. What is: bool(items)
# Your prediction:

# 7. What is: 10 < age < 20
# Your prediction:

# 8. What is: name or "Anonymous"
# Your prediction:

# 9. What is: items and items[0]
# Your prediction:

# 10. What is: not name and has_permission
# Your prediction:

# Uncomment these to check your answers:
# print(f"1. age >= 18: {age >= 18}")
# print(f"2. score > 80 and score < 90: {score > 80 and score < 90}")
# print(f"3. age < 18 or has_permission: {age < 18 or has_permission}")
# print(f"4. not has_permission: {not has_permission}")
# print(f"5. bool(name): {bool(name)}")
# print(f"6. bool(items): {bool(items)}")
# print(f"7. 10 < age < 20: {10 < age < 20}")
# print(f"8. name or 'Anonymous': {name or 'Anonymous'}")
# print(f"9. items and items[0]: {items and items[0]}")
# print(f"10. not name and has_permission: {not name and has_permission}")

Output

Click Run to execute your code

Show Answers

age = 17
score = 85
has_permission = True
name = ""
items = [1, 2, 3]

# 1. age >= 18 → False (17 is not >= 18)
# 2. score > 80 and score < 90 → True (85 is between 80 and 90)
# 3. age < 18 or has_permission → True (17 < 18 is True)
# 4. not has_permission → False (not True = False)
# 5. bool(name) → False (empty string is falsy)
# 6. bool(items) → True (non-empty list is truthy)
# 7. 10 < age < 20 → True (17 is between 10 and 20)
# 8. name or "Anonymous" → "Anonymous" (empty string is falsy)
# 9. items and items[0] → 1 (items is truthy, returns items[0])
# 10. not name and has_permission → True (not "" is True, and True = True)

Summary

Boolean values: True and False (capital letters!)
Comparison: ==, !=, <, >, <=, >=
Identity: is, is not (for object identity, use with None)
Membership: in, not in
Logical: and, or, not
Falsy values: False, None, 0, empty sequences
Short-circuit: and stops at first falsy, or stops at first truthy

What's Next?

In the next lesson, we'll explore type conversion - how to convert between Python's data types like int, float, str, and bool.

Previous String Methods

Next Type Conversion

Boolean Values

Comparison Operators

Logical Operators

Truthy and Falsy Values

Common Mistakes

1. Using = instead of ==

2. Using 'is' for value comparison

3. Confusing 'and' short-circuit behavior

4. Checking empty containers wrong way

Exercise: Boolean Logic Practice

Summary

What's Next?

Enjoying these tutorials?