Python Try-Finally Block Tutorial with Examples | Python Exception Handling

Python - The try-finally Block

When writing Python programs, errors and exceptions can occur unexpectedly. Sometimes, regardless of whether an error occurs or not, you need certain code to execute. This is where the try-finally block becomes useful.

The finally block ensures that important cleanup operations are performed before the program terminates or moves on. It is commonly used for closing files, releasing resources, disconnecting from databases, and other cleanup tasks.

In this tutorial, you will learn what the try-finally block is, how it works, its syntax, practical examples, and best practices.

---

What is the try-finally Block?

The try-finally block consists of two parts:

• try block: Contains code that may raise an exception.
• finally block: Contains code that is always executed, whether an exception occurs or not.

The main purpose of the finally block is to guarantee execution of cleanup code.

---

Syntax of try-finally

try:
    # Code that may raise an exception
finally:
    # Code that always executes

No matter what happens inside the try block, Python executes the finally block before leaving the statement.

---

Simple Example

try:
    print("Inside try block")
finally:
    print("Inside finally block")

Output

Inside try block
Inside finally block

In this example, no exception occurs, but the finally block still executes.

---

Example with an Exception

try:
    print(10 / 0)
finally:
    print("Cleanup operation executed")

Output

Cleanup operation executed
ZeroDivisionError: division by zero

Explanation

1. Python attempts to divide by zero.
2. A ZeroDivisionError occurs.
3. Before terminating the program, Python executes the finally block.
4. The exception is then displayed.

---

Why Use finally?

The finally block is useful when resources need to be released regardless of program success or failure.

Common examples include:

• Closing files
• Closing database connections
• Releasing network resources
• Cleaning temporary files
• Releasing locks in multithreaded applications

---

File Handling Example

file = open("sample.txt", "r")

try:
    content = file.read()
    print(content)
finally:
    file.close()
    print("File closed successfully")

Explanation

Even if reading the file causes an error, the file will still be closed properly.

This prevents resource leaks and improves application stability.

---

try-finally with User Input

try:
    number = int(input("Enter a number: "))
    result = 100 / number
    print(result)
finally:
    print("Program execution completed")

Output (Input: 5)

20.0
Program execution completed

Output (Input: 0)

Program execution completed
ZeroDivisionError: division by zero

Notice that the finally block executes in both cases.

---

Combining try, except, and finally

Most real-world applications use finally together with except.

try:
    num = int(input("Enter a number: "))
    print(10 / num)

except ZeroDivisionError:
    print("Cannot divide by zero")

finally:
    print("Execution finished")

Output

Enter a number: 0
Cannot divide by zero
Execution finished

The exception is handled by except, and finally still executes.

---

Example: Database Connection

connection = None

try:
    print("Connecting to database...")
    connection = "Database Connected"

except Exception:
    print("Connection error")

finally:
    print("Closing database connection")

Output

Connecting to database...
Closing database connection

This pattern is commonly used in enterprise applications.

---

finally with Return Statements

The finally block executes even when a function returns a value.

def test():
    try:
        return "Returned from try"
    finally:
        print("Finally executed")

print(test())

Output

Finally executed
Returned from try

The return statement waits until the finally block finishes.

---

Difference Between try-except and try-finally

Feature	try-except	try-finally
Handles exceptions	Yes	No
Prevents program crash	Yes	No
Executes cleanup code	Not always	Always
Common use	Error handling	Resource cleanup

---

Best Practices

1. Use finally for Cleanup Only

Keep cleanup-related code inside the finally block.

finally:
    file.close()

---

2. Avoid Complex Logic

Do not place complicated business logic inside finally.

---

3. Close Resources Properly

Always close:

• Files
• Database connections
• Network sockets
• External resources

---

4. Combine with except When Needed

For robust applications:

try:
    risky_code()
except Exception:
    handle_error()
finally:
    cleanup()

---

Common Mistakes

Forgetting Cleanup

file = open("data.txt")
content = file.read()

If an error occurs, the file may remain open.

---

Using finally for Error Handling

Incorrect:

try:
    x = 10 / 0
finally:
    print("Error handled")

The error is not handled; it still occurs.

Use except for handling errors.

---

Real-World Applications

The try-finally block is widely used in:

• Web applications
• Automation scripts
• Database systems
• File processing programs
• Network communication software
• Cloud services

Whenever resources must be released safely, finally is the preferred solution.

---

Summary

The Python try-finally block guarantees that certain code executes regardless of whether an exception occurs. It is primarily used for cleanup operations such as closing files, releasing resources, and disconnecting from services.

Key Points

• finally always executes.
• It runs whether an exception occurs or not.
• It is mainly used for cleanup tasks.
• It does not handle exceptions by itself.
• It can be combined with try-except for complete error management.

Mastering the try-finally block helps you write safer, cleaner, and more reliable Python programs.