Finally & Else

Intermediate ~25 min read

The finally clause guarantees code runs no matter what - whether an exception occurs, the code returns early, or breaks from a loop. The else clause runs only when no exception occurred. Together, they complete Python's exception handling toolkit, enabling robust resource management and clean code separation!

Finally Block Basics

The finally block always executes - when an exception occurs, when no exception occurs, even when the code uses return, break, or continue. This makes it perfect for cleanup code that must run no matter what happens.

# Finally Block Basics

print("=== Finally Block Basics ===\n")

# 1. Finally always runs - with exception
print("1. Finally runs even when exception occurs:")
try:
    print("   Try: About to raise exception")
    raise ValueError("Something went wrong")
except ValueError as e:
    print(f"   Except: Caught {e}")
finally:
    print("   Finally: This ALWAYS runs!")
print()

# 2. Finally always runs - without exception
print("2. Finally runs when no exception:")
try:
    print("   Try: No exception here")
    result = 10 + 5
    print(f"   Try: Result = {result}")
except ValueError:
    print("   Except: This won't run")
finally:
    print("   Finally: Still runs!")
print()

# 3. Finally runs even if except re-raises
print("3. Finally runs even when re-raising:")
try:
    try:
        raise RuntimeError("Original error")
    except RuntimeError:
        print("   Except: Catching and re-raising")
        raise  # Re-raise the exception
    finally:
        print("   Finally: Runs before exception propagates!")
except RuntimeError:
    print("   Outer: Caught the re-raised exception")
print()

# 4. Finally runs even with return
print("4. Finally runs even with return:")

def returns_early():
    try:
        print("   Try: About to return")
        return "returned value"
    finally:
        print("   Finally: Runs BEFORE return completes!")

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

# 5. Finally runs even with break in loops
print("5. Finally runs even with break:")
for i in range(3):
    try:
        if i == 1:
            print(f"   Try: Breaking at i={i}")
            break
        print(f"   Try: i={i}")
    finally:
        print(f"   Finally: i={i}")
print()

# 6. Order of execution
print("6. Execution order: try -> except/else -> finally")
print("   (See next section for else clause)")

Output

Click Run to execute your code

When Finally Runs:
- After try completes normally
- After except handles an exception
- Before return completes
- Before break or continue in loops
- Before an exception propagates up

Key insight: Finally runs BEFORE control leaves the try/except block!

Finally with Return Statements

When a function returns inside a try block, finally still runs - but there's a catch. If finally also has a return statement, it overrides the try's return! This is usually a bug, so avoid return statements in finally blocks.

# Finally with Return Statements

print("=== Finally with Return ===\n")

# 1. Return in try, finally runs first
print("1. Return in try block:")

def try_return():
    try:
        print("   Try: Returning 'from try'")
        return "from try"
    finally:
        print("   Finally: Executing before return")

result = try_return()
print(f"   Result: {result}")
print()

# 2. Return in finally OVERRIDES try's return
print("2. Return in finally overrides try:")

def finally_overrides():
    try:
        print("   Try: Returning 'from try'")
        return "from try"
    finally:
        print("   Finally: Returning 'from finally' instead!")
        return "from finally"  # This wins!

result = finally_overrides()
print(f"   Result: {result}")  # "from finally"!
print()

# 3. Return in finally suppresses exception!
print("3. Return in finally suppresses exception:")

def finally_suppresses_exception():
    try:
        print("   Try: Raising ValueError")
        raise ValueError("This will be suppressed!")
    finally:
        print("   Finally: Returning instead of propagating")
        return "exception was suppressed"

result = finally_suppresses_exception()
print(f"   Result: {result}")  # No exception raised!
print()

# 4. Modifying return value in finally - DOESN'T work
print("4. Modifying return value in finally (doesn't work):")

def try_modify_return():
    result = "original"
    try:
        result = "from try"
        return result
    finally:
        # This modification doesn't affect the return!
        result = "modified in finally"
        print(f"   Finally: Set result to '{result}'")

actual = try_modify_return()
print(f"   Actual return: '{actual}'")  # Still "from try"
print()

# 5. Best practice: avoid return in finally
print("5. Best practice - avoid return in finally:")

def proper_cleanup():
    resource = None
    try:
        resource = "acquired resource"
        # Do work...
        return "success"
    except Exception as e:
        return f"error: {e}"
    finally:
        # Cleanup only, no return!
        if resource:
            print(f"   Finally: Cleaning up {resource}")

result = proper_cleanup()
print(f"   Result: {result}")
print()

# 6. Warning summary
print("=== Warning ===")
print("""
Avoid these patterns in finally:
- return (overrides try's return)
- raise (replaces original exception)
- break/continue in loops

Finally should only do cleanup!
""")

Output

Click Run to execute your code

Avoid These in Finally!
- return - Overrides the try block's return value
- raise - Replaces the original exception
- break/continue - Overrides loop control

Finally should ONLY contain cleanup code - closing files, releasing locks, etc.

The Else Clause

The else clause runs only when no exception occurred in the try block. This lets you separate "code that might fail" from "code to run on success". It keeps your try block minimal and makes the code's intent clearer.

# The Else Clause in Try/Except

print("=== The Else Clause ===\n")

# 1. Basic else - runs only if NO exception
print("1. Else runs only when no exception:")
try:
    result = 10 / 2
    print(f"   Try: Calculated {result}")
except ZeroDivisionError:
    print("   Except: Division failed")
else:
    print("   Else: No exception occurred!")
    print(f"   Else: Can safely use result: {result}")
finally:
    print("   Finally: Always runs")
print()

# 2. Else does NOT run when exception occurs
print("2. Else skipped when exception occurs:")
try:
    result = 10 / 0  # Will raise exception
    print("   Try: This won't print")
except ZeroDivisionError:
    print("   Except: Caught division by zero")
else:
    print("   Else: This won't run!")
finally:
    print("   Finally: Still runs")
print()

# 3. Why use else? Keep try block minimal
print("3. Why else? Keeps try block minimal:")

def process_data(value):
    # BAD: too much in try block
    # try:
    #     number = int(value)
    #     squared = number ** 2
    #     result = squared * 100 / number  # What if THIS fails?
    # except ValueError:
    #     return "Invalid number"

# GOOD: only risky code in try
    try:
        number = int(value)  # Only this can raise ValueError
    except ValueError:
        return "Invalid number"
    else:
        # This code is safe from ValueError
        # But if it fails, we WANT to see the error!
        squared = number ** 2
        return f"{value} -> {squared}"

print(f"   process_data('5'): {process_data('5')}")
print(f"   process_data('x'): {process_data('x')}")
print()

# 4. Complete try/except/else/finally
print("4. Complete structure:")
print("""
try:
    # Code that might fail
    risky_operation()
except SomeError:
    # Handle the error
    handle_error()
else:
    # Only if NO exception
    process_success()
finally:
    # Always runs - cleanup
    cleanup()
""")

# 5. Practical example: File processing
print("5. Practical Example - File Processing:")

def read_config(filename):
    try:
        f = open(filename)
    except FileNotFoundError:
        print(f"   Config '{filename}' not found, using defaults")
        return {"setting": "default"}
    else:
        # Only runs if open succeeded
        print(f"   Reading config from '{filename}'")
        # Process file (any error here is NOT caught as FileNotFoundError)
        content = f.read()
        return {"setting": content[:20] if content else "empty"}
    finally:
        # Would close file if opened
        print("   Cleanup complete")

config = read_config("nonexistent.conf")
print(f"   Config: {config}")
print()

# 6. Execution order
print("6. Execution Order:")
print("   1. try block executes")
print("   2. If exception: except runs, else skipped")
print("   3. If no exception: else runs")
print("   4. finally ALWAYS runs last")

Output

Click Run to execute your code

Execution Order:
1. try - Runs first
2. except - Only if exception occurred
3. else - Only if NO exception occurred
4. finally - Always runs last

Why use else? Keep try blocks minimal - only wrap code that might fail!

Resource Management Patterns

The most common use of finally is resource cleanup - closing files, disconnecting from databases, releasing locks. But Python's with statement (context managers) is usually cleaner. Still, understanding the finally pattern helps when with isn't available.

# Resource Management with Finally

print("=== Resource Management ===\n")

# 1. Classic pattern: file handling
print("1. File Handling with Finally:")

def read_file_safely(filename):
    f = None
    try:
        f = open(filename, 'r')
        return f.read()
    except FileNotFoundError:
        return None
    finally:
        if f is not None:
            f.close()
            print(f"   Closed file: {filename}")

content = read_file_safely("nonexistent.txt")
print(f"   Content: {content}")
print()

# 2. Better: context manager (with statement)
print("2. Better Approach - Context Manager:")
print("""
# Instead of:
f = None
try:
    f = open(filename)
    data = f.read()
finally:
    if f:
        f.close()

# Use this:
with open(filename) as f:
    data = f.read()
# Automatically closed!
""")

# 3. Database connection pattern
print("3. Database Connection Pattern:")

class FakeDatabase:
    def __init__(self, name):
        self.name = name
        self.connected = False

def connect(self):
        self.connected = True
        print(f"   Connected to {self.name}")

def query(self, sql):
        if not self.connected:
            raise RuntimeError("Not connected!")
        if "error" in sql:
            raise ValueError("Query failed")
        return [{"id": 1, "name": "Alice"}]

def disconnect(self):
        self.connected = False
        print(f"   Disconnected from {self.name}")

def fetch_users(db):
    try:
        db.connect()
        users = db.query("SELECT * FROM users")
        return users
    except ValueError as e:
        print(f"   Query error: {e}")
        return []
    finally:
        db.disconnect()  # Always disconnect!

db = FakeDatabase("production")
users = fetch_users(db)
print(f"   Users: {users}")
print()

# 4. Lock pattern (threading)
print("4. Lock Pattern (Threading):")
print("""
import threading
lock = threading.Lock()

# With finally:
lock.acquire()
try:
    # Critical section
    do_work()
finally:
    lock.release()  # Always release!

# Better - use context manager:
with lock:
    do_work()
# Automatically released!
""")

# 5. Multiple resources
print("5. Multiple Resources:")

def process_files(input_name, output_name):
    infile = None
    outfile = None
    try:
        infile = open(input_name, 'r')
        outfile = open(output_name, 'w')
        # Process...
        outfile.write(infile.read().upper())
        return True
    except FileNotFoundError as e:
        print(f"   Error: {e}")
        return False
    finally:
        # Close both files
        if infile:
            infile.close()
            print("   Closed input file")
        if outfile:
            outfile.close()
            print("   Closed output file")

# Better with context managers:
print("\n   Better approach:")
print("""
with open(input_name) as infile, open(output_name, 'w') as outfile:
    outfile.write(infile.read().upper())
# Both automatically closed!
""")

# 6. Custom cleanup
print("6. Custom Cleanup Pattern:")

class Timer:
    def __init__(self, name):
        self.name = name
        self.start_time = None

def start(self):
        import time
        self.start_time = time.time()
        print(f"   Timer '{self.name}' started")

def stop(self):
        import time
        if self.start_time:
            elapsed = time.time() - self.start_time
            print(f"   Timer '{self.name}' stopped: {elapsed:.4f}s")

timer = Timer("processing")
try:
    timer.start()
    # Simulate work
    total = sum(range(100000))
except Exception as e:
    print(f"   Error: {e}")
finally:
    timer.stop()  # Always stop timer

print()
print("=== Key Takeaway ===")
print("Use 'with' statements when possible - they're cleaner than try/finally!")

Output

Click Run to execute your code

Prefer Context Managers:
with open(file) as f: - File automatically closed
with lock: - Lock automatically released
with connection: - Connection automatically closed

Use try/finally only when context managers aren't available or appropriate.

Common Mistakes

1. Returning in finally

# Wrong - return in finally overrides try's return!
def get_data():
    try:
        return fetch_from_server()
    finally:
        return None  # This ALWAYS returns None!

# Correct - only cleanup in finally
def get_data():
    connection = None
    try:
        connection = connect()
        return connection.fetch()
    finally:
        if connection:
            connection.close()  # Just cleanup, no return

2. Raising in finally (suppresses original)

# Wrong - new exception replaces original!
def process():
    try:
        raise ValueError("Original error")
    finally:
        raise RuntimeError("Cleanup failed")  # Original lost!

# Correct - log cleanup errors, don't raise
def process():
    try:
        raise ValueError("Original error")
    finally:
        try:
            cleanup()
        except Exception as e:
            logging.error(f"Cleanup failed: {e}")
            # Don't raise - let original propagate

3. Confusing else with finally

# Wrong - using else for cleanup
try:
    data = load_data()
except FileNotFoundError:
    data = default_data()
else:
    file.close()  # Wrong place! What if exception occurred?

# Correct - else for success-only code, finally for cleanup
try:
    data = load_data()
except FileNotFoundError:
    data = default_data()
else:
    process(data)  # Only runs on success
finally:
    file.close()  # Always runs

4. Too much code in try block

# Wrong - everything in try
try:
    f = open(filename)
    data = f.read()
    parsed = json.loads(data)
    result = process(parsed)
    save(result)
except Exception:
    print("Something failed")  # Which part?

# Correct - minimal try, use else for success path
try:
    f = open(filename)
except FileNotFoundError:
    print("File not found")
    f = None
else:
    try:
        data = f.read()
        parsed = json.loads(data)
    except json.JSONDecodeError:
        print("Invalid JSON")
    else:
        result = process(parsed)
        save(result)
finally:
    if f:
        f.close()

5. Not using context managers when available

# Verbose - manual try/finally
f = None
try:
    f = open(filename)
    data = f.read()
finally:
    if f:
        f.close()

# Better - context manager handles cleanup
with open(filename) as f:
    data = f.read()
# Automatically closed, even if exception occurs!

# For multiple resources
with open('in.txt') as infile, open('out.txt', 'w') as outfile:
    outfile.write(infile.read())

Exercise: Safe Database Query

Task: Create a function that safely queries a database with proper cleanup.

Requirements:

Connect to the database in try block
Use else for processing the results
Always disconnect in finally, even if errors occur
Return the results or an error message

# Exercise: Safe Database Query
# Task: Create a function that safely queries a database with proper cleanup.

# Requirements:
# 1. Connect to the database in try block
# 2. Use else for processing the results
# 3. Always disconnect in finally, even if errors occur
# 4. Return the results or an error message

class Database:
    """Simulated database for exercise."""
    def __init__(self, name):
        self.name = name
        self.connected = False

def connect(self):
        self.connected = True
        print(f"Connected to {self.name}")

def disconnect(self):
        if self.connected:
            self.connected = False
            print(f"Disconnected from {self.name}")

def query(self, sql):
        if not self.connected:
            raise RuntimeError("Not connected!")
        if "error" in sql.lower():
            raise ValueError("Query syntax error")
        return [{"id": 1}, {"id": 2}]

def safe_query(db, sql):
    """
    Safely query database with proper cleanup.
    Returns (success, result_or_error).
    """
    # Your code here:
    # 1. Try to connect
    # 2. Use else to query (only if connect succeeded)
    # 3. Use finally to always disconnect
    pass

# Test your function:
db = Database("production")
print("Test 1:", safe_query(db, "SELECT * FROM users"))
print("Test 2:", safe_query(db, "SELECT error FROM bad"))

Output

Click Run to execute your code

Show Solution

class Database:
    """Simulated database for exercise."""
    def __init__(self, name):
        self.name = name
        self.connected = False

    def connect(self):
        self.connected = True
        print(f"Connected to {self.name}")

    def disconnect(self):
        if self.connected:
            self.connected = False
            print(f"Disconnected from {self.name}")

    def query(self, sql):
        if not self.connected:
            raise RuntimeError("Not connected!")
        if "error" in sql.lower():
            raise ValueError("Query syntax error")
        return [{"id": 1}, {"id": 2}]


def safe_query(db, sql):
    """
    Safely query database with proper cleanup.
    Returns (success, result_or_error).
    """
    try:
        db.connect()
    except Exception as e:
        return (False, f"Connection failed: {e}")
    else:
        # Only runs if connect succeeded
        try:
            results = db.query(sql)
            return (True, results)
        except ValueError as e:
            return (False, f"Query failed: {e}")
    finally:
        # Always disconnect
        db.disconnect()


# Test the function
db = Database("production")

print("=== Test 1: Successful query ===")
success, result = safe_query(db, "SELECT * FROM users")
print(f"Success: {success}, Result: {result}\n")

print("=== Test 2: Failed query ===")
success, result = safe_query(db, "SELECT error FROM bad")
print(f"Success: {success}, Result: {result}\n")

print("=== Verify cleanup ===")
print(f"Database connected: {db.connected}")  # Should be False

Summary

finally: Always runs - perfect for cleanup code
else: Runs only when no exception occurred
Order: try → except (if error) OR else (if no error) → finally
finally with return: Runs before return, but avoid returning in finally
Don't in finally: return, raise, break, continue
Use else to: Keep try blocks minimal, separate success code
Resource management: Finally ensures cleanup happens
Prefer context managers: with is cleaner than try/finally

What's Next?

Now you know how to catch and clean up after exceptions. But what if you need to signal an error yourself? Next, we'll learn about raise to create and throw your own exceptions, and how to create custom exception classes for your specific error conditions!

Previous Try/Except

Next Raising Exceptions

Finally Block Basics

Finally with Return Statements

The Else Clause

Resource Management Patterns

Common Mistakes

1. Returning in finally

2. Raising in finally (suppresses original)

3. Confusing else with finally

4. Too much code in try block

5. Not using context managers when available

Exercise: Safe Database Query

Summary

What's Next?

Enjoying these tutorials?