Python: Exception Handling

# Basic try-except
try:
    result = 10 / 0
    print(f"Result: {result}")
except ZeroDivisionError:
    print("Cannot divide by zero!")

# Output:
# Cannot divide by zero!

# Handling a ValueError
try:
    number = int("hello")
    print(f"Number: {number}")
except ValueError:
    print("That's not a valid number!")

# Handling multiple types
try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print(f"Result: {result}")
except ValueError:
    print("That's not a valid number!")
except ZeroDivisionError:
    print("Cannot divide by zero!")

# Multiple except blocks
def divide_numbers(a, b):
    try:
        result = a / b
        return result
    except ZeroDivisionError:
        return "Cannot divide by zero!"
    except TypeError:
        return "Both arguments must be numbers!"

# Test the function
print(divide_numbers(10, 2))   # 5.0
print(divide_numbers(10, 0))   # Cannot divide by zero!
print(divide_numbers(10, "5")) # Both arguments must be numbers!

# Catching exceptions with the exception object
try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")  # Error: division by zero

# Combining multiple exceptions in one except
try:
    num = int("hello")
    result = 10 / num
except (ValueError, ZeroDivisionError) as e:
    print(f"Error occurred: {e}")

# Catching all exceptions
try:
    result = 10 / 0
except Exception as e:
    print(f"An error occurred: {e}")

# Using a bare except (not recommended)
try:
    result = 10 / 0
except:  # Catches everything
    print("Something went wrong")

# Catching specific exceptions first
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
except Exception as e:
    print(f"Some other error: {e}")

# When to use catch-all:
# 1. Logging errors
# 2. Cleaning up resources
# 3. Preventing crashes in critical applications

# Using the else block
try:
    number = int(input("Enter a number: "))
except ValueError:
    print("That's not a valid number!")
else:
    print(f"You entered: {number}")
    print("No errors occurred!")

# Why use else?
# 1. It separates error handling from success code
# 2. It prevents accidentally catching exceptions in the success code
# 3. It makes the code more readable

# Practical example
def read_file(filename):
    try:
        file = open(filename, "r")
    except FileNotFoundError:
        print(f"File '{filename}' not found!")
        return None
    else:
        content = file.read()
        file.close()
        return content
    finally:
        # Code that always runs (covered next)
        pass

# Using the finally block
try:
    file = open("data.txt", "r")
    content = file.read()
    print(content)
except FileNotFoundError:
    print("File not found!")
finally:
    print("This always runs!")
    # Clean up resources
    try:
        file.close()
    except:
        pass

# Finally without except
try:
    print("Trying something...")
    result = 10 / 2
finally:
    print("This always runs!")

# Output:
# Trying something...
# This always runs!

# Finally with an exception
try:
    print("Trying something...")
    result = 10 / 0
finally:
    print("This always runs!")
# This runs, then the exception is raised

# Raising a built-in exception
def divide(a, b):
    if b == 0:
        raise ValueError("Cannot divide by zero!")
    return a / b

# Using the function
try:
    result = divide(10, 0)
except ValueError as e:
    print(f"Error: {e}")

# Raising with a custom message
def check_age(age):
    if age < 0:
        raise ValueError("Age cannot be negative!")
    if age < 18:
        raise ValueError("Age must be 18 or older!")
    return "Access granted"

# Re-raising an exception
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Caught an error, re-raising...")
    raise  # Re-raises the same exception

# Raising a specific exception type
def get_value(index, data):
    if index < 0 or index >= len(data):
        raise IndexError("Index out of range!")
    return data[index]

# Creating a custom exception
class InvalidAgeError(Exception):
    """Raised when an age is invalid"""
    pass

class InsufficientFundsError(Exception):
    """Raised when an account doesn't have enough funds"""
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        super().__init__(f"Insufficient funds: balance {balance}, needed {amount}")

# Using custom exceptions
def validate_age(age):
    if age < 0:
        raise InvalidAgeError("Age cannot be negative!")
    if age > 150:
        raise InvalidAgeError("Age cannot be greater than 150!")
    return True

def withdraw(balance, amount):
    if amount > balance:
        raise InsufficientFundsError(balance, amount)
    return balance - amount

# Handling custom exceptions
try:
    validate_age(-5)
except InvalidAgeError as e:
    print(f"Age validation failed: {e}")

try:
    balance = 100
    new_balance = withdraw(balance, 150)
except InsufficientFundsError as e:
    print(f"Withdrawal failed: {e}")
    print(f"Balance: {e.balance}, Attempted: {e.amount}")

# 1. Be specific — catch only what you can handle
# GOOD
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

# AVOID
try:
    result = 10 / 0
except:  # Bare except
    print("Something went wrong")

# 2. Use finally for cleanup
# GOOD
try:
    file = open("data.txt", "r")
    content = file.read()
finally:
    file.close()  # Always closes the file

# 3. Don't swallow exceptions silently
# AVOID
try:
    risky_operation()
except:
    pass  # Silently ignores the error

# GOOD
try:
    risky_operation()
except Exception as e:
    print(f"Error occurred: {e}")  # At least logs it

# 4. Use custom exceptions for clarity
# GOOD
class ConfigurationError(Exception):
    pass

def load_config():
    raise ConfigurationError("Config file not found")

# 5. Keep try blocks small
# GOOD
try:
    result = divide(10, 2)
except ZeroDivisionError:
    print("Cannot divide by zero!")

# Try blocks should only contain code that might raise the exception