Python Comparison and Logical Operators

Logical Operators

Logical operators allow us to combine multiple conditions and create complex logical expressions. They operate on boolean values and return boolean results.

Types of Logical Operators

Truth Tables

Truth tables help us understand how logical operators behave with different combinations of inputs:

AND Operator

OR Operator

NOT Operator

Basic Examples

a = True
b = False

# AND operator
print(a and a)  # True
print(a and b)  # False
print(b and b)  # False

# OR operator
print(a or a)   # True
print(a or b)   # True
print(b or b)   # False

# NOT operator
print(not a)    # False
print(not b)    # True

Combining Logical Operators

a = True
b = False
c = True

# Complex expressions
print((a and b) or c)  # True
print(a and (b or c))  # True
print(not (a and b))   # True

# Using parentheses to control order of evaluation
print(not a and b)     # False - equivalent to (not a) and b
print(not (a and b))   # True - equivalent to not (False) = True

Just like in mathematics, you can use parentheses to control the order of operations. If you're uncertain about the precedence, it's always a good practice to use parentheses to make your code more readable.

Short-Circuit Evaluation

Python's logical operators use short-circuit evaluation, meaning they stop evaluating as soon as the result is determined.

# AND short-circuit: if first operand is False, second is not evaluated
def print_and_return_false():
    print("Evaluating first operand")
    return False

def print_and_return_true():
    print("Evaluating second operand")
    return True

# First operand is False, so second is never evaluated
print(print_and_return_false() and print_and_return_true())
# Output:
# Evaluating first operand
# False

# OR short-circuit: if first operand is True, second is not evaluated
print(print_and_return_true() or print_and_return_false())
# Output:
# Evaluating second operand
# True

Think of short-circuit evaluation like a chef who stops tasting a recipe as soon as they determine it won't work: if one crucial ingredient is spoiled, there's no need to taste the rest.

Using Short-Circuit Evaluation for Efficient Code

# Safe dictionary access
user_data = {"name": "Alice"}

# Without short-circuit
if "age" in user_data and user_data["age"] > 18:
    print("User is an adult")
else:
    print("Age unknown or user is not an adult")

# If we forget the existence check, this would raise a KeyError
if user_data.get("age") and user_data["age"] > 18:
    print("User is an adult")
else:
    print("Age unknown or user is not an adult")

In the first example, if "age" is not in the dictionary, the second part is never evaluated, preventing a KeyError.

Non-Boolean Operands in Logical Operations

Logical operators in Python don't always return boolean values! When used with non-boolean values, they return one of the operands:

# AND returns the first falsy value, or the last value if all are truthy
print(0 and 1)        # 0 (first falsy value)
print(1 and 2)        # 2 (last value, all truthy)
print([] and "hello") # [] (first falsy value)
print(42 and "")      # "" (first falsy value)
print("hi" and [1])   # [1] (last value, all truthy)

# OR returns the first truthy value, or the last value if all are falsy
print(0 or 1)         # 1 (first truthy value)
print(False or "")    # "" (last value, all falsy)
print([] or ())       # () (last value, all falsy)
print("hi" or 42)     # "hi" (first truthy value)
print(None or 0 or "default" or []) # "default" (first truthy value)

This behavior enables Pythonic idioms like providing default values:

def greet(name):
    # Use the provided name or default to "Guest" if name is falsy
    actual_name = name or "Guest"
    return f"Hello, {actual_name}!"

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

Real-World Example: Access Control System

def check_access(user_id, resource_id, is_admin=False):
    """
    Determines if a user has access to a specific resource.
    
    Access is granted if any of these conditions are met:
    1. User is an admin
    2. User is the owner of the resource
    3. Resource is public AND the user has a verified account
    """
    # Simulate database lookup
    user = get_user_by_id(user_id)
    resource = get_resource_by_id(resource_id)
    
    if user is None or resource is None:
        return False, "User or resource not found"
    
    # Check if admin (short-circuit for efficiency)
    if is_admin:
        return True, "Admin access granted"
    
    # Check if owner
    if user['id'] == resource['owner_id']:
        return True, "Owner access granted"
    
    # Check if public resource and user is verified
    if resource['is_public'] and user['is_verified']:
        return True, "Public access granted to verified user"
    
    # No access conditions met
    return False, "Access denied"

def get_user_by_id(user_id):
    # Simulate database lookup
    users = {
        101: {'id': 101, 'name': 'Alice', 'is_verified': True},
        102: {'id': 102, 'name': 'Bob', 'is_verified': False},
        103: {'id': 103, 'name': 'Charlie', 'is_verified': True}
    }
    return users.get(user_id)

def get_resource_by_id(resource_id):
    # Simulate database lookup
    resources = {
        1: {'id': 1, 'name': 'Company Wiki', 'owner_id': 101, 'is_public': True},
        2: {'id': 2, 'name': 'Financial Report', 'owner_id': 101, 'is_public': False},
        3: {'id': 3, 'name': 'Project Plan', 'owner_id': 102, 'is_public': False}
    }
    return resources.get(resource_id)

# Test the function
test_cases = [
    (101, 1, False),  # Alice accessing her public Wiki
    (102, 1, False),  # Bob accessing public Wiki (but he's not verified)
    (103, 1, False),  # Charlie accessing public Wiki (verified user)
    (102, 2, False),  # Bob accessing Alice's private Financial Report
    (101, 3, False),  # Alice accessing Bob's private Project Plan
    (103, 3, True)    # Charlie as admin accessing Bob's Project Plan
]

for user_id, resource_id, is_admin in test_cases:
    user = get_user_by_id(user_id)
    resource = get_resource_by_id(resource_id)
    has_access, reason = check_access(user_id, resource_id, is_admin)
    
    print(f"User: {user['name']}, Resource: {resource['name']}")
    print(f"Access: {'✅' if has_access else '❌'} - {reason}\n")

This example demonstrates how logical operators can implement complex business rules for an access control system, combining multiple conditions with appropriate short-circuiting for efficiency.