How to Use Try, Except, Else, and Finally in Python

# Basic try block structure
try:
    # Risky code goes here
    user_input = input("Enter a number: ")
    number = int(user_input)
    result = 100 / number
    print(f"Result: {result}")
except:
    print("Something went wrong!")

# Specific exception handling
try:
    number = int(input("Enter a number: "))
    result = 100 / number
except ValueError:
    print("Please enter a valid number!")
except ZeroDivisionError:
    print("Cannot divide by zero!")

# General exception handling
try:
    risky_operation()
except Exception as e:
    print(f"An error occurred: {e}")

# Method 1: Multiple except blocks
try:
    data = eval(input("Enter an expression: "))
    result = data[0] / data[1]
except ZeroDivisionError:
    print("Division by zero!")
except IndexError:
    print("Not enough values!")
except TypeError:
    print("Invalid data type!")

# Method 2: Tuple of exceptions
try:
    risky_operation()
except (ValueError, TypeError, ZeroDivisionError):
    print("One of several expected errors occurred")

# Method 3: Exception hierarchy
try:
    risky_operation()
except ValueError:
    print("Value error occurred")
except Exception:
    print("Some other error occurred")

# Example of else block usage
try:
    file = open("data.txt", "r")
except FileNotFoundError:
    print("File not found!")
else:
    # This runs only if file opened successfully
    print("File opened successfully!")
    content = file.read()
    print(f"File content: {content}")
    file.close()

try:
    file = open("important_data.txt", "r")
    data = file.read()
    process_data(data)
except FileNotFoundError:
    print("File not found")
except Exception as e:
    print(f"Error processing file: {e}")
finally:
    # This always runs, ensuring file is closed
    if 'file' in locals() and not file.closed:
        file.close()
        print("File closed successfully")

import sqlite3

connection = None
try:
    connection = sqlite3.connect("database.db")
    cursor = connection.cursor()
    cursor.execute("SELECT * FROM users")
    results = cursor.fetchall()
except sqlite3.Error as e:
    print(f"Database error: {e}")
finally:
    # Always close the database connection
    if connection:
        connection.close()
        print("Database connection closed")

import time

start_time = time.time()
try:
    # Some time-consuming operation
    complex_calculation()
except Exception as e:
    print(f"Operation failed: {e}")
finally:
    # Always log the execution time
    end_time = time.time()
    execution_time = end_time - start_time
    print(f"Operation took {execution_time:.2f} seconds")

# Complete exception handling structure
def process_user_data(filename):
    file_handle = None
    
    try:
        # Step 1: Attempt risky operations
        print("Opening file...")
        file_handle = open(filename, "r")
        
        print("Reading data...")
        raw_data = file_handle.read()
        
        print("Processing data...")
        processed_data = json.loads(raw_data)
        
        # Simulate data validation
        if not processed_data.get("users"):
            raise ValueError("No users found in data")
            
    except FileNotFoundError:
        # Step 2A: Handle specific exceptions
        print(f"Error: File '{filename}' not found")
        return None
        
    except json.JSONDecodeError:
        print("Error: Invalid JSON format")
        return None
        
    except ValueError as e:
        print(f"Data validation error: {e}")
        return None
        
    except Exception as e:
        print(f"Unexpected error: {e}")
        return None
        
    else:
        # Step 3: Success-only operations
        print("Data processed successfully!")
        print(f"Found {len(processed_data['users'])} users")
        return processed_data
        
    finally:
        # Step 4: Cleanup (always runs)
        if file_handle and not file_handle.closed:
            file_handle.close()
            print("File closed")
        print("Processing attempt completed")

try:
    try:
        risky_operation()
    except ValueError as e:
        # Chain exceptions to preserve error context
        raise RuntimeError("Operation failed") from e
except RuntimeError as e:
    print(f"Error: {e}")
    print(f"Original cause: {e.__cause__}")

# Handle multiple exceptions simultaneously
try:
    errors = []
    for item in items:
        try:
            process_item(item)
        except Exception as e:
            errors.append(e)
    
    if errors:
        raise ExceptionGroup("Multiple errors occurred", errors)
        
except* ValueError as eg:
    for error in eg.exceptions:
        print(f"Value error: {error}")
        
except* TypeError as eg:
    for error in eg.exceptions:
        print(f"Type error: {error}")

import time
import random

def retry_operation(max_attempts=3, delay=1):
    for attempt in range(max_attempts):
        try:
            result = unreliable_network_call()
            return result
        except ConnectionError as e:
            if attempt == max_attempts - 1:
                print(f"Failed after {max_attempts} attempts")
                raise
            print(f"Attempt {attempt + 1} failed, retrying in {delay}s...")
            time.sleep(delay)
            delay *= 2  # Exponential backoff

try:
    result = retry_operation()
    print(f"Success: {result}")
except ConnectionError:
    print("Operation failed permanently")