Python Finally Block – Complete Guide with Examples

Introduction

The finally block plays a special role. The code inside a finally block always executes, whether an exception occurs or not. This makes it ideal for cleanup tasks such as closing files, releasing resources, disconnecting from databases, or displaying final messages.

The finally block helps ensure that important operations are performed regardless of the outcome of the program. It is widely used in real-world applications where resource management and cleanup are critical.

What is Python Finally Block?

The finally block is a part of Python’s exception handling mechanism. It contains code that is guaranteed to execute after the try and except blocks, regardless of whether an exception occurs.

Example:

try:
   result = 10 / 2
except ZeroDivisionError:
   print("Cannot divide by zero")
finally:
   print("Program execution completed")

Output:

The finally block executes even though no exception occurred.

Why Use a Finally Block?

The main purpose of the finally block is to ensure that important cleanup code runs no matter what happens in the program.

Benefits include:

• Prevents resource leaks
• Ensures files are closed properly
• Helps disconnect databases
• Improves application reliability
• Makes code more professional

Without a finally block, resources may remain open if an exception occurs.

Syntax

The basic syntax is:

try:
   # Risky code
except ExceptionType:
   # Error handling code
finally:
   # Cleanup code

Example:

try:
   number = int("abc")
except ValueError:
   print("Invalid value")
finally:
   print("Execution finished")

Output:

How Finally Works?

The execution flow is:

1. Python executes the try block.
2. If an exception occurs, the matching except block runs.
3. Whether an exception occurs or not, the finally block executes.
4. Program execution continues.

Flow Diagram:

try block
   |
Exception?
/      \
Yes      No
|        |
except   Skip
   \    /
  finally
     |
Continue

Finally Block Without Exception

If no exception occurs, the finally block still executes.

Example:

try:
   print("Program running")
finally:
   print("Cleanup completed")

Output:

Finally Block With Exception

When an exception occurs and is handled, the finally block still executes.

Example:

try:
   result = 10 / 0
except ZeroDivisionError:
   print("Cannot divide by zero")
finally:
   print("Program finished")

Output:

Try Except Else Finally Structure

The finally block can be combined with try, except, and else.

Syntax

try:
   pass
except:
   pass
else:
   pass
finally:
   pass

Example:

try:
   result = 20 / 4
except ZeroDivisionError:
   print("Error")
else:
   print("Result:", result)
finally:
   print("Execution completed")

Output:

Finally Block with File Handling

One of the most common uses of finally is closing files.

Example:

file = None
try:
   file = open("data.txt", "r")
   print(file.read())
except FileNotFoundError:
   print("File not found")
finally:
   if file:
       file.close()
       print("File closed")

Output:

Even if an error occurs, the file is closed properly.

Finally Block with User Input

Example:

try:
   age = int(input("Enter age: "))
except ValueError:
   print("Invalid age")
finally:
   print("Input process completed")
Input:
abc

Output:

Finally Block with Multiple Exceptions

Example:

try:
   number = int(input("Enter number: "))
   result = 100 / number
except ValueError:
   print("Invalid number")
except ZeroDivisionError:
   print("Cannot divide by zero")
finally:
   print("Calculation completed")

Possible Output:

Finally Block with Return Statement

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

Example:

def calculate():
   try:
       return "Try Block"
   finally:
       print("Finally Block")
print(calculate())

Output:

Notice that the finally block executes before the function returns.

Example

The following example demonstrates complete exception handling using a finally block.

try:
   num1 = int(input("Enter first number: "))
   num2 = int(input("Enter second number: "))
   result = num1 / num2
except ValueError:
   print("Invalid input")
except ZeroDivisionError:
   print("Cannot divide by zero")
else:
   print("Result:", result)
finally:
   print("Program ended")

Input:

10
2

Output:

Real-life Example

Imagine you are building a banking application.

A database connection must always be closed after a transaction.

connection = "Database Connected"
try:
   print("Processing transaction")
except Exception:
   print("Transaction failed")
finally:
   print("Closing database connection")

Output:

Why Is This Useful?

In banking systems, leaving database connections open can consume resources and affect performance. The finally block ensures connections are always closed.

Other real-world uses include:

• Closing files
• Releasing memory resources
• Disconnecting databases
• Closing network connections
• Logging program completion
• Cleaning temporary files

Common Mistakes

1. Assuming Finally Runs Only During Errors

Wrong Thinking:

finally:
   print("Runs only when error occurs")

Reality:

The finally block always runs.

2. Forgetting Cleanup Code

Incorrect:

file = open("data.txt")

Correct:

finally:
   file.close()

Always clean up resources.

3. Writing Risky Code Inside Finally

Incorrect:

finally:
   result = 10 / 0

This can create new exceptions.

Keep cleanup code simple and safe.

4. Using Finally Instead of Except

Incorrect:

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

The finally block does not replace exception handling.

Correct:

except ZeroDivisionError:
   print("Error")

5. Ignoring Resource Management

Incorrect:

try:
   file = open("data.txt")

Correct:

finally:
   file.close()

Best Practices

1. Use Finally for Cleanup

finally:
   file.close()

Perfect for releasing resources.

2. Keep Finally Block Simple

finally:
   print("Done")

Avoid complicated logic.

3. Use With Files When Possible

with open("data.txt") as file:
   print(file.read())

The with statement automatically handles cleanup.

4. Combine with Exception Handling

try:
   pass
except:
   pass
finally:
   pass

Provides complete error management.

5. Avoid Creating New Exceptions

Keep cleanup code safe and predictable.

Difference Between Try, Except, Else, and Finally

Conclusion

The Python Finally Block is a powerful feature that ensures important code executes regardless of whether an exception occurs. It is primarily used for cleanup operations such as closing files, releasing resources, disconnecting databases, and performing final actions before a program exits.

By combining finally with try, except, and else, developers can create robust applications that manage errors effectively while ensuring resources are handled properly.

Related Python Tutorials