Home › Problems › try / except / finally flow

try / except / finally flow

🧠 Predict the output Topic: exceptions Difficulty: medium Free

What this problem practises

Exceptions are control flow. except clauses are matched top to bottom, finally runs even after a return, and catching too broadly hides the real bug behind a generic message.

This is an output-prediction problem: read the snippet carefully and write down exactly what it prints before anything runs. These questions are interview staples because they test whether you know the language rules, or merely recognise their syntax.

Difficulty: medium — expect to hold two interacting rules in your head at once, such as a boundary combined with a mutation.

The challenge

What will this program print? Type the exact output (both lines, in order).

The code runs in PyDebug’s in-browser compiler. Open the problem, run the snippet, watch the exact error or output, and keep iterating until it is right. Signed-in solves count toward XP and your daily streak.

The snippet

The interactive editor pre-fills exactly this code — read it, then submit your prediction:

try:
    x = int('12a')
except ValueError:
    x = 89
finally:
    print('done')
print(x)

Understand the rule

Exception control-flow puzzles test the exact order in which `try`, `except`, optional `else`, and `finally` blocks execute. Two ironclad rules govern every snippet: lines inside `try` AFTER a raising expression never run, and `finally` ALWAYS runs whether an exception occurred or not.

How to trace it

Step through `try` line by line; if a line raises an exception, jump immediately out of `try` (skipping remaining `try` lines).
Match the raised exception's class against `except` clauses from top to bottom using `isinstance`; run only the FIRST matching `except` block.
If `try` finished with NO exception, skip all `except` blocks (and run `else:` if present).
Execute the `finally:` block unconditionally before leaving the `try` statement — even if `try` or `except` hit `return`!

Common wrong fixes

Running lines inside `try:` that sit below a `1 / 0` or `int('abc')` crash as if `except` resumed execution back inside `try`.
Skipping `finally:` when no exception occurred — `finally` means 'always', not 'on error'.
Running multiple `except` blocks for a single exception when Python executes at most one matching handler.

Rule to remember

`try` aborts on the raising line, at most one `except` handles it, and `finally` executes on every possible path.

Solve it in the interactive editor →

Keep going

Output-prediction strategies — how to predict tricky snippets without running them.
Browse every exceptions problem in this topic.
Common Python errors and what they actually mean, plus the Python glossary for any term used on this page.