Python Operators: Arithmetic, Comparison, Logical, and More

# Arithmetic Operators Examples
a = 15
b = 4

print("=== Arithmetic Operators ===")

# Addition
print(f"{a} + {b} = {a + b}")           # 19

# Subtraction
print(f"{a} - {b} = {a - b}")           # 11

# Multiplication
print(f"{a} * {b} = {a * b}")           # 60

# Division (always returns float)
print(f"{a} / {b} = {a / b}")           # 3.75

# Floor Division (returns integer, rounds down)
print(f"{a} // {b} = {a // b}")         # 3
print(f"-{a} // {b} = {-a // b}")       # -4 (rounds toward negative infinity)

# Modulus (remainder)
print(f"{a} % {b} = {a % b}")           # 3 (15 divided by 4 leaves remainder 3)

# Exponentiation (power)
print(f"{a} ** {b} = {a ** b}")         # 50625 (15 to the power of 4)

# Operator Precedence
result = 2 + 3 * 4 ** 2 / 2 - 1
print(f"\n2 + 3 * 4 ** 2 / 2 - 1 = {result}")  # 25.0
# Evaluation order: 4**2=16, 3*16=48, 48/2=24, 2+24=26, 26-1=25

# Practical Examples
price = 99.99
quantity = 3
tax_rate = 0.08

subtotal = price * quantity
tax = subtotal * tax_rate
total = subtotal + tax

print(f"\nShopping Cart:")
print(f"Price: ${price:.2f}")
print(f"Quantity: {quantity}")
print(f"Subtotal: ${subtotal:.2f}")
print(f"Tax (8%): ${tax:.2f}")
print(f"Total: ${total:.2f}")

# Check if number is even or odd using modulus
number = 17
if number % 2 == 0:
    print(f"\n{number} is even")
else:
    print(f"\n{number} is odd")

# Comparison Operators Examples
print("=== Comparison Operators ===")

x = 10
y = 20

# Equal to
print(f"{x} == {y}: {x == y}")          # False
print(f"{x} == 10: {x == 10}")          # True

# Not equal to
print(f"{x} != {y}: {x != y}")          # True

# Greater than
print(f"{x} > {y}: {x > y}")            # False
print(f"{y} > {x}: {y > x}")            # True

# Less than
print(f"{x} < {y}: {x < y}")            # True

# Greater than or equal to
print(f"{x} >= 10: {x >= 10}")          # True
print(f"{x} >= 15: {x >= 15}")          # False

# Less than or equal to
print(f"{y} <= 20: {y <= 20}")          # True

# String comparison (lexicographic)
print("\n=== String Comparison ===")
name1 = "Alice"
name2 = "Bob"

print(f"'{name1}' < '{name2}': {name1 < name2}")    # True (A comes before B)
print(f"'apple' == 'Apple': {'apple' == 'Apple'}")  # False (case-sensitive)

# Chaining comparisons
print("\n=== Chained Comparisons ===")
age = 25
print(f"18 <= {age} <= 65: {18 <= age <= 65}")     # True
print(f"1 < 2 < 3 < 4: {1 < 2 < 3 < 4}")            # True

# Practical example: Grade checker
score = 85

if score >= 90:
    grade = 'A'
elif score >= 80:
    grade = 'B'
elif score >= 70:
    grade = 'C'
elif score >= 60:
    grade = 'D'
else:
    grade = 'F'

print(f"\nScore: {score}, Grade: {grade}")

# Password validation
password = "SecurePass123"
min_length = 8

if len(password) >= min_length:
    print(f"\nPassword length is valid ({len(password)} >= {min_length})")
else:
    print(f"\nPassword too short (minimum {min_length} characters)")

# Logical Operators Examples
print("=== Logical Operators ===")

# AND operator - both conditions must be True
print("\n--- AND Operator ---")
print(f"True and True: {True and True}")      # True
print(f"True and False: {True and False}")    # False
print(f"False and True: {False and True}")    # False
print(f"False and False: {False and False}")  # False

# OR operator - at least one condition must be True
print("\n--- OR Operator ---")
print(f"True or True: {True or True}")        # True
print(f"True or False: {True or False}")      # True
print(f"False or True: {False or True}")      # True
print(f"False or False: {False or False}")    # False

# NOT operator - inverts the Boolean value
print("\n--- NOT Operator ---")
print(f"not True: {not True}")                # False
print(f"not False: {not False}")              # True

# Practical examples
age = 25
has_license = True
has_insurance = True

print("\n=== Practical Examples ===")

# Check if person can drive
can_drive = age >= 18 and has_license
print(f"Can drive: {can_drive}")              # True

# Check if person can rent a car
can_rent = age >= 21 and has_license and has_insurance
print(f"Can rent car: {can_rent}")            # True

# Username validation
username = "Alice123"
min_length = 5
max_length = 20

is_valid = len(username) >= min_length and len(username) <= max_length
print(f"\nUsername '{username}' valid: {is_valid}")  # True

# Weekend checker
day = "Saturday"
is_weekend = day == "Saturday" or day == "Sunday"
print(f"Is {day} a weekend: {is_weekend}")    # True

# Short-circuit evaluation
print("\n=== Short-Circuit Evaluation ===")
x = 0
# The second condition is not evaluated because first is False
result = (x != 0) and (10 / x > 5)  # Safe: division not executed
print(f"Result: {result}")                    # False

# Complex condition
temperature = 25
is_raining = False
has_umbrella = True

go_outside = (temperature > 15 and temperature < 30) and (not is_raining or has_umbrella)
print(f"\nGo outside: {go_outside}")           # True

# Truth table demonstration
print("\n=== Combined Operations ===")
print(f"True and True or False: {True and True or False}")      # True
print(f"True and (True or False): {True and (True or False)}")  # True
print(f"not (True and False): {not (True and False)}")          # True
print(f"not True and False: {not True and False}")              # False

# Assignment Operators Examples
print("=== Assignment Operators ===")

# Basic assignment
x = 10
print(f"x = 10: x is {x}")

# Add and assign
x += 5   # Equivalent to: x = x + 5
print(f"x += 5: x is {x}")               # 15

# Subtract and assign
x -= 3   # Equivalent to: x = x - 3
print(f"x -= 3: x is {x}")               # 12

# Multiply and assign
x *= 2   # Equivalent to: x = x * 2
print(f"x *= 2: x is {x}")               # 24

# Divide and assign
x /= 4   # Equivalent to: x = x / 4
print(f"x /= 4: x is {x}")               # 6.0

# Floor divide and assign
x //= 2  # Equivalent to: x = x // 2
print(f"x //= 2: x is {x}")              # 3.0

# Modulus and assign
x = 10
x %= 3   # Equivalent to: x = x % 3
print(f"x %= 3: x is {x}")               # 1

# Exponent and assign
x = 2
x **= 3  # Equivalent to: x = x ** 3
print(f"x **= 3: x is {x}")              # 8

# Multiple assignment
a = b = c = 100
print(f"\nMultiple assignment: a={a}, b={b}, c={c}")

# Parallel assignment (unpacking)
x, y, z = 10, 20, 30
print(f"Parallel assignment: x={x}, y={y}, z={z}")

# Swapping values
a, b = 5, 10
print(f"\nBefore swap: a={a}, b={b}")
a, b = b, a  # Elegant swap without temp variable
print(f"After swap: a={a}, b={b}")

# Practical example: Counter
print("\n=== Counter Example ===")
count = 0
count += 1  # Increment
print(f"Count: {count}")
count += 1
print(f"Count: {count}")
count += 1
print(f"Count: {count}")

# Practical example: Score accumulation
print("\n=== Score Accumulation ===")
total_score = 0
total_score += 50  # First game
print(f"After game 1: {total_score}")
total_score += 75  # Second game
print(f"After game 2: {total_score}")
total_score += 100 # Third game
print(f"Final total: {total_score}")

# Bitwise Operators Examples
print("=== Bitwise Operators ===")

a = 60  # Binary: 0011 1100
b = 13  # Binary: 0000 1101

print(f"a = {a} (binary: {bin(a)})")
print(f"b = {b} (binary: {bin(b)})")

# Bitwise AND - sets bit to 1 if both bits are 1
result = a & b  # 0011 1100 & 0000 1101 = 0000 1100 = 12
print(f"\na & b = {result} (binary: {bin(result)})")

# Bitwise OR - sets bit to 1 if any bit is 1
result = a | b  # 0011 1100 | 0000 1101 = 0011 1101 = 61
print(f"a | b = {result} (binary: {bin(result)})")

# Bitwise XOR - sets bit to 1 if bits are different
result = a ^ b  # 0011 1100 ^ 0000 1101 = 0011 0001 = 49
print(f"a ^ b = {result} (binary: {bin(result)})")

# Bitwise NOT - inverts all bits
result = ~a  # ~0011 1100 = 1100 0011 = -61 (two's complement)
print(f"~a = {result} (binary: {bin(result)})")

# Left shift - shifts bits left, fills with zeros
result = a << 2  # 0011 1100 << 2 = 1111 0000 = 240
print(f"\na << 2 = {result} (binary: {bin(result)})")
print(f"Left shift by 2 is same as multiply by 4: {a} * 4 = {a * 4}")

# Right shift - shifts bits right, discards shifted bits
result = a >> 2  # 0011 1100 >> 2 = 0000 1111 = 15
print(f"a >> 2 = {result} (binary: {bin(result)})")
print(f"Right shift by 2 is same as divide by 4: {a} // 4 = {a // 4}")

# Practical example: Permission system
print("\n=== Permission System ===")
READ = 1    # Binary: 001
WRITE = 2   # Binary: 010
EXECUTE = 4 # Binary: 100

# Grant read and write permissions
user_permissions = READ | WRITE
print(f"User permissions: {user_permissions} (binary: {bin(user_permissions)})")

# Check if user has read permission
has_read = (user_permissions & READ) != 0
print(f"Has READ permission: {has_read}")

# Check if user has execute permission
has_execute = (user_permissions & EXECUTE) != 0
print(f"Has EXECUTE permission: {has_execute}")

# Add execute permission
user_permissions |= EXECUTE
print(f"\nAfter adding EXECUTE: {user_permissions} (binary: {bin(user_permissions)})")

# Remove write permission
user_permissions &= ~WRITE
print(f"After removing WRITE: {user_permissions} (binary: {bin(user_permissions)})")

# Fast multiplication/division using shifts
print("\n=== Fast Operations ===")
num = 10
print(f"Original: {num}")
print(f"Multiply by 2 (shift left 1): {num << 1}")   # 20
print(f"Multiply by 8 (shift left 3): {num << 3}")   # 80
print(f"Divide by 2 (shift right 1): {num >> 1}")    # 5
print(f"Divide by 4 (shift right 2): {num >> 2}")    # 2

# Identity Operators Examples
print("=== Identity Operators ===")

# Identity vs Equality
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print("list1:", list1, "id:", id(list1))
print("list2:", list2, "id:", id(list2))
print("list3:", list3, "id:", id(list3))

print(f"\nlist1 == list2: {list1 == list2}")  # True (same values)
print(f"list1 is list2: {list1 is list2}")    # False (different objects)
print(f"list1 is list3: {list1 is list3}")    # True (same object)

# Integer caching (Python optimization)
print("\n=== Integer Caching ===")
a = 256
b = 256
print(f"a = 256, b = 256")
print(f"a is b: {a is b}")  # True (cached for -5 to 256)

a = 257
b = 257
print(f"\na = 257, b = 257")
print(f"a is b: {a is b}")  # False (not cached)

# Checking for None (correct way)
print("\n=== Checking None ===")
value = None

# Correct: use 'is' for None
if value is None:
    print("Value is None (correct way)")

# Incorrect but works: use '==' for None
if value == None:
    print("Value is None (works but not recommended)")

# is not operator
name = "Alice"
if name is not None:
    print(f"\nName is not None: {name}")

# Practical example: Checking initialization
print("\n=== Checking Initialization ===")
data = None

if data is None:
    print("Data not initialized, creating new list")
    data = []

data.append(1)
data.append(2)
print(f"Data: {data}")

# String interning
print("\n=== String Interning ===")
str1 = "hello"
str2 = "hello"
print(f"str1 is str2: {str1 is str2}")  # True (interned)

str3 = "hello world"
str4 = "hello world"
print(f"str3 is str4: {str3 is str4}")  # May be True or False

# Best practice: Use == for value comparison, is for identity
print("\n=== Best Practices ===")
x = [1, 2]
y = [1, 2]

print(f"Use == for value comparison: x == y: {x == y}")    # True
print(f"Use 'is' for identity comparison: x is y: {x is y}")  # False
print(f"Always use 'is' for None: x is None: {x is None}")     # False

# Membership Operators Examples
print("=== Membership Operators ===")

# Testing membership in lists
fruits = ["apple", "banana", "cherry", "date"]

print("Fruits list:", fruits)
print(f"'apple' in fruits: {'apple' in fruits}")        # True
print(f"'orange' in fruits: {'orange' in fruits}")      # False
print(f"'orange' not in fruits: {'orange' not in fruits}")  # True

# Testing membership in strings
print("\n=== String Membership ===")
text = "Hello, World!"
print(f"Text: '{text}'")
print(f"'World' in text: {'World' in text}")            # True
print(f"'world' in text: {'world' in text}")            # False (case-sensitive)
print(f"'Python' in text: {'Python' in text}")          # False
print(f"'xyz' not in text: {'xyz' not in text}")        # True

# Testing membership in tuples
print("\n=== Tuple Membership ===")
coordinates = (10, 20, 30, 40)
print(f"Coordinates: {coordinates}")
print(f"20 in coordinates: {20 in coordinates}")        # True
print(f"25 in coordinates: {25 in coordinates}")        # False

# Testing membership in sets
print("\n=== Set Membership ===")
numbers = {1, 2, 3, 4, 5}
print(f"Numbers set: {numbers}")
print(f"3 in numbers: {3 in numbers}")                  # True
print(f"6 in numbers: {6 in numbers}")                  # False

# Testing membership in dictionaries (checks keys)
print("\n=== Dictionary Membership ===")
student = {"name": "Alice", "age": 20, "grade": "A"}
print(f"Student dict: {student}")
print(f"'name' in student: {'name' in student}")        # True
print(f"'address' in student: {'address' in student}")  # False
print(f"'Alice' in student: {'Alice' in student}")      # False (checks keys, not values)

# Check if value exists in dictionary values
print(f"'Alice' in student.values(): {'Alice' in student.values()}")  # True

# Practical example: Email validation
print("\n=== Email Validation ===")
email = "[email protected]"

if "@" in email and "." in email:
    print(f"{email} appears to be a valid email format")
else:
    print(f"{email} is not a valid email format")

# Practical example: Vowel counter
print("\n=== Vowel Counter ===")
text = "Hello World"
vowels = "aeiouAEIOU"
vowel_count = sum(1 for char in text if char in vowels)
print(f"Text: '{text}'")
print(f"Vowel count: {vowel_count}")

# Practical example: Access control
print("\n=== Access Control ===")
admin_users = ["alice", "bob", "charlie"]
current_user = "alice"

if current_user in admin_users:
    print(f"User '{current_user}' has admin access")
else:
    print(f"User '{current_user}' does not have admin access")

# Filter example
print("\n=== Filtering ===")
allowed_extensions = [".jpg", ".png", ".gif", ".pdf"]
filename = "document.pdf"

if any(filename.endswith(ext) for ext in allowed_extensions):
    print(f"{filename} has an allowed extension")
else:
    print(f"{filename} has an invalid extension")

# Checking multiple values
print("\n=== Multiple Value Check ===")
weekday = "Saturday"
weekends = ["Saturday", "Sunday"]

if weekday in weekends:
    print(f"{weekday} is a weekend day")
else:
    print(f"{weekday} is a weekday")

# Practical: Command processor
print("\n=== Command Processor ===")
valid_commands = ["start", "stop", "restart", "status"]
user_command = "start"

if user_command in valid_commands:
    print(f"Executing command: {user_command}")
else:
    print(f"Invalid command: {user_command}")
    print(f"Valid commands: {', '.join(valid_commands)}")

# Operator Precedence Examples
print("=== Operator Precedence ===")

# Precedence order (highest to lowest):
# 1. Parentheses: ()
# 2. Exponentiation: **
# 3. Unary: +x, -x, ~x
# 4. Multiplication, Division: *, /, //, %
# 5. Addition, Subtraction: +, -
# 6. Bitwise shifts: <<, >>
# 7. Bitwise AND: &
# 8. Bitwise XOR: ^
# 9. Bitwise OR: |
# 10. Comparison: ==, !=, >, <, >=, <=, is, is not, in, not in
# 11. Logical NOT: not
# 12. Logical AND: and
# 13. Logical OR: or

# Example 1: Mixed arithmetic
result = 2 + 3 * 4
print(f"2 + 3 * 4 = {result}")  # 14 (multiplication before addition)

result = (2 + 3) * 4
print(f"(2 + 3) * 4 = {result}")  # 20 (parentheses override)

# Example 2: Exponentiation and multiplication
result = 2 * 3 ** 2
print(f"\n2 * 3 ** 2 = {result}")  # 18 (3**2 = 9, then 2*9)

result = (2 * 3) ** 2
print(f"(2 * 3) ** 2 = {result}")  # 36

# Example 3: Comparison and logical operators
result = 5 > 3 and 10 < 20
print(f"\n5 > 3 and 10 < 20: {result}")  # True

result = 5 > 3 and 10 < 20 or False
print(f"5 > 3 and 10 < 20 or False: {result}")  # True

# Example 4: Complex expression
x = 10
y = 5
z = 2

result = x + y * z ** 2
print(f"\nx=10, y=5, z=2")
print(f"x + y * z ** 2 = {result}")  # 30 (z**2=4, y*4=20, x+20=30)

# Example 5: Using parentheses for clarity
a = 10
b = 20
c = 30

# Without parentheses (relies on precedence)
result = a + b * c / 2 - 5
print(f"\na + b * c / 2 - 5 = {result}")  # 305.0

# With parentheses (explicit and clear)
result = a + ((b * c) / 2) - 5
print(f"a + ((b * c) / 2) - 5 = {result}")  # 305.0

# Best practice: Use parentheses for readability
print("\n=== Best Practice ===")
age = 25
has_license = True

# Less clear
can_drive = age >= 18 and has_license == True
print(f"Can drive: {can_drive}")

# More clear with parentheses
can_drive = (age >= 18) and (has_license == True)
print(f"Can drive (clear): {can_drive}")

# Even better
can_drive = (age >= 18) and has_license
print(f"Can drive (best): {can_drive}")