Finally blocks for cleanup code
The else block means: continue with this code only after the try block has succeeded.
Try it: try / except / else / finally
How an exception jumps out of a try block to the first matching except clause, when else runs, and why finally always runs.
How it works
- Statements in try run until one raises an exception; the rest of try is skipped.
- Python checks the except clauses in order and runs the first one whose type matches.
- If nothing was raised, the else block runs instead.
- finally runs in every case.
Default run (9 steps): Call safe_divide('4'). … Return 25.0. Output was: Worked: 25.0 / Done.
Simplified: One fixed function; int() and / are modelled exactly (including how Python prints floats), but nothing is executed as Python.
Loading the simulation…
The Path Depends on the Try Block
Exception handling has a success path and one or more error paths. The try block runs first. If it completes without raising an exception, Python skips the except blocks and runs the else block. If the try block raises an exception, Python jumps to the first matching except block and skips the else block.
The else block means: continue with this code only after the try block has succeeded.
Tracing Successful and Failed Paths
Think of the try block as the decision point. Python evaluates it before considering the rest of the structure. A normal completion takes the success route to else. An exception takes an error route to a matching except block. These routes do not merge into else: when an exception occurs, else is skipped.
- Try succeeds: except blocks are skipped, then else runs.
- Try raises a handled exception: Python enters the first matching except block, and else is skipped.
- Try raises EOFError: the EOFError handler runs if one is present.
- Try raises KeyboardInterrupt: the KeyboardInterrupt handler runs if one is present.
Separate Handlers for Specific Interruptions
Multiple except blocks allow different exception types to receive different responses. Python checks the except blocks from top to bottom and executes the first one whose exception type matches the raised exception. After that matching handler is selected, the remaining except blocks are skipped.
A user-input operation can be interrupted in more than one way. An end-of-file signal raises EOFError, while pressing Ctrl+C raises KeyboardInterrupt. Separate handlers let the program provide a tailored response for each case. In this example, the two exception types are independent, so either order would work. In general, order matters when exception types overlap through inheritance.
| Situation in try | Block selected | Else block |
|---|---|---|
| The user enters ordinary text | else | Runs |
| The user sends an end-of-file signal | EOFError handler | Skipped |
| The user presses Ctrl+C | KeyboardInterrupt handler | Skipped |
The selected path depends on what happens during the input operation.
Why Success Code Belongs in Else
The else block is optional, but it separates success-path logic from exception-handling logic. Code in try is monitored for exceptions. If success code is placed in try after the risky operation, an exception accidentally raised by that success code could also be caught by the except blocks. That may not be the intended behavior. Code in else runs only after the try block has completed successfully, so the structure communicates which statements belong to the risky operation and which belong to the success case.
Reading user input
Determine the selected path when a program attempts to read input and the user either enters text, sends an end-of-file signal, or presses Ctrl+C.
- 1Ordinary text
The input operation completes without an exception. The except blocks are skipped, and the else block runs to display what was entered.
- 2End-of-file signal
The input operation raises EOFError. Python selects the EOFError handler, skips the other except block, and skips else.
- 3Ctrl+C
The input operation raises KeyboardInterrupt. Python selects the KeyboardInterrupt handler, skips the other except block, and skips else.
Only ordinary text reaches else. Each interruption reaches its corresponding specific except block.
Predicting the Selected Block
What do you think happens?
A program tries to read user input. The user enters ordinary text rather than sending an end-of-file signal or pressing Ctrl+C. Which path executes?
Reveal answer
The else block
The try operation completes without raising an exception, so Python skips both except blocks and runs else.
What do you think happens?
The input operation raises EOFError. Which blocks are skipped after Python selects the EOFError handler?
Reveal answer
The KeyboardInterrupt handler and the else block
Python runs the first matching except block. The remaining except blocks are skipped, and else runs only when try succeeds.
For each scenario, name the block that executes next: the user presses Ctrl+C; the user enters text; the input operation raises EOFError.
Hints
- Check first whether the try operation raises an exception.
- Match EOFError and KeyboardInterrupt to their specific handlers.
- Use else only for the scenario with no exception.
Mistakes in Control-Flow Reasoning
Common mistake Assuming else runs after every try block
What it looks likeThe try block raises EOFError, but the learner expects the else block to display the result.
Why it failsElse runs only when try completes without raising an exception.
Do this insteadFollow the exception path to the matching except block and mark else as skipped.
Common mistake Treating multiple except blocks as cumulative
What it looks likeThe learner expects both the EOFError and KeyboardInterrupt handlers to run after one exception.
Why it failsPython executes the first matching except block and skips the remaining except blocks.
Do this insteadCheck the except blocks from top to bottom and stop at the first match.
Common mistake Putting all success logic inside try without considering its monitoring scope
What it looks likeA success-path statement placed after the risky operation raises an exception and is caught by the same except blocks.
Why it failsEverything in try is monitored for exceptions, not only the initial risky operation.
Do this insteadUse else for code that depends on the try block succeeding.
Common mistake Confusing an exception type with the success case
What it looks likeTreating ordinary input as though it selected an exception handler.
Why it failsOrdinary input does not raise EOFError or KeyboardInterrupt in the described scenario.
Do this insteadWhen no exception occurs, skip the except blocks and continue to else.
Execution Rules to Remember
- 1Python evaluates the try block first.
- 2A successful try skips every except block and enters else.
- 3An exception in try sends control to the first except block that matches its type.
- 4After one except block matches, the remaining except blocks and else are skipped.
- 5Use separate except blocks when different exception types need different responses.
- 6Use else for success-path code that should remain separate from monitored, potentially risky code.
Key Takeaways
- The else block runs only when the try block succeeds without raising an exception.
- When try raises an exception, Python checks except blocks in order and executes the first matching handler.
- EOFError and KeyboardInterrupt can have separate handlers with different responses.
- The else block keeps success logic separate from exception-handling logic.
- For ordinary input, the success path reaches else; for the two described interruptions, the matching except path runs.