Skip to main content

Handling Exceptions: The `else` and `finally` Blocks

In the last article, we introduced the try...except block as the fundamental way to handle runtime errors in Python. It allows our programs to react to problems gracefully instead of crashing. However, the story doesn't end there. The full try statement includes two more optional but powerful clauses: else and finally.

Mastering these clauses gives you fine-grained control over your program's execution flow, allowing you to separate your "success" code from your "cleanup" code.

📚 Prerequisites​

You should be comfortable with the basic try...except syntax for catching exceptions.

🎯 Article Outline: What You'll Master​

In this article, you will learn:

  • ✅ The Full try Statement: See the complete syntax including all four clauses.
  • ✅ The else Block: How to execute code only when the try block succeeds without any errors.
  • ✅ The finally Block: How to run cleanup code that is guaranteed to execute, no matter what.
  • ✅ A Practical Example: See how all four clauses work together to create a robust file processing script.

🧠 Section 1: The else Block - The "Success" Clause​

The else block is the "happy path" of exception handling. Its code is executed if and only if the try block completes without raising an exception.

This is incredibly useful for separating the code that might fail from the code that should only run upon success. It makes your try block cleaner and more focused.

The Syntax:

try:
    # Code that might raise an exception
    ...
except SomeException:
    # Handle the error
    ...
else:
    # Code that runs ONLY if the 'try' block was successful
    ...

Example: Let's revisit our division calculator.

# else_example.py

try:
    numerator = int(input("Enter the numerator: "))
    denominator = int(input("Enter the denominator: "))
    result = numerator / denominator

except ValueError:
    print("Invalid input. Please enter numbers only.")
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")

else:
    # This code only runs if both inputs were valid numbers AND denominator was not zero.
    print(f"Success! The result is {result:.2f}")

By moving the success message into the else block, we make our intent clear: the try block is for the dangerous operations, and the else block is for what to do when those operations succeed.

💻 Section 2: The finally Block - The "Always" Clause​

The finally block is for cleanup. The code inside a finally clause is guaranteed to run, no matter what. It runs whether:

  • The try block succeeded.
  • The try block failed and an except block was executed.
  • The try block failed and the exception was not caught.

This makes it the perfect place for actions that must happen under all circumstances, like closing a file, releasing a network connection, or cleaning up a temporary resource.

The Syntax:

try:
    # Risky code
    ...
except SomeException:
    # Handle error
    ...
finally:
    # This code ALWAYS runs.
    ...

Example: While the with statement is the best way to handle files, a try...finally block demonstrates the concept perfectly.

# finally_example.py

f = None # Define f outside the try block so it's accessible in 'finally'
try:
    f = open('my_file.txt', 'w')
    f.write('Hello!')
    # Uncomment the line below to simulate an error
    # 1 / 0
except Exception as e:
    print(f"An error occurred: {e}")
finally:
    print("Executing the 'finally' block.")
    if f: # Check if the file was successfully opened before trying to close it
        f.close()
        print("File has been closed.")

If you run this code as is, it will succeed, and the finally block will run. If you uncomment the 1 / 0 line, a ZeroDivisionError will occur, the except block will run, and then the finally block will still run to close the file.

🛠️ Section 3: Putting It All Together​

Let's see all four clauses in a single, comprehensive example. We'll write a script that reads a number from a file, calculates its inverse, and writes the result to a new file.

# full_example.py

print("Attempting to process 'data.txt'...")

try:
    # 1. Try to open and read the file
    with open('data.txt', 'r') as f:
        line = f.readline()
        number = int(line.strip())
        inverse = 1 / number

# 2. Handle potential errors
except FileNotFoundError:
    print("Error: 'data.txt' not found.")
except (ValueError, ZeroDivisionError) as e:
    print(f"Error processing data: {e}")

# 3. Run this only if the try block succeeded
else:
    print(f"Successfully calculated the inverse: {inverse}")
    with open('result.txt', 'w') as f_out:
        f_out.write(str(inverse))
    print("Result saved to 'result.txt'.")

# 4. This block runs no matter what
finally:
    print("--- Processing complete. ---")

This structure is extremely robust. It clearly separates the risky code, the specific error handlers, the success case, and the guaranteed cleanup code, making the program's logic easy to follow.

✨ Conclusion & Key Takeaways​

You have now mastered the full try...except...else...finally structure. Using these clauses appropriately allows you to write Python programs that are not only correct on the "happy path" but are also resilient and predictable when things go wrong.

Let's summarize the key takeaways:

  • try: For the code that might fail.
  • except: To handle a specific error that occurred in the try block.
  • else: For the code that should run only if the try block succeeds.
  • finally: For the cleanup code that must run no matter what.

Challenge Yourself: Write a script that asks the user for a file name.

  1. In the try block, attempt to open and read the file.
  2. Have an except block for FileNotFoundError.
  3. In the else block, print the contents of the file.
  4. In the finally block, print a message like "File reading attempt finished." Test your script with both a real file name and a fake one.

➡️ Next Steps​

You know how to handle errors, but what if you want to signal an error in your own functions? In our final article of this series, we'll learn how to create and "Raising Exceptions: The raise keyword," which allows you to create your own custom error conditions.

Happy (resilient) coding!