Try–except–finally behavior in Python - Step-by-Step Execution

Concept Flow - Try–except–finally behavior

Start try block

↓

Execute try code

↓

Exception?

No→Execute finally block

↓

Go to except block

↓

Execute except block

↓

Execute finally block

↓

End

The program tries the code in try. If no error, it runs finally then ends. If error, it runs except, then finally, then ends.

Execution Sample

Python

try:
    x = 1 / y
except ZeroDivisionError:
    x = 0
finally:
    print(x)

This code tries to divide 1 by y, handles division errors by setting x to 0, and always prints x at the end.

Execution Table

Step	Action	Evaluation	Result
1	Enter try block	Execute 'x = 1 / y'	Error: NameError (y not defined)
2	Exception caught?	No ZeroDivisionError, but NameError raised	No except block matches, skip except
3	Execute finally block	Print x	Error: x not assigned, NameError raised again
4	Program ends	Unhandled NameError	Program crashes with NameError

💡 No matching except block for NameError, finally runs, then program crashes

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
x	undefined	undefined (error on assignment)	undefined	undefined	undefined (program crashes)
y	undefined	undefined	undefined	undefined	undefined

Key Moments - 3 Insights

Why does the program crash even though there is an except block?

The except block only catches ZeroDivisionError, but the error is NameError because y is not defined. See execution_table step 2.

Does the finally block run if an exception is not caught?

Yes, finally always runs no matter what. See execution_table step 3 where finally runs even though exception is unhandled.

What happens if the except block matches the error?

If except matches, it runs the except code, then finally runs. The program does not crash. This is not shown here but is the normal flow.

Visual Quiz - 3 Questions

Look at the execution table, what error occurs at step 1?

A No error occurs

B ZeroDivisionError because of division by zero

C NameError because y is not defined

D SyntaxError due to wrong code

💡 Hint

Check the 'Evaluation' column in step 1 of the execution_table

At which step does the finally block execute?

A Step 1

B Step 3

C Step 2

D Step 4

💡 Hint

Look for 'Execute finally block' in the Action column of execution_table

If the except block caught NameError instead, what would change in the execution?

A The except block would run, then finally, and program ends normally

B The program would crash after finally

C The finally block would not run

D The try block would run again

💡 Hint

Refer to key_moments explanation about except block matching the error

Concept Snapshot

try:
  code that might fail
except ErrorType:
  handle error
finally:
  code that always runs

- try runs first
- except runs if matching error
- finally runs always
- program ends after finally

Full Transcript

This example shows how Python runs try-except-finally. The try block runs code that may cause an error. If an error happens and matches the except type, except runs. Finally always runs no matter what. Here, a NameError happens because y is not defined. The except block only catches ZeroDivisionError, so it does not run. Finally runs and tries to print x, but x was never set, so the program crashes with NameError. This shows that finally runs even if except does not catch the error. If except matched the error, it would run, then finally, and the program would end normally.

Practice

1. What does the finally block do in a try-except-finally structure?

easy

A. It always runs, whether an error occurs or not.

B. It runs only if an error occurs.

C. It runs only if no error occurs.

D. It runs before the try block.

Solution

1. Step 1: Understand the role of try and except

   The try block runs code that might cause an error, and except runs only if an error happens.

2. Step 2: Understand the finally block behavior

   The finally block always runs after try and except, no matter if an error occurred or not.

3. Final Answer:

   It always runs, whether an error occurs or not. -> Option A

4. Quick Check:

   finally always runs = A [OK]

Hint: Remember: finally always runs last, no matter what. [OK]

Common Mistakes:

• Thinking finally runs only on errors
• Confusing except and finally blocks
• Believing finally runs before try

2. Which of the following is the correct syntax for a try-except-finally block in Python?

easy

A. except:
pass
try:
pass
finally:
pass

B. try:
pass
finally:
pass
except:
pass

C. try:
pass
except:
pass
finally:
pass

D. try:
pass
except:
pass
else:
pass

Solution

1. Step 1: Recall the order of blocks

   The correct order is try, then except, then finally.

2. Step 2: Check each option's order

   try: pass except: pass finally: pass follows the correct order. try: pass finally: pass except: pass places finally before except, which is invalid. except: pass try: pass finally: pass starts with except, which is wrong. try: pass except: pass else: pass uses else but no finally.

3. Final Answer:

   try, except, finally in correct order -> Option C

4. Quick Check:

   try-except-finally order = C [OK]

Hint: Remember order: try, except, then finally. [OK]

Common Mistakes:

• Placing finally before except
• Starting with except block
• Confusing else with finally

3. What will be the output of this code?

try:
    print('Start')
    x = 1 / 0
except ZeroDivisionError:
    print('Error caught')
finally:
    print('Always runs')

medium

A. Start\nAlways runs

B. Start\nError caught

C. Error caught\nAlways runs

D. Start\nError caught\nAlways runs

Solution

1. Step 1: Trace the try block

   The code prints 'Start' then tries to divide by zero, causing a ZeroDivisionError.

2. Step 2: Handle the exception and finally block

   The except block catches the error and prints 'Error caught'. Then the finally block runs and prints 'Always runs'.

3. Final Answer:

   Start\nError caught\nAlways runs -> Option D

4. Quick Check:

   try prints + except prints + finally prints = A [OK]

Hint: finally always prints last, even after except. [OK]

Common Mistakes:

• Forgetting finally runs
• Assuming code stops after error
• Missing the initial print before error

4. Find the error in this code snippet:

try:
    print('Hello')
except:
    print('Error')
finally
    print('Done')

medium

A. Missing colon after except

B. Missing colon after finally

C. Indentation error in try block

D. No error, code is correct

Solution

1. Step 1: Check syntax of try-except-finally

   Each block header must end with a colon (:). The finally line is missing a colon.

2. Step 2: Verify other parts

   The except line has a colon, and indentation is correct.

3. Final Answer:

   Missing colon after finally -> Option B

4. Quick Check:

   Colon needed after finally = B [OK]

Hint: Check colons after try, except, finally lines. [OK]

Common Mistakes:

• Ignoring missing colon errors
• Confusing except and finally syntax
• Assuming indentation fixes missing colon

5. Consider this code:

def test():
    try:
        return 'try'
    except:
        return 'except'
    finally:
        return 'finally'

result = test()
print(result)

What will be printed?

hard

A. finally

B. except

C. None

D. try

Solution

1. Step 1: Understand return in try and finally

   The try block returns 'try', but the finally block also has a return statement.

2. Step 2: Know that finally return overrides others

   In Python, if finally has a return, it overrides any previous return from try or except.

3. Step 3: Determine final output

   The function returns 'finally', so print(result) outputs 'finally'.

4. Final Answer:

   finally -> Option A

5. Quick Check:

   finally return overrides try/except returns = D [OK]

Hint: Return in finally overrides try/except returns. [OK]

Common Mistakes:

• Thinking try return is final
• Ignoring finally's return effect
• Assuming except runs without error