# Python Arithmetic Operators Demonstration

# Addition operator (+)
num1 = 10
num2 = 5
result_add = num1 + num2
print(f"Addition: {num1} + {num2} = {result_add}") # Output: 15

# Subtraction operator (-)
result_sub = num1 - num2
print(f"Subtraction: {num1} - {num2} = {result_sub}") # Output: 5

# Multiplication operator (*)
result_mul = num1 * num2
print(f"Multiplication: {num1} * {num2} = {result_mul}") # Output: 50

# Division operator (/)
# Always returns a float
result_div = num1 / num2
print(f"Division: {num1} / {num2} = {result_div}") # Output: 2.0

# Floor Division operator (//)
# Divides and returns the integer part of the quotient
# If operands are floats, result is float. If integers, result is integer.
result_floor_div_int = num1 // num2
print(f"Floor Division (int): {num1} // {num2} = {result_floor_div_int}") # Output: 2
result_floor_div_float = 10.5 // 2.0
print(f"Floor Division (float): 10.5 // 2.0 = {result_floor_div_float}") # Output: 5.0

# Modulo operator (%)
# Returns the remainder of the division
result_mod = num1 % num2
print(f"Modulo: {num1} % {num2} = {result_mod}") # Output: 0
# Example for non-zero remainder
result_mod_nonzero = 10 % 3
print(f"Modulo (non-zero): 10 % 3 = {result_mod_nonzero}") # Output: 1

# Exponentiation operator (**)
# Raises the first operand to the power of the second
result_exp = num1 ** 2 # 10 squared
print(f"Exponentiation: {num1} ** 2 = {result_exp}") # Output: 100
result_exp_cube = 2 ** 3 # 2 cubed
print(f"Exponentiation: 2 ** 3 = {result_exp_cube}") # Output: 8

# Order of Operations (Precedence Example)
# Python follows PEMDAS/BODMAS rules
complex_expression = 5 + 3 * 2 ** 2 - (10 / 5)
# Step 1: 2 ** 2 = 4
# Step 2: 3 * 4 = 12
# Step 3: 10 / 5 = 2.0
# Step 4: 5 + 12 - 2.0 = 17 - 2.0 = 15.0
print(f"Complex Expression (5 + 3 * 2 ** 2 - (10 / 5)): {complex_expression}") # Output: 15.0

# Python Comparison Operators Demonstration

# Equality operator (==)
x = 10
y = 10
is_equal = (x == y)
print(f"Is {x} equal to {y}? {is_equal}") # Output: True

z = 20
is_equal_false = (x == z)
print(f"Is {x} equal to {z}? {is_equal_false}") # Output: False

# Inequality operator (!=)
is_not_equal = (x != z)
print(f"Is {x} not equal to {z}? {is_not_equal}") # Output: True

# Greater than operator (>)
is_greater = (z > x)
print(f"Is {z} greater than {x}? {is_greater}") # Output: True

# Less than operator (<)
is_less = (x < z)
print(f"Is {x} less than {z}? {is_less}") # Output: True

# Greater than or equal to operator (>=)
is_greater_equal = (y >= x)
print(f"Is {y} greater than or equal to {x}? {is_greater_equal}") # Output: True

# Less than or equal to operator (<=)
is_less_equal = (x <= z)
print(f"Is {x} less than or equal to {z}? {is_less_equal}") # Output: True

# Chaining Comparison Operators
# Python allows chaining for concise range checks
age = 25
is_adult = (18 <= age <= 65)
print(f"Is age {age} an adult (18-65)? {is_adult}") # Output: True

temperature = 30
is_comfortable = (20 < temperature < 35)
print(f"Is temperature {temperature} comfortable (20-35)? {is_comfortable}") # Output: True

# Comparing different types (potential pitfalls)
# Python attempts to compare, but can lead to TypeErrors or unexpected results
print(f"'10' == 10? {'10' == 10}") # Output: False (string vs int)
# print(f"'abc' > 10? {'abc' > 10}") # This would raise a TypeError: '>' not supported between instances of 'str' and 'int'

# Best Practice: Ensure consistent types for comparison where possible
str_num = '10'
int_num = 10
print(f"int(str_num) == int_num? {int(str_num) == int_num}") # Output: True

# Python Logical Operators Demonstration

# Logical AND operator (and)
# Returns True if both operands are True
condition1 = True
condition2 = False
result_and_true = (condition1 and True)
print(f"True and True: {result_and_true}") # Output: True
result_and_false = (condition1 and condition2)
print(f"True and False: {result_and_false}") # Output: False

# Short-circuiting with 'and'
# The second expression (do_something_risky()) won't be evaluated if the first is False
def do_something_risky():
    print("Executing risky operation...")
    return True

# Example where short-circuit occurs:
# If x > 0 is False, do_something_risky() is skipped
x = 0
if x > 0 and do_something_risky():
    print("Condition met.")
else:
    print("Condition not met (x is not positive, or risky operation failed).")
# Output: Condition not met (x is not positive, or risky operation failed).

# Example where short-circuit does not occur:
# If x > 0 is True, do_something_risky() is executed
y = 5
if y > 0 and do_something_risky():
    print("Condition met.")
else:
    print("Condition not met.")
# Output: Executing risky operation...
#         Condition met.

# Logical OR operator (or)
# Returns True if at least one operand is True
result_or_true = (condition1 or condition2)
print(f"True or False: {result_or_true}") # Output: True
result_or_false = (False or False)
print(f"False or False: {result_or_false}") # Output: False

# Short-circuiting with 'or'
# The second expression (do_something_else()) won't be evaluated if the first is True
def do_something_else():
    print("Executing alternative operation...")
    return True

# Example where short-circuit occurs:
# If x < 0 is True, do_something_else() is skipped
x = -1
if x < 0 or do_something_else():
    print("Condition met.")
else:
    print("Condition not met.")
# Output: Condition met.

# Logical NOT operator (not)
# Inverts the Boolean value of the operand
result_not_true = (not condition1) # not True is False
print(f"Not True: {result_not_true}") # Output: False
result_not_false = (not condition2) # not False is True
print(f"Not False: {result_not_false}") # Output: True

# Truthiness and Falsiness
# Non-empty strings, non-zero numbers, non-empty lists/tuples/dicts are True
# Empty strings, 0, None, empty lists/tuples/dicts are False
print(f"'Hello' is True: {bool('Hello')}") # Output: True
print(f"'' is False: {bool('')}") # Output: False
print(f"10 is True: {bool(10)}") # Output: True
print(f"0 is False: {bool(0)}") # Output: False
print(f"not [] is True: {not []}") # Output: True (empty list is False, so not False is True)

# Combining logical and comparison operators
age = 17
has_license = True

if age >= 18 and has_license:
    print("Eligible to drive.")
else:
    print("Not eligible to drive.") # Output: Not eligible to drive.

# Python Operator Precedence and Associativity Demonstration

# Precedence Hierarchy (from highest to lowest relevant here):
# 1. Parentheses ()
# 2. Exponentiation (**)
# 3. Unary Plus, Unary Minus (~, +, -)
# 4. Multiplication, Division, Floor Division, Modulo (*, /, //, %)
# 5. Addition, Subtraction (+, -)
# 6. Comparison operators (==, !=, <, >, <=, >=, is, is not, in, not in)
# 7. Logical NOT (not)
# 8. Logical AND (and)
# 9. Logical OR (or)

# Example 1: Arithmetic Precedence
# (5 + 3) * 2 - 10 / 5 ** 2
# Step 1: 5 ** 2 = 25
# Step 2: 10 / 25 = 0.4
# Step 3: 5 + 3 = 8
# Step 4: 8 * 2 = 16
# Step 5: 16 - 0.4 = 15.6
result1 = (5 + 3) * 2 - 10 / 5 ** 2
print(f"Result 1: {result1}") # Output: 15.6

# Example 2: Logical Precedence (not > and > or)
# True or False and not False
# Step 1: not False = True
# Step 2: False and True = False
# Step 3: True or False = True
result2 = True or False and not False
print(f"Result 2 (True or False and not False): {result2}") # Output: True

# Explicit parentheses for clarity and correctness
result2_explicit = True or (False and (not False))
print(f"Result 2 (Explicit Parentheses): {result2_explicit}") # Output: True

# Example 3: Combining Arithmetic and Comparison
# 10 + 5 > 3 * 2 and 7 % 3 == 1
# Arithmetic first:
# 10 + 5 = 15
# 3 * 2 = 6
# 7 % 3 = 1
# Then comparisons:
# 15 > 6 = True
# 1 == 1 = True
# Finally logical:
# True and True = True
result3 = 10 + 5 > 3 * 2 and 7 % 3 == 1
print(f"Result 3 (10 + 5 > 3 * 2 and 7 % 3 == 1): {result3}") # Output: True

# Example 4: Associativity of Exponentiation (right-to-left)
# 2 ** 3 ** 2 is 2 ** (3 ** 2) = 2 ** 9 = 512
# It is NOT (2 ** 3) ** 2 = 8 ** 2 = 64
result_exp_assoc = 2 ** 3 ** 2
print(f"2 ** 3 ** 2 (right-to-left): {result_exp_assoc}") # Output: 512

# Example 5: Associativity of other operators (left-to-left, usually)
# 10 / 2 / 5 is (10 / 2) / 5 = 5 / 5 = 1.0
# It is NOT 10 / (2 / 5) = 10 / 0.4 = 25.0
result_div_assoc = 10 / 2 / 5
print(f"10 / 2 / 5 (left-to-right): {result_div_assoc}") # Output: 1.0

# Pitfall: Forgetting precedence can lead to subtle bugs
# Incorrect: if x > 10 and y == 5 or z < 0:
# Correct (clear): if (x > 10 and y == 5) or (z < 0):

# Python Operators: Best Practices and Common Pitfalls

# 1. Use parentheses for clarity, even if not strictly necessary due to precedence.
# Bad (ambiguous for humans): result = a + b * c > d and e or f
# Good (clear intent): result = ((a + (b * c)) > d) and e or f # Or even better, break it down

a = 10
b = 2
c = 3
d = 20
e = True
f = False

# Clearer expression with parentheses:
intermediate_calc = a + (b * c) # 10 + 6 = 16
comparison_result = intermediate_calc > d # 16 > 20 = False
final_result = comparison_result and e or f # False and True or False => False or False => False
print(f"Clarity with parentheses: {final_result}") # Output: False

# 2. Understand integer vs. float division.
int_div_result = 7 / 2
print(f"7 / 2 (float division): {int_div_result}") # Output: 3.5

floor_div_result = 7 // 2
print(f"7 // 2 (floor division): {floor_div_result}") # Output: 3

# Pitfall: Division by zero
# Uncommenting the line below will cause a ZeroDivisionError
# error_case = 10 / 0 
# print(error_case)

# Best Practice: Handle potential division by zero
denominator = 0
if denominator != 0:
    result_safe_div = 10 / denominator
    print(f"Safe division: {result_safe_div}")
else:
    print("Error: Cannot divide by zero.") # Output: Error: Cannot divide by zero.

# 3. Leverage short-circuiting for efficiency and safety.
def get_user_input():
    print("Prompting for user input...")
    # Simulate user input
    return 'admin'

user_is_authenticated = False # Imagine this comes from a login check
user_role = None

# Short-circuiting prevents calling get_user_input() if user_is_authenticated is False
if user_is_authenticated and get_user_input() == 'admin':
    print("Access granted to admin panel.")
else:
    print("Access denied or not admin.") # Output: Access denied or not admin.

# Now, if authenticated (first part is True), get_user_input() is called
user_is_authenticated = True
if user_is_authenticated and get_user_input() == 'admin':
    print("Access granted to admin panel.") # Output: Prompting for user input...
                                          #         Access granted to admin panel.
else:
    print("Access denied or not admin.")

# 4. Be mindful of truthiness/falsiness, especially with 'not'.
my_list = []

if not my_list: # my_list is falsy, so not my_list is True
    print("The list is empty.") # Output: The list is empty.

my_string = ""
if not my_string:
    print("The string is empty.") # Output: The string is empty.

my_value = None
if my_value is None: # Explicit check for None is generally clearer
    print("Value is None.")

# Pitfall: Using 'not' with numerical values when specific checks are needed
count = 0
if not count: # This evaluates to True because 0 is falsy
    print("Count is zero (or falsy).") # Output: Count is zero (or falsy).

# For specific zero check:
if count == 0:
    print("Count is exactly zero.") # Output: Count is exactly zero.

# 5. Avoid comparing different types with ordering operators when possible.
# print(5 > '3') # TypeError: '>' not supported between instances of 'int' and 'str'

# Best Practice: Explicit type conversion
str_num = '3'
if 5 > int(str_num):
    print(f"5 > {str_num} is True.") # Output: 5 > 3 is True.