Python Exception Handling (try-except) Exercises

# Example: exception without except
try:
    x = 10 / 0
print("This line is never reached if exception is not handled")

Uncaught exceptions and program termination

• Option 1 – Incorrect: Python does not silently ignore uncaught exceptions; the error is not ignored.
• Option 2 – Correct: If an exception occurs in a try block and there is no matching except, Python raises the exception, prints a traceback, and the program stops (unless the exception is caught further up the call stack).
• Option 3 – Incorrect: A finally block (if present) will run, but after that Python still propagates the uncaught exception — the program does not exit silently.
• Option 4 – Incorrect: Exceptions are not automatically logged and suppressed; they cause a traceback by default unless explicitly handled.

Step-by-step reasoning:

1. Execution enters the try block and runs statements sequentially.
2. If a statement raises an exception and there is no except clause matching that exception type, Python searches up the call stack for a handler.
3. If no handler is found anywhere, Python prints a traceback showing the exception type and location, and the program terminates with a non-zero exit status.
4. If a finally block exists, it executes before termination, but it does not suppress the uncaught exception.

Key takeaways:

• Always handle expected exceptions with appropriate except clauses to avoid program crashes.
• finally is useful for cleanup (e.g., closing files) but does not replace exception handling.
• For unexpected errors, consider catching generic exceptions at a top level to log and exit gracefully, but prefer catching specific exceptions where possible.

# Example demonstrating ValueError handling
try:
    value = int("abc")
except ValueError:
    print("Invalid conversion!")

Understanding how try-except works:

• In the try block, Python attempts to execute int("abc").
• This operation raises a ValueError because the string "abc" is not a valid integer representation.
• The raised ValueError is immediately caught by the except ValueError: block.
• The statement inside except executes — in this case, it prints "Invalid conversion!".

Why the other options are incorrect:

• Option 1: Incorrect — The program does not crash because the exception is properly caught.
• Option 2: Incorrect — The code never prints the string "abc".
• Option 4: Incorrect — Python does not ignore exceptions silently; if unhandled, they raise errors, but here it’s handled.

Step-by-step reasoning:

1. Interpreter enters the try block.
2. int("abc") triggers a ValueError.
3. Control jumps immediately to the except ValueError block.
4. The message "Invalid conversion!" is printed.

Output:

Invalid conversion!

Key takeaway: Use try-except to handle predictable errors like invalid user input or failed conversions, ensuring that your program continues running smoothly instead of crashing.

Explanation:

When an exception occurs inside a try block, Python looks for an except block that matches the type of the raised exception. If no matching except block is found:

• The exception is not handled locally.
• Python stops executing the current function or script.
• An error traceback message is printed to the console.

Example:

try:
    print(10 / 0)
except ValueError:
    print("Invalid value!")

Explanation of example:

• The code inside try raises a ZeroDivisionError.
• But the except block only handles ValueError.
• Since no matching except is found, Python raises an unhandled ZeroDivisionError.

Output:

Traceback (most recent call last):
  File "main.py", line 2, in <module>
    print(10 / 0)
ZeroDivisionError: division by zero

Key takeaway: If no except block matches the raised exception, Python will stop execution and display an error traceback. To prevent this, always include the correct exception type or a generic except Exception: to handle unexpected errors safely.

Explanation:

Let’s break down how the try-except-else-finally flow works in this example:

1. int("abc") raises a ValueError because "abc" cannot be converted to an integer.
2. The except ValueError block runs and prints "Conversion failed!".
3. The else block is skipped since an exception occurred.
4. The finally block always runs, printing "Program completed.".

Output:

Conversion failed!
Program completed.

Key takeaway:

• The finally block executes whether an exception occurs or not.
• else only runs if no exception occurs inside the try block.

Explanation:

In Python, you can handle different exceptions separately by using multiple except blocks. This allows more precise control over how various errors are handled.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ValueError:
    print("Invalid number entered.")
except ZeroDivisionError:
    print("Division by zero is not allowed.")
else:
    print("Result:", result)
finally:
    print("Operation finished.")

Explanation of options:

• Option 1 – Incorrect: else runs only when no exception occurs.
• Option 2 – Incorrect: finally executes whether or not an exception occurs.
• Option 3 – Correct: You can use multiple except blocks for different exceptions.
• Option 4 – Incorrect: try can contain return statements.

Key takeaways:

• Multiple except clauses improve error-specific handling.
• else executes only when no exceptions occur.
• finally always runs — even if there’s a return statement or exception.

Explanation:

This example demonstrates how try-except-else-finally interacts with return statements:

1. Call divide_numbers(10, 2):
   • a / b → 10 / 2 = 5.0 → no exception.
   • else block executes → returns "Result is 5.0".
   • finally always executes → prints "Execution completed."
2. Call divide_numbers(5, 0):
   • 5 / 0 raises ZeroDivisionError.
   • except block executes → returns "Division by zero!"
   • finally executes → prints "Execution completed."

Output:

Execution completed.
Result is 5.0
Execution completed.
Division by zero!

Key takeaways:

• finally executes before the value is returned from try, except, or else.
• Use finally for cleanup actions like logging, closing files, or releasing resources.
• Return values are not affected by finally unless finally contains a return itself.

Explanation:

This example demonstrates the safest way to read a file while handling exceptions:

• Option 1 – Incorrect: Opens the file without handling exceptions; will crash if the file does not exist.
• Option 2 – Incorrect: Catches FileNotFoundError, but if the file opens successfully, f is never closed if another error occurs.
• Option 3 – Incorrect: Uses finally to close, but f.close() will raise NameError if the file was not successfully opened.
• Option 4 – Correct: Using with automatically handles file opening and closing, and raises exceptions if the file does not exist. The resource is properly released even if an exception occurs.

Step-by-step reasoning:

1. with open("data.txt") as f: opens the file and assigns it to f.
2. Reading with f.read() works if the file exists.
3. When the block exits (even if an exception occurs), the file is automatically closed.
4. If the file does not exist, a FileNotFoundError is raised and can be caught externally if needed.

Key takeaways:

• Always prefer with statement for file operations — ensures proper resource management.
• try-except-finally is useful for more complex resource handling but can be error-prone if the resource isn’t successfully initialized.

Explanation:

This example demonstrates proper exception handling for a runtime error:

• Option 1 – Incorrect: No exception handling; program will crash with ZeroDivisionError.
• Option 2 – Incorrect: Catches generic Exception, which works, but the message is less specific; finally not used for cleanup/logging.
• Option 3 – Correct: Specifically catches ZeroDivisionError and prints an informative message. The finally block always executes, logging that the operation finished.
• Option 4 – Incorrect: Only finally is used; the exception is not caught, so the program still crashes after printing.

Step-by-step reasoning:

1. try block executes result = 10 / 0, which raises ZeroDivisionError.
2. except ZeroDivisionError block runs → prints "Cannot divide by zero".
3. finally block executes → prints "Operation finished".
4. The program continues execution safely without crashing.

Output:

Cannot divide by zero
Operation finished

Key takeaways:

• Use specific exception types to provide meaningful error handling.
• The finally block is ideal for cleanup or logging regardless of whether an exception occurs.
• A well-structured try-except-finally ensures program stability even in error scenarios.

Explanation:

This example demonstrates how try-except-else-finally interacts with return statements in Python:

1. Call divide(10, 2):
   • No exception occurs → else block executes → returns "Result is 5.0".
   • finally block executes first → prints "Execution finished".
   • Then the returned value "Result is 5.0" is passed to the caller.
2. Call divide(5, 0):
   • ZeroDivisionError occurs → except block executes → returns "Division by zero!"
   • finally executes → prints "Execution finished".
   • The return value "Division by zero!" is passed to the caller.

Output:

Execution finished.
Result is 5.0
Execution finished.
Division by zero!

Key takeaways:

• finally always executes before returning a value from try or except.
• Return values are preserved after finally execution.
• This pattern ensures that cleanup, logging, or other final actions are performed consistently.

Explanation:

Python’s exception handling allows flexibility to manage errors efficiently. Here’s how the blocks work:

• Option 1 – Incorrect: The finally block always executes, regardless of whether an exception occurs.
• Option 2 – Incorrect: The else block executes only if no exception occurs in the try block.
• Option 3 – Incorrect: A try block can have multiple except clauses for different exception types.
• Option 4 – Correct: Multiple except blocks can be used to handle specific exception types differently, improving clarity and error management.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ValueError:
    print("Invalid number entered.")
except ZeroDivisionError:
    print("Division by zero is not allowed.")
else:
    print("Result is", result)
finally:
    print("Execution completed.")

Key takeaways:

• Use multiple except blocks to handle different exceptions explicitly.
• The else block is optional and runs only if the try block succeeds.
• The finally block is ideal for cleanup actions like closing files or releasing resources.

Explanation:

This example demonstrates try-except-finally inside a loop for handling exceptions on multiple inputs:

1. Iterate through nums = [5, 0, 2].
2. First iteration (n = 5):
   • 10 / 5 = 2.0 → appended to result.
   • finally executes → prints "Processed 5".
3. Second iteration (n = 0):
   • 10 / 0 → raises ZeroDivisionError.
   • except executes → append None to result.
   • finally executes → prints "Processed 0".
4. Third iteration (n = 2):
   • 10 / 2 = 5.0 → appended to result.
   • finally executes → prints "Processed 2".

Final output:

Processed 5
Processed 0
Processed 2
[2.0, None, 5.0]

Key takeaways:

• finally executes on every iteration, ensuring logging or cleanup happens regardless of exceptions.
• Use None or other sentinel values to handle invalid inputs without stopping the program.
• This pattern is useful for processing data collections safely.

Explanation:

This code demonstrates nested try-except-finally handling in loops:

1. First iteration (n = 5):
   • 10 // 5 → 2 printed.
   • No exception → inner except skipped.
   • finally executes → prints "Finally block executed".
2. Second iteration (n = 0):
   • 10 // 0 → raises ZeroDivisionError.
   • Inner except runs → prints "Inner: Division by zero" and raise propagates it.
   • Outer except catches it → prints "Outer: Caught exception".
   • finally executes → prints "Finally block executed".
3. Third iteration (n = 2):
   • 10 // 2 → 5 printed.
   • No exception → inner except skipped.
   • finally executes → prints "Finally block executed".

Final Output:

2
Finally block executed
Inner: Division by zero
Outer: Caught exception
Finally block executed
5
Finally block executed

Key takeaways:

• Nested try-except allows granular handling of exceptions at different levels.
• raise inside an inner except passes the exception to the outer block.
• finally always runs after each try-except, ensuring cleanup for every iteration.

Explanation:

This question focuses on handling exceptions correctly when performing operations on a list:

• Option 1 – Incorrect: No exception handling → program crashes on division by zero.
• Option 2 – Incorrect: Catches TypeError, but division by zero raises ZeroDivisionError.
• Option 3 – Correct: Catches ZeroDivisionError and appends "Error" for invalid divisions → program continues safely.
• Option 4 – Incorrect: Catches IndexError, which does not occur in division → program still crashes.

Step-by-step reasoning:

1. Iterate through numbers: 10, 0, 5.
2. 10 / 10 → 1.0 appended.
3. 10 / 0 → ZeroDivisionError caught → "Error" appended.
4. 10 / 5 → 2.0 appended.

Output:

[1.0, 'Error', 2.0]

Key takeaways:

• Always catch the correct exception type for the operation.
• Gracefully handle errors to avoid program crashes.
• Appending a sentinel value like "Error" or None allows continued processing.

Explanation:

This question tests safe file handling with exception handling:

• Option 1 – Incorrect: f.close() is called outside a try → if an exception occurs during reading or conversion, the file may not close.
• Option 2 – Incorrect: Ensures finally closes the file, but lacks exception-specific handling (e.g., ValueError), so errors may still stop the program.
• Option 3 – Incorrect: Catches ValueError, but if another exception occurs (like FileNotFoundError), the file may remain open.
• Option 4 – Correct: Using with ensures the file is automatically closed, even if exceptions occur. Also handles all exceptions safely.

Step-by-step reasoning:

1. with open("numbers.txt") as f: → context manager opens the file and guarantees closure.
2. Read the file → data = f.read().
3. Convert each item to integer safely → numbers = [int(x) for x in data.split()].
4. File automatically closed when block ends.

Key takeaways:

• Use with statement for safe and concise file handling.
• finally can be used, but context managers are cleaner and less error-prone.
• Always handle potential exceptions when reading and converting data from files.

Explanation:

This code demonstrates nested try-except and the interaction of finally:

• Option 1 – Correct: The outer except catches the ValueError → prints "Outer: Zero not allowed". The finally block always executes → prints "Finally block executed".
• Option 2 – Incorrect: ZeroDivisionError never occurs because n = 0 raises ValueError before the inner try executes.
• Option 3 – Incorrect: Misses finally output.
• Option 4 – Incorrect: Order of finally and outer except is wrong.

Step-by-step reasoning:

1. n = 0 → if n == 0: raise ValueError triggers.
2. Inner try never executes because exception is raised before it.
3. Outer except ValueError prints the message.
4. finally block executes afterward.

Key takeaways:

• Exceptions raised before a try block prevent inner code from running.
• finally always executes after the outer try-except, even if an exception is caught.