Try–except–finally behavior in Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of try-except-finally with exception

What is the output of this Python code?

Python

try:
    print("Start")
    x = 1 / 0
except ZeroDivisionError:
    print("Caught division by zero")
finally:
    print("Finally block executed")

A Start\nFinally block executed

B Caught division by zero\nFinally block executed

C Start\nCaught division by zero\nFinally block executed

D Start\nCaught division by zero

💡 Hint

Remember that the finally block always runs, even if an exception occurs.

The code prints "Start" first. Then it tries to divide by zero, which raises ZeroDivisionError. The except block catches it and prints "Caught division by zero". Finally, the finally block runs and prints "Finally block executed".

❓ Predict Output

intermediate

Return value with try-except-finally

What is the output of this Python code?

Python

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

print(func())

A finally

B except

C None

D try

💡 Hint

The finally block runs after return statements and can override the return value.

Even though the try block returns 'try', the finally block runs last and its return value 'finally' overrides the previous return.

🧠 Conceptual

advanced

Exception propagation with finally

Consider this code snippet. What will be printed?

Python

def test():
    try:
        raise ValueError('error')
    finally:
        print('In finally')

try:
    test()
except Exception as e:
    print(f'Caught: {e}')

A In finally\nCaught: error

B Caught: error\nIn finally

C In finally

D Caught: error

💡 Hint

The finally block runs before the exception is caught outside.

The function test raises a ValueError. Before the exception leaves test, the finally block prints 'In finally'. Then the exception is caught in the outer try-except and prints 'Caught: error'.

❓ Predict Output

advanced

Exception in finally block

What happens when an exception is raised in the finally block?

Python

try:
    print('Try block')
    raise ValueError('Original error')
except ValueError as e:
    print(f'Caught: {e}')
finally:
    print('Finally block')
    raise RuntimeError('Error in finally')

A Try block\nFinally block\nCaught: Original error

B Try block\nCaught: Original error\nFinally block

C Try block\nCaught: Original error

D Try block\nCaught: Original error\nFinally block\nRuntimeError: Error in finally

💡 Hint

Exceptions in finally override previous exceptions.

The try block raises ValueError, which is caught and printed. The finally block runs and prints 'Finally block', but then raises RuntimeError. This new exception replaces the original one and is shown after the prints.

🔧 Debug

expert

Identify the output and explain the flow

What is the output of this code and why?

Python

def f():
    try:
        print('A')
        raise Exception('E1')
    except Exception as e:
        print('B')
        raise Exception('E2')
    finally:
        print('C')

try:
    f()
except Exception as e:
    print(f'D: {e}')

A A\nB\nD: E2\nC

B A\nB\nC\nD: E2

C A\nC\nB\nD: E2

D A\nC\nD: E1

💡 Hint

The finally block runs after the except block but before the exception propagates.

The function prints 'A', then raises 'E1'. The except catches it, prints 'B', and raises 'E2'. Before 'E2' propagates, the finally block runs and prints 'C'. Outside, the try-except catches 'E2' and prints 'D: E2'.

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