Try/Except

Intermediate ~30 min read

The try/except block is Python's primary mechanism for handling exceptions. Instead of crashing when an error occurs, you can catch the exception, handle it gracefully, and keep your program running. This is essential for building robust applications that handle unexpected situations - from invalid user input to network failures!

Basic Try/Except

The basic structure is simple: code that might fail goes in the try block, and the error handling code goes in the except block. When an exception occurs in the try block, Python immediately jumps to the except block. If no exception occurs, the except block is skipped entirely.

# Basic Try/Except

print("=== Basic Try/Except ===\n")

# 1. Without exception handling - program crashes
print("1. Without try/except (would crash):")
print("   # result = 10 / 0  <- This crashes the program!")
print()

# 2. With try/except - program continues
print("2. With try/except (graceful handling):")
try:
    result = 10 / 0
except ZeroDivisionError:
    print("   Caught: Cannot divide by zero!")

print("   Program continues running!")
print()

# 3. Code that doesn't raise exception
print("3. When no exception occurs:")
try:
    result = 10 / 2
    print(f"   Result: {result}")
except ZeroDivisionError:
    print("   This won't run - no error!")
print()

# 4. Try block can have multiple lines
print("4. Multiple lines in try block:")
try:
    x = 5
    y = 10
    z = x + y
    result = z / x  # Last line might fail
    print(f"   Calculation result: {result}")
except ZeroDivisionError:
    print("   Division failed!")
print()

# 5. Only the failing line skips to except
print("5. Exception stops try block execution:")
try:
    print("   Line 1 - runs")
    print("   Line 2 - runs")
    result = 1 / 0  # Exception here!
    print("   Line 3 - SKIPPED!")
    print("   Line 4 - SKIPPED!")
except ZeroDivisionError:
    print("   Caught exception!")

print("   After try/except - program continues")
print()

# 6. Basic syntax template
print("=== Syntax Template ===")
print("""
try:
    # Code that might fail
    risky_operation()
except SomeException:
    # Handle the error
    print("Something went wrong")

# Code here runs regardless
continue_program()
""")

Output

Click Run to execute your code

How Try/Except Works:
1. Python executes code in the try block
2. If an exception occurs, execution jumps to the matching except block
3. If no exception occurs, the except block is skipped
4. Either way, code after try/except continues normally

Key insight: Only lines after the exception are skipped in try block - lines before it still run!

Multiple Except Clauses

Different errors require different handling. You can have multiple except clauses, each catching a specific exception type. Python checks them in order and runs the first matching handler. You can also catch multiple exception types in a single clause using a tuple.

# Multiple Except Clauses

print("=== Multiple Except Clauses ===\n")

# 1. Different handlers for different exceptions
print("1. Handling different exception types:")

def process_input(value):
    try:
        number = int(value)
        result = 100 / number
        return result
    except ValueError:
        print(f"   ValueError: '{value}' is not a valid number")
    except ZeroDivisionError:
        print("   ZeroDivisionError: Cannot divide by zero")
    return None

process_input("hello")  # ValueError
process_input("0")      # ZeroDivisionError
result = process_input("5")  # Success
print(f"   Success: {result}")
print()

# 2. Catching multiple exceptions in one clause
print("2. One handler for multiple exceptions:")
try:
    # This could raise either exception
    data = [1, 2, 3]
    value = data[10]  # IndexError
except (IndexError, KeyError):
    print("   Caught IndexError or KeyError")
print()

# 3. Order matters! Specific before general
print("3. Exception order (specific first):")

def divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        print("   Specific: Division by zero")
        return None
    except ArithmeticError:
        print("   General: Math error")
        return None

divide(10, 0)  # Matches ZeroDivisionError first
print()

# 4. Catch-all with Exception
print("4. Catch-all (use sparingly!):")
try:
    # Unknown what might fail
    risky = {}["missing"]
except KeyError:
    print("   Specific: Key not found")
except Exception as e:
    print(f"   Catch-all: {type(e).__name__}: {e}")
print()

# 5. Handling exceptions from function calls
print("5. Exceptions from nested functions:")

def step1():
    return int("not a number")

def step2():
    return step1()

def step3():
    return step2()

try:
    step3()
except ValueError:
    print("   Caught ValueError from deep in call stack")
print()

# 6. Pattern: User input validation
print("6. User Input Pattern:")

def get_number(prompt_text="Enter number: "):
    user_input = "42"  # Simulating input
    try:
        return int(user_input)
    except ValueError:
        print(f"   Invalid: '{user_input}' is not a number")
        return None

result = get_number()
print(f"   Got: {result}")

Output

Click Run to execute your code

Order Matters! Put specific exceptions before general ones. If you catch Exception first, more specific handlers will never run because Exception catches everything. Python uses the first matching handler, not the most specific one.

Accessing Exception Details

Use as to capture the exception object and access its details. Different exception types have different attributes - FileNotFoundError has filename, KeyError has args[0] for the missing key. You can also re-raise exceptions after logging them.

# Accessing Exception Details

print("=== Accessing Exception Info ===\n")

# 1. Using 'as' to capture the exception
print("1. Capture exception with 'as':")
try:
    result = int("hello")
except ValueError as e:
    print(f"   Exception object: {e}")
    print(f"   Type: {type(e).__name__}")
    print(f"   Args: {e.args}")
print()

# 2. Different exceptions have different attributes
print("2. Exception-specific attributes:")

# FileNotFoundError has filename
try:
    open("nonexistent.txt")
except FileNotFoundError as e:
    print(f"   FileNotFoundError:")
    print(f"   - Message: {e}")
    print(f"   - Filename: {e.filename}")
    print(f"   - Errno: {e.errno}")
print()

# KeyError includes the missing key
try:
    data = {"name": "Alice"}
    value = data["age"]
except KeyError as e:
    print(f"   KeyError:")
    print(f"   - Missing key: {e.args[0]}")
print()

# 3. String representation vs args
print("3. str(e) vs e.args:")
try:
    x = 1 / 0
except ZeroDivisionError as e:
    print(f"   str(e): '{e}'")
    print(f"   e.args: {e.args}")
    print(f"   repr(e): {repr(e)}")
print()

# 4. Re-raise after logging
print("4. Log and re-raise:")
def process_data():
    try:
        return int("invalid")
    except ValueError as e:
        print(f"   Logging error: {e}")
        raise  # Re-raise the same exception

try:
    process_data()
except ValueError:
    print("   Caught re-raised exception")
print()

# 5. Get exception type name dynamically
print("5. Dynamic exception handling:")

def handle_any_exception(func):
    try:
        return func()
    except Exception as e:
        error_type = type(e).__name__
        error_msg = str(e)
        print(f"   {error_type}: {error_msg}")
        return None

handle_any_exception(lambda: 1 / 0)
handle_any_exception(lambda: int("x"))
handle_any_exception(lambda: [1][5])
print()

# 6. Exception chaining info
print("6. Exception with context:")
try:
    try:
        x = int("bad")
    except ValueError:
        raise RuntimeError("Conversion failed")
except RuntimeError as e:
    print(f"   Exception: {e}")
    print(f"   Caused by: {e.__context__}")

Output

Click Run to execute your code

Useful Exception Attributes:
str(e) - Human-readable error message
e.args - Tuple of arguments passed to exception
type(e).__name__ - Exception class name as string
repr(e) - Debug representation with class name
e.__context__ - Original exception if this was raised during handling another

Common Error Handling Patterns

Exception handling isn't just about catching errors - it's about handling them intelligently. These patterns appear frequently in production code: safe file reading, type conversion with defaults, retry logic for flaky operations, and user-friendly error messages.

# Common Try/Except Patterns

print("=== Common Patterns ===\n")

# 1. Pattern: Safe file reading
print("1. Safe File Reading:")

def read_file_safe(filename):
    try:
        with open(filename, 'r') as f:
            return f.read()
    except FileNotFoundError:
        print(f"   File not found: {filename}")
        return None
    except PermissionError:
        print(f"   Permission denied: {filename}")
        return None

content = read_file_safe("missing.txt")
print(f"   Content: {content}")
print()

# 2. Pattern: Safe type conversion
print("2. Safe Type Conversion:")

def safe_int(value, default=0):
    """Convert to int, return default on failure."""
    try:
        return int(value)
    except (ValueError, TypeError):
        return default

print(f"   safe_int('42'): {safe_int('42')}")
print(f"   safe_int('abc'): {safe_int('abc')}")
print(f"   safe_int(None): {safe_int(None)}")
print(f"   safe_int('x', -1): {safe_int('x', -1)}")
print()

# 3. Pattern: Safe dictionary access
print("3. Safe Dictionary Access:")

data = {"name": "Alice", "age": 30}

# Method 1: Try/except
def get_key_try(d, key):
    try:
        return d[key]
    except KeyError:
        return None

# Method 2: dict.get() - usually better!
def get_key_get(d, key):
    return d.get(key)

print(f"   try/except: {get_key_try(data, 'city')}")
print(f"   dict.get(): {get_key_get(data, 'city')}")
print()

# 4. Pattern: Retry on failure
print("4. Retry Pattern:")

import random

def unreliable_operation():
    if random.random() < 0.7:  # 70% failure rate
        raise ConnectionError("Network timeout")
    return "Success!"

def retry(func, max_attempts=3):
    for attempt in range(1, max_attempts + 1):
        try:
            return func()
        except ConnectionError as e:
            print(f"   Attempt {attempt} failed: {e}")
            if attempt == max_attempts:
                raise
    return None

random.seed(42)  # For reproducibility
try:
    result = retry(unreliable_operation)
    print(f"   Result: {result}")
except ConnectionError:
    print("   All attempts failed!")
print()

# 5. Pattern: Context-specific error messages
print("5. User-Friendly Messages:")

def process_config(filename):
    try:
        with open(filename) as f:
            import json
            return json.load(f)
    except FileNotFoundError:
        raise ValueError(f"Config file '{filename}' not found. "
                        "Please create it or specify a valid path.")
    except json.JSONDecodeError as e:
        raise ValueError(f"Config file '{filename}' contains invalid JSON "
                        f"at line {e.lineno}: {e.msg}")

try:
    config = process_config("config.json")
except ValueError as e:
    print(f"   {e}")
print()

# 6. Pattern: Cleanup on exception
print("6. Cleanup Pattern:")

class Database:
    def connect(self):
        print("   Connected to database")
    def close(self):
        print("   Closed database connection")
    def query(self, sql):
        if "DROP" in sql:
            raise PermissionError("DROP not allowed!")
        return [{"id": 1}]

db = Database()
try:
    db.connect()
    result = db.query("DROP TABLE users")
except PermissionError as e:
    print(f"   Error: {e}")
finally:
    db.close()  # Always cleanup!

Output

Click Run to execute your code

Pattern Summary:
Safe File Reading - Return None or default on file errors
Safe Type Conversion - Convert with fallback: safe_int("x", 0)
Retry Pattern - Retry flaky operations N times before giving up
User-Friendly Messages - Convert technical errors to helpful messages
Cleanup Pattern - Use finally to ensure cleanup always happens

Common Mistakes

1. Using bare except

# Wrong - catches EVERYTHING including Ctrl+C!
try:
    risky_operation()
except:  # Bare except - NEVER do this!
    pass  # Silently swallows all errors

# Wrong - too broad, hides bugs
try:
    risky_operation()
except Exception:
    pass  # Still catches too much

# Correct - catch specific exceptions
try:
    risky_operation()
except ValueError:
    print("Invalid value")
except ConnectionError:
    print("Network failed")

2. Catching exceptions in wrong order

# Wrong - FileNotFoundError is never reached!
try:
    open("missing.txt")
except OSError:
    print("OS error")  # This catches FileNotFoundError too
except FileNotFoundError:
    print("File not found")  # NEVER RUNS - dead code!

# Correct - specific exceptions first
try:
    open("missing.txt")
except FileNotFoundError:
    print("File not found")  # Specific first
except OSError:
    print("Other OS error")  # General second

3. Swallowing exceptions silently

# Wrong - error disappears, debugging nightmare!
def get_user(user_id):
    try:
        return database.fetch(user_id)
    except:
        return None  # What went wrong? Nobody knows!

# Correct - at least log the error
import logging

def get_user(user_id):
    try:
        return database.fetch(user_id)
    except DatabaseError as e:
        logging.error(f"Failed to fetch user {user_id}: {e}")
        return None

4. Using exceptions for flow control

# Wrong - slow and unclear, exceptions aren't for flow control
def find_item(items, target):
    try:
        return items.index(target)
    except ValueError:
        return -1

# Also wrong for dictionaries
try:
    value = my_dict[key]
except KeyError:
    value = default

# Correct - use built-in methods
def find_item(items, target):
    return items.index(target) if target in items else -1

# Correct for dictionaries
value = my_dict.get(key, default)

5. Too much code in try block

# Wrong - too much in try, unclear what might fail
try:
    data = load_config()
    processed = process_data(data)
    result = calculate(processed)
    save_result(result)
    send_notification()
except Exception as e:
    print(f"Something failed: {e}")  # Which operation?

# Correct - minimal try blocks, clear error handling
try:
    data = load_config()
except FileNotFoundError:
    data = default_config()

try:
    processed = process_data(data)
    result = calculate(processed)
except ValueError as e:
    print(f"Invalid data: {e}")
    return

save_result(result)  # Let this fail if it fails

Exercise: Safe Calculator

Task: Create a calculator function that handles all possible errors gracefully.

Requirements:

Handle division by zero
Handle invalid number inputs
Handle unknown operations
Return a tuple of (success, result_or_error)

Output

Click Run to execute your code

Show Solution

def safe_calculate(a, b, operation):
    """
    Safely perform calculation with full error handling.
    Returns (True, result) on success, (False, error_msg) on failure.
    """
    # Convert inputs to numbers
    try:
        num_a = float(a)
        num_b = float(b)
    except (ValueError, TypeError) as e:
        return (False, f"Invalid number: {e}")

    # Perform operation
    operations = {
        '+': lambda x, y: x + y,
        '-': lambda x, y: x - y,
        '*': lambda x, y: x * y,
        '/': lambda x, y: x / y,
        '**': lambda x, y: x ** y,
    }

    if operation not in operations:
        return (False, f"Unknown operation: {operation}")

    try:
        result = operations[operation](num_a, num_b)
        return (True, result)
    except ZeroDivisionError:
        return (False, "Cannot divide by zero")
    except OverflowError:
        return (False, "Result too large")


# Test the calculator
test_cases = [
    (10, 5, '+'),      # Normal addition
    (10, 0, '/'),      # Division by zero
    ('abc', 5, '+'),   # Invalid input
    (10, 5, '%'),      # Unknown operation
    (2, 1000, '**'),   # Large exponent (might overflow)
    ('10', '3', '-'),  # String numbers (should work)
]

print("=== Safe Calculator Tests ===\n")
for a, b, op in test_cases:
    success, result = safe_calculate(a, b, op)
    status = "OK" if success else "ERR"
    print(f"{a} {op} {b} => [{status}] {result}")

Summary

try/except: Code in try runs; if it fails, except handles the error
Specific exceptions: Always catch specific types, not bare except
Multiple except: Handle different errors differently, specific first
as keyword: Capture exception: except ValueError as e
Exception attributes: str(e), e.args, type(e).__name__
Tuple syntax: except (TypeError, ValueError) for multiple types
Re-raise: Use bare raise to re-raise after logging
Keep try blocks small: Only wrap code that might fail
Don't swallow errors: At minimum, log what went wrong

What's Next?

Now you know how to catch exceptions, but what about cleanup code that must always run? And what if you want to do something only when no exception occurs? Next, we'll learn about finally for guaranteed cleanup and else for success-only code - completing your exception handling toolkit!

Previous Exceptions Basics

Next Finally & Else

Basic Try/Except

Multiple Except Clauses

Accessing Exception Details

Common Error Handling Patterns

Common Mistakes

1. Using bare except

2. Catching exceptions in wrong order

3. Swallowing exceptions silently

4. Using exceptions for flow control

5. Too much code in try block

Exercise: Safe Calculator

Summary

What's Next?

Enjoying these tutorials?