else and finally in Exception Handling

diagram the four blocks, and exactly when each runs mermaid

  flowchart TD
  A["try body"] --> B{"did it raise?"}
  B -->|no| C["else"]
  B -->|"yes, a matching type"| D["except"]
  B -->|"yes, unmatched"| E["propagates on"]
  C --> F["finally"]
  D --> F
  E --> F
  F --> G["and only then does the exception continue, or the function return"]
  H["a return in the try body"] --> F
  I["else is NOT the same as putting it at the end of try"] --> J["code there is no longer guarded by except"]

else runs only when the try body finished without raising, which makes it the right place for code that must not be protected by the except. finally runs on every path -- normal exit, handled exception, unhandled exception, and even a return. That last case is where it turns dangerous.

A return inside finally silently discards the exception

Verified:

python

def h():
    try:
        raise ValueError("lost!")
    finally:
        return "finally won"
 
h()        # 'finally won'  -- the ValueError is GONE

No traceback, no logging, nothing. The same happens with break and continue in a finally inside a loop. And a return in finally also overrides a return in try:

python

def g():
    try: return "from try"
    finally: return "from finally"     # 'from finally'

Python 3.14 now warns about this at compile time — SyntaxWarning: 'return' in a 'finally' block — which is a good reason not to suppress that warning.

The observed order, for reference:

Situation	Blocks that ran
no exception	try, else, finally
exception raised and caught	try, except, finally

Use finally for cleanup only. If you need to change what the function returns, do it in else or after the whole statement.

else in try/except

else runs only if no exception occurred.

try_else.py

try:
    x = int("42")
except ValueError:
    print("Invalid number")
else:
    print("Parsed successfully:", x)

finally in try/except

finally runs always (success or error). This is useful for cleanup.

try_finally.py

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

Prefer context managers when possible

Instead of manual .close(), use with.

with_open.py

try:
    with open("data.txt", "r") as f:
        print(f.read())
except FileNotFoundError:
    print("File not found")

When is finally important?

• closing files
• releasing locks
• closing DB connections
• cleaning up temporary files

sketch Which block runs, and what a return in finally does to an exception p5.js Pause Restart

Three paths through the same statement. The left column is the ordinary case, the middle is a caught exception, and the right is the one worth remembering: a return inside finally discards whatever was in flight, including an exception nobody has handled. Python 3.14 now warns about it at compile time.

Check yourself

pch.quizTag pch.quizDefaultTitle

1. A function raises inside `try` and has `return 'done'` inside `finally`. What does the caller see?

   A The exception propagates B `'done'` — the exception is discarded C Both, in sequence D RuntimeError
   pch.quizShowAnswer

   B — `'done'` — the exception is discarded — Verified: the ValueError vanished entirely, with no traceback and nothing logged. Python 3.14 now warns at compile time — SyntaxWarning: 'return' in a 'finally' block.

2. When does the `else` clause of a `try` statement run?

   A Whenever `finally` runs B Only when the `try` body raised C Only when the `try` body did NOT raise D Only when there is no `except`
   pch.quizShowAnswer

   C — Only when the `try` body did NOT raise — `else` is the no-exception path. Putting that code at the end of `try` instead would leave it guarded by the `except`, so an unrelated error in it would be caught by a handler meant for the risky call.

3. With no exception raised, which blocks run and in what order?

   A `try`, `finally` B `try`, `else`, `finally` C `try`, `except`, `finally` D `try`, `else`
   pch.quizShowAnswer

   B — `try`, `else`, `finally` — Verified. With an exception it is `try`, `except`, `finally` instead — `finally` runs on every path.

4. What should `finally` be used for?

   A Returning a fallback value B Cleanup that must happen on every path C Logging the exception D Retrying the operation
   pch.quizShowAnswer

   B — Cleanup that must happen on every path — Releasing a lock, closing a handle, restoring state. Changing what the function returns from there is what silently swallows exceptions.

🧪 Try It Yourself

Exercise 1 – The else Clause

pch.exerciseTag pch.exerciseTitle

Exercise 2 – The finally Clause

pch.exerciseTag pch.exerciseTitle

Exercise 3 – else + finally Together

pch.exerciseTag pch.exerciseTitle