Python - Boolean Operations

# Basic boolean assignment
is_active = True
has_permission = False

# Type checking
print(type(is_active))  # <class 'bool'>
print(isinstance(is_active, bool))  # True
print(isinstance(is_active, int))   # True (bool inherits from int)

# Arithmetic works because of int inheritance
print(True + True)   # 2
print(False * 100)   # 0
print(sum([True, True, False, True]))  # 3 (counting True values)

# Basic truth tables
print(True and True)    # True
print(True and False)   # False
print(False and True)   # False
print(False and False)  # False

print(True or True)     # True
print(True or False)    # True
print(False or True)    # True
print(False or False)   # False

print(not True)         # False
print(not False)        # True

# Precedence matters
x, y, z = True, False, True

# Without parentheses: not binds tightest, then and, then or
print(not x or y and z)           # False
# Equivalent to: (not x) or (y and z)
print((not x) or (y and z))       # False

# Parentheses change meaning
print(not (x or y) and z)         # False
print(not (x or (y and z)))       # False

# Combining multiple conditions
age = 25
has_license = True
is_insured = True

can_drive = age >= 18 and has_license and is_insured
print(can_drive)  # True

# and returns the first falsy value, or the last value if all are truthy
print(0 and 5)          # 0 (first falsy)
print(5 and 0)          # 0 (second value, which is falsy)
print(5 and 10)         # 10 (last value, both truthy)
print([] and "hello")   # [] (first falsy)

# or returns the first truthy value, or the last value if all are falsy
print(0 or 5)           # 5 (first truthy)
print(5 or 0)           # 5 (first truthy)
print(0 or [] or None)  # None (last value, all falsy)
print("" or "default")  # "default"

# Demonstrating evaluation order with function calls
def check_a():
    print("Checking A")
    return False

def check_b():
    print("Checking B")
    return True

# With 'and', check_b never runs because check_a returns False
result = check_a() and check_b()
# Output: "Checking A"
# result = False

# With 'or', check_b never runs because check_a... wait, it's False
result = check_a() or check_b()
# Output: "Checking A", then "Checking B"
# result = True

# Default value pattern
def greet(name=None):
    # If name is falsy (None, empty string), use "Guest"
    display_name = name or "Guest"
    return f"Hello, {display_name}!"

print(greet("Alice"))  # Hello, Alice!
print(greet(None))     # Hello, Guest!
print(greet(""))       # Hello, Guest!

# Guard clause pattern
def process_data(data):
    # Short-circuit: if data is None, don't call len()
    if data and len(data) > 0:
        return sum(data) / len(data)
    return 0

print(process_data([1, 2, 3]))  # 2.0
print(process_data(None))       # 0
print(process_data([]))         # 0

# Testing truthiness with bool()
print(bool(None))       # False
print(bool(0))          # False
print(bool(""))         # False
print(bool([]))         # False
print(bool({}))         # False

print(bool(1))          # True
print(bool(-1))         # True (any non-zero number)
print(bool("0"))        # True (non-empty string, even if it's "0")
print(bool([0]))        # True (non-empty list, even containing falsy value)
print(bool(" "))        # True (string with whitespace is not empty)

# Practical usage: avoid explicit comparisons
users = []

# Verbose (don't do this)
if len(users) > 0:
    print("Has users")

# Pythonic
if users:
    print("Has users")

# Checking for None or empty
config = None

# Verbose
if config is not None and len(config) > 0:
    process(config)

# Pythonic (but be careful—this treats empty dict as "no config")
if config:
    process(config)

# Standard comparisons
print(5 == 5)    # True
print(5 != 3)    # True
print(5 < 10)    # True
print(5 <= 5)    # True
print(5 > 3)     # True
print(5 >= 5)    # True

# Chained comparisons - Python's superpower
x = 5

# Instead of: x > 0 and x < 10
print(0 < x < 10)           # True

# Works with any comparison operators
print(1 < 2 < 3 < 4)        # True
print(1 < 2 > 0)            # True (1 < 2 and 2 > 0)

# Each operand is evaluated only once
def get_value():
    print("Getting value")
    return 5

# This calls get_value() only once
result = 0 < get_value() < 10
# Output: "Getting value"
# result = True

# Identity vs equality: is vs ==
a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)    # True (same values)
print(a is b)    # False (different objects)
print(a is c)    # True (same object)

# Always use 'is' for None, True, False
value = None
print(value is None)      # Correct
print(value == None)      # Works but not idiomatic

# Small integers are cached (implementation detail, don't rely on this)
x = 256
y = 256
print(x is y)    # True (cached)

x = 257
y = 257
print(x is y)    # False (or True, depends on implementation)

# Input validation with multiple conditions
def validate_user(username, email, age):
    errors = []
    
    if not username or len(username) < 3:
        errors.append("Username must be at least 3 characters")
    
    if not email or "@" not in email:
        errors.append("Valid email required")
    
    if not isinstance(age, int) or not 13 <= age <= 120:
        errors.append("Age must be between 13 and 120")
    
    return len(errors) == 0, errors

is_valid, errors = validate_user("ab", "invalid", 10)
print(is_valid)  # False
print(errors)    # ['Username must be at least 3 characters', 'Valid email required', 'Age must be between 13 and 120']

# Feature flags with fallback
class Config:
    FEATURES = {
        "dark_mode": True,
        "beta_features": False,
    }
    
    @classmethod
    def is_enabled(cls, feature, default=False):
        return cls.FEATURES.get(feature) or default

print(Config.is_enabled("dark_mode"))        # True
print(Config.is_enabled("unknown_feature"))  # False

# Filtering with boolean expressions
transactions = [
    {"amount": 100, "type": "credit", "verified": True},
    {"amount": 50, "type": "debit", "verified": False},
    {"amount": 200, "type": "credit", "verified": True},
    {"amount": 0, "type": "credit", "verified": True},
]

# Filter verified credits with positive amounts
valid_credits = [
    t for t in transactions
    if t["type"] == "credit" and t["verified"] and t["amount"] > 0
]
print(valid_credits)  # [{'amount': 100, ...}, {'amount': 200, ...}]

# Using any() and all() for collection-wide checks
numbers = [2, 4, 6, 8, 10]
print(all(n % 2 == 0 for n in numbers))  # True (all even)
print(any(n > 5 for n in numbers))        # True (at least one > 5)

# PITFALL 1: Comparing to True/False explicitly
is_active = True

# Bad
if is_active == True:
    print("Active")

# Good
if is_active:
    print("Active")

# Bad
if is_active == False:
    print("Inactive")

# Good
if not is_active:
    print("Inactive")

# PITFALL 2: Using 'is' with mutable objects for equality
list1 = [1, 2, 3]
list2 = [1, 2, 3]

# Wrong (checks identity, not equality)
if list1 is list2:
    print("Same")

# Correct
if list1 == list2:
    print("Equal")

# PITFALL 3: Forgetting that 'or' returns values, not booleans
def get_config(override=None):
    # Bug: if override is 0, this ignores it
    return override or "default"

print(get_config(0))  # "default" (probably not intended)

# Fix: be explicit about None
def get_config_fixed(override=None):
    return "default" if override is None else override

print(get_config_fixed(0))  # 0

# PITFALL 4: Overly complex boolean expressions
# Hard to read
if not (user is None or not user.is_active or user.is_banned):
    allow_access()

# Refactored for clarity
def user_can_access(user):
    if user is None:
        return False
    return user.is_active and not user.is_banned

if user_can_access(user):
    allow_access()