Python finally

Learning Objectives

By the end of this lesson, you will understand how the finally block works and when it should be used in real Python programs.

What Is finally?

The finally block is part of Python's exception-handling system.

Its most important feature is that it normally runs whether an exception occurs or not.

A basic structure looks like this:

try:
    # Code that might fail

except SomeException:
    # Handle the exception

finally:
    # Code that should run afterward

Why Use finally?

Programs often acquire resources temporarily. Examples include:

• Opening a file
• Connecting to a database
• Opening a network connection
• Acquiring a lock
• Starting a temporary operation
• Creating temporary resources

Once the operation is finished, these resources may need to be released.

Basic finally Syntax

The simplest form uses try followed by finally.

try:
    print("Starting operation")

finally:
    print("Cleanup operation")

Starting operation
Cleanup operation

Notice that there is no except block here. Python allows try to be followed directly by finally.

When No Exception Occurs

If the code inside try succeeds, Python still executes finally.

try:
    number = 10
    print("Number:", number)

finally:
    print("Operation finished.")

Number: 10
Operation finished.

The operation succeeded, but the cleanup section still executed.

When an Error Occurs

The finally block also runs when an exception occurs.

try:
    number = 10 / 0

finally:
    print("Cleanup executed.")

Cleanup executed.

After the finally block executes, the unhandled ZeroDivisionError can continue upward and produce a traceback.

try / except / finally

The most common complete structure combines all three blocks.

try:
    number = int("abc")
    print(number)

except ValueError:
    print("Invalid number.")

finally:
    print("Program section finished.")

Invalid number.
Program section finished.

else + finally

Python allows all three optional components to work together:

try:
    number = int("25")

except ValueError:
    print("Invalid input.")

else:
    print("Conversion successful.")

finally:
    print("Finished.")

Conversion successful.
Finished.

The three blocks have different responsibilities:

Cleanup Operations

Cleanup means returning your program or environment to an appropriate state after an operation.

Examples include:

• Closing a resource
• Releasing a lock
• Closing a connection
• Deleting temporary resources
• Writing final log information
• Resetting temporary state

try:
    print("Processing data...")

except Exception as error:
    print("Something went wrong:", error)

finally:
    print("Cleaning up resources...")

The cleanup message is intended to represent work that should happen after the main operation.

Using finally with Files

Before Python's with statement became the preferred way to manage files, developers commonly used finally to make sure files were closed.

file = None

try:
    file = open("students.txt", "r", encoding="utf-8")
    data = file.read()
    print(data)

except FileNotFoundError:
    print("File not found.")

finally:
    if file is not None:
        file.close()

    print("File operation finished.")

with open("students.txt", "r", encoding="utf-8") as file:
    data = file.read()

print(data)

Understanding finally is still important because the same cleanup principle applies to many resources beyond simple file reading.

Resource Management

A resource is something your program temporarily acquires and should eventually release.

Examples include:

Failing to release resources can cause problems such as resource leaks, locked files, connection exhaustion or unexpected application behavior.

finally and return

The interaction between finally and return is important.

The finally block executes before a function actually returns.

def example():
    try:
        return "Returning from try"

    finally:
        print("Finally runs first.")

print(example())

Finally runs first.
Returning from try

Nested finally

Exception-handling structures can be nested when complex resource management requires it.

try:
    print("Outer try")

    try:
        print("Inner try")

    finally:
        print("Inner cleanup")

finally:
    print("Outer cleanup")

Outer try
Inner try
Inner cleanup
Outer cleanup

The inner finally executes when the inner operation finishes, followed by the outer cleanup.

Real-World Examples

Example 1 — Database Connection

A database application may need to close a connection after an operation.

connection = None

try:
    connection = connect_to_database()
    perform_query(connection)

except DatabaseError:
    print("Database operation failed.")

finally:
    if connection is not None:
        connection.close()

Example 2 — Processing a Report

try:
    print("Generating report...")
    generate_report()

except Exception as error:
    print("Report failed:", error)

finally:
    print("Report process ended.")

Example 3 — Releasing a Lock

lock.acquire()

try:
    update_shared_data()

finally:
    lock.release()

Common Mistakes

1. Thinking finally Handles Exceptions

It does not. finally performs final cleanup. An except block handles a matching exception.

2. Returning from finally

Avoid this because it can override previous return values and suppress exceptions.

3. Using finally Everywhere

Use it when there is meaningful finalization or cleanup work to perform.

4. Ignoring Better Resource Management Tools

For files and many other resources, Python's with statement is usually clearer and safer.

5. Putting Unrelated Code in finally

Keep the cleanup block focused on operations that should happen after the main operation.

Practice Exercises

Try solving these exercises without looking at the examples above.

Mini Challenge — Safe File Processor

Build a small program that processes a text file while demonstrating proper exception handling and cleanup.

Starter Structure

file = None

try:
    file = open("students.txt", "r", encoding="utf-8")

    data = file.read()

    print("File contents:")
    print(data)

except FileNotFoundError:
    print("The file could not be found.")

finally:
    if file is not None:
        file.close()

    print("File processing finished.")

Quick Knowledge Check

Test your understanding of Python's finally block.

Lesson Summary

In this lesson, you learned how the finally block works and why it is useful for cleanup and resource management.