Codectionary / Developer documentation / Python

False

False is the Boolean value for a negative result or disabled state. In a condition, Python also treats values such as zero, empty containers and None as falsy. These values share a truth-value result without being interchangeable meanings.

How it works

Use not flag to reverse a Boolean decision. not always returns True or False. By contrast, and and or can return their operands when they are used with non-Boolean values.

False == 0 is true because Boolean values participate in numeric comparisons. False is not None: None normally represents absence, while False can be a known negative answer. Keep that distinction when modelling optional settings.

An empty list means no items, while a nonempty list containing False is still truthy. Truth testing a container checks emptiness, not whether all its members are true.

Common mistakes and boundaries

bool("false") is True. Parse textual settings explicitly rather than using bool() on a nonempty response.

An illustrative password-character check does not establish a secure authentication policy. The sample teaches a Boolean failure result only and uses fake data. Never print real passwords while diagnosing validation.

Try it yourself

Predict bool([]), bool([False]) and not [False]. Then write a setting check that distinguishes a missing setting (None) from an explicitly disabled setting (False).

Syntax

False

Examples

State Management

Using False to track states and flags in your program.

is_logged_in = False
has_notifications = False

if is_logged_in:
    print("Welcome back!")
else:
    print("Please log in")  # This will print

if not has_notifications:
    print("No new notifications")  # This will print
  1. The login flag selects else; negating the notification flag selects the second message.
  2. Expected output: Please log in No new notifications

Boolean Comparisons

How various comparisons evaluate to False in different scenarios.

# Numeric comparisons
print(5 > 10)      # False
print(3 == 7)      # False
print(100 < 50)    # False

# String comparisons
print("hello" == "world")  # False
print("abc" > "xyz")       # False

# List membership
numbers = [1, 2, 3]
print(5 in numbers)  # False

# Empty checks
print(bool([]))      # False - empty list
print(bool(""))      # False - empty string
print(bool(0))       # False - zero
  1. All the relationships fail for these values, and each final empty/zero value converts to False.
  2. Expected output: False False False False False False False False False

Logical Operations

Combining False with boolean operators to create complex conditions.

# AND operator
result1 = False and True   # False
result2 = False and False  # False

# OR operator
result3 = False or True    # True
result4 = False or False   # False

# NOT operator
result5 = not False        # True

# Real-world example
is_admin = False
has_special_access = False
is_verified = True

can_view_panel = is_admin or (has_special_access and is_verified)
print(f"Can access admin panel: {can_view_panel}")  # False
  1. The final permission expression is false: neither the admin flag nor the combined access condition succeeds.
  2. Expected output: Can access admin panel: False

Validation and Error Checking

Using False to indicate validation failures or error states.

def meets_character_rules(text):
    # Teaching example only, not a password-security policy.
    return (len(text) >= 8
            and any(char.isdigit() for char in text)
            and any(char.isupper() for char in text))

if not meets_character_rules("hello"):
    print("Sample does not meet the toy character rules")
  1. The fake sample fails the toy character rules. This illustrates False without claiming that character rules alone establish password security.
  2. Expected output: Sample does not meet the toy character rules

Loop Control

Using False to control loop execution and exit conditions.

searching = True
attempts = 0
max_attempts = 3

while searching:
    attempts += 1
    user_input = input(f"Attempt {attempts}: Enter the code: ")
    
    if user_input == "1234":
        print("Correct code!")
        searching = False  # Exit loop
    elif attempts >= max_attempts:
        print("Too many attempts")
        searching = False  # Exit loop
    else:
        print("Wrong code, try again")

print("Process complete")
  1. In a local terminal, enter a wrong code followed by the fake code 1234. The flag becomes false on success or after the attempt limit; this is not an authentication implementation.
  2. Expected output with the sample input below: Attempt 1: Enter the code: Wrong code, try again Attempt 2: Enter the code: Correct code! Process complete
  3. Run in a local terminal or an editor with console input. Sample input, one response per line: 0000 1234

Best practices

  • Write conditions positively when possible (if is_valid: instead of if not is_invalid:)
  • Use "not" operator for better readability (if not is_active: instead of if is_active == False:)
  • Remember that many values are "falsy" in Python (0, empty strings, empty lists, None)
  • Initialize boolean flags with False when starting in a negative state
  • Use False explicitly when you need to distinguish from None or 0
  • Choose meaningful variable names that clearly indicate what False represents

Runtime & versions

Python interpreter. Feature availability depends on the language and runtime version used by your project; consult the official reference below.

Python language reference

Specifications & further reading