Exception Handling in Python – Class 12 Important MCQs with Answers & Explanations

Explanation:
An exception in Python is an error that occurs while the program is running, not before execution.
Unlike syntax errors, which are detected when the code is being parsed, exceptions arise during runtime and can be handled using try-except blocks.

Handling exceptions allows the program to continue executing instead of abruptly stopping.

Common examples include:

• IndexError – accessing an invalid list index
• ZeroDivisionError – division by zero
• NameError – using an undefined variable
• FileNotFoundError – trying to open a file that doesn’t exist

Example:

try:
    x = 10 / 0
except ZeroDivisionError:
    print("Error: Division by zero is not allowed.")

Explanation:

Python is an interpreted language, which means the source code is executed line by line by the Python interpreter.
There is no separate compilation stage as in compiled languages such as C or C++.

Therefore, Compilation Error does not occur in Python.

The main types of errors in Python are:

1. Syntax Errors – mistakes in the code structure or grammar.
   Example: print "Hello" # Missing parentheses → SyntaxError
2. Runtime Errors (Exceptions) – errors that occur while the program is running.
   Example: print(10 / 0) # ZeroDivisionError
3. Logical Errors – flaws in the program logic that produce incorrect output but do not stop execution.
   Example: # Wrong formula used area = 2 * 3.14 * r # Logic error instead of 3.14 * r * r

Summary Table

Error Type	When Occurs	Example	Detected By Interpreter?
Syntax Error	Before execution	print "Hi"	Yes
Runtime Error (Exception)	During execution	10/0	Yes
Logical Error	During execution	wrong formula	No
Compilation Error	—	—	Not applicable in Python

Explanation:

A syntax error occurs when the code violates Python’s grammatical rules or structure.
Such errors are also called parsing errors because they are detected during the parsing stage, before the program starts executing.

When a syntax error is encountered, the Python interpreter halts immediately and displays an error message indicating the line and nature of the mistake.
The program cannot be executed until all syntax errors are fixed.

Example:

print("Hello"

Output:

SyntaxError: unexpected EOF while parsing

The interpreter stops execution and reports the issue — the program will not run until the missing parenthesis is corrected.

Key Point for Exam:

Syntax errors are detected before program execution and must be corrected before the interpreter can run the code.

Explanation:
Exceptions occur during program execution, even if the syntax of the code is correct.
They are runtime errors that interrupt the normal flow of the program.
However, Python provides exception handling mechanisms using try and except blocks, which allow the program to handle these errors gracefully instead of crashing.

Example:

try:
    a = 10
    b = 0
    print(a / b)
except ZeroDivisionError:
    print("Cannot divide by zero.")

Output:

Cannot divide by zero.

Here, the exception (ZeroDivisionError) is handled, preventing the program from terminating abnormally.

Key Point for Exam:

Exceptions can be caught and handled using try-except blocks, allowing the program to continue running normally..

Explanation:
A syntax error occurs when the programmer does not follow Python’s grammatical or structural rules.
These errors are detected before program execution — during the parsing stage — and prevent the code from running until they are corrected.

Common causes of syntax errors include:

• Missing or mismatched parentheses
• Incorrect indentation
• Misspelled keywords or punctuation mistakes

Example:

if True
    print("Hello")

Output:

SyntaxError: expected ':'

The interpreter detects the missing colon (:) and stops execution until it is fixed.

Key Point for Exam:

A syntax error occurs when Python’s grammar or structure is violated and is detected before execution begins.

Explanation:
When using the Python shell (interactive mode), the interpreter executes each line immediately after you press Enter.
If a syntax error is detected, Python instantly reports it, showing both the error type (usually SyntaxError) and a short description of the issue.

The program does not execute until the error is corrected.

Example (in Shell mode):

>>> print "Hello"

Output:

  File "<stdin>", line 1
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello")?

Python clearly indicates the type of error (SyntaxError) and gives a brief explanation suggesting how to fix it.

Key Point for Exam:

In shell mode, Python immediately displays the error name and a short message describing the syntax mistake

Explanation:
When a Python program is executed in script mode, the entire file is checked for syntax correctness before execution.
If any syntax error is found, Python does not run the script and instead displays an error message showing:

• the type of error (e.g., SyntaxError)
• and a brief description of the problem

In environments like IDLE, this message may appear in a dialog box, whereas in a terminal or editor, it appears in the console output.

Example:

print("Hello"

Output:

  File "example.py", line 1
    print("Hello"
                 ^
SyntaxError: unexpected EOF while parsing

Key Point for Exam:

In script mode, Python halts execution and displays an error message (or dialog in IDLE) describing the syntax error before running the program.

Explanation:
This code contains two syntax errors:

1. The colon (:) is incorrectly used — it should appear after a valid control statement such as if, for, or while.
2. The print statement in Python 3 requires parentheses — it should be written as print("GOOD SCORE").

Because of these syntax issues, the Python interpreter detects the error before execution and raises a SyntaxError.

Example (in shell mode):

>>> marks > 20:
  File "<stdin>", line 1
    marks > 20:
              ^
SyntaxError: invalid syntax

Key Point for Exam:

Python checks for syntax errors before execution; misplaced colons or missing parentheses cause a SyntaxError immediately.

Explanation:
In Python 3, print is a function, not a statement as it was in Python 2.
Therefore, parentheses are required when calling it.

Using the old Python 2 syntax (print "Hello World") results in a SyntaxError because it violates Python 3 syntax rules.

Example:

# Correct (Python 3)
print("Hello World")

# Incorrect (Python 2 style)
print "Hello World"   # ❌ SyntaxError

Output for incorrect version:

SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello World")?

Key Point for Exam:

In Python 3, print is a function and must always be written with parentheses — print("message").

Explanation:
When a syntax error occurs, the Python interpreter stops execution immediately and displays a clear error message.
This message typically includes:

1. The error type, such as SyntaxError.
2. A short description of what went wrong.
3. In many cases, a suggestion on how to fix the problem (for example, missing parentheses or colons).

This built-in feedback helps programmers quickly locate and correct syntax issues before running the code successfully.

Example:

print "Hello"

Output:

  File "<stdin>", line 1
    print "Hello"
          ^^^^^^^
SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello")?

Key Point for Exam:

Python immediately reports syntax errors with the error name, a short description, and sometimes a helpful suggestion to correct the mistake.

Explanation:
An exception in Python is an error that occurs while the program is running, even though the syntax of the code is correct.
When such an event happens, Python raises an exception to indicate the error condition.

If the exception is not handled, it causes abnormal termination of the program.
However, exceptions can be handled gracefully using try and except blocks to ensure smooth program execution.

Common examples:

• ZeroDivisionError – dividing by zero
• FileNotFoundError – trying to open a non-existent file
• NameError – using an undefined variable

Example:

try:
    print(10 / 0)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")

Output:

Error: Cannot divide by zero.

Key Point for Exam:

An exception is a runtime error that can be handled using try-except statements to prevent the program from crashing.

Explanation:
Exceptions are runtime errors that occur while the program is executing, even if the syntax is completely valid.
They arise when an operation or statement fails during execution.

Examples:

• ZeroDivisionError → Dividing by zero
• FileNotFoundError → Trying to open a non-existent file
• NameError → Using an undefined variable

These errors can be handled using try and except blocks to prevent program crashes.

Key Point for Exam:

Exceptions occur after successful compilation but during execution, unlike syntax errors which are detected before execution.

Explanation:
Built-in exceptions are predefined error classes in Python that represent common runtime errors.
They are part of Python’s standard library and are automatically raised by the interpreter when specific conditions fail during program execution.

Examples include:

• ZeroDivisionError – dividing by zero
• NameError – using an undefined variable
• TypeError – performing an operation on incompatible data types
• ValueError – passing an invalid value to a function
• EOFError – reading beyond the end of a file

Key Point for Exam:

Built-in exceptions are ready-made error classes provided by Python to handle frequent runtime issues efficiently.

Explanation:
When a program attempts to divide any number by zero, Python immediately raises a ZeroDivisionError.
This is a runtime exception, meaning it occurs while the program is executing, not during compilation or parsing.

Example:

print(10 / 0)   # Raises ZeroDivisionError

To prevent the program from crashing, it can be handled using a try-except block:

try:
    print(10 / 0)
except ZeroDivisionError:
    print("Division by zero is not allowed.")

Key Point for Exam:

ZeroDivisionError occurs only at runtime when a division operation’s denominator is zero.

Explanation:
A NameError occurs when Python encounters a variable or identifier that has not been defined in the current scope.
This means the interpreter cannot find the variable name in memory during execution.

Example:

print(x)   # x is not defined → Raises NameError

To fix this, the variable must be defined before use:

x = 10
print(x)   # Output: 10

Key Point for Exam:

NameError indicates that a variable or identifier is being used before it is defined or imported.

Explanation:
An IndexError is raised when a program tries to access an element of a sequence (like a list, tuple, or string) using an index that is outside the valid range.

Example:

lst = [1, 2, 3]
print(lst[5])   # Raises IndexError: list index out of range

The valid indices for lst are 0, 1, 2.
Accessing lst[5] triggers an IndexError because the fifth index does not exist.

Key Point for Exam:

IndexError occurs when a sequence is accessed using an invalid index, exceeding its valid range.

Explanation:
An EOFError occurs when Python expects input (for example, via the input() function) but reaches the end-of-file (EOF) without receiving any data.
This commonly happens when reading from files or when input is terminated unexpectedly.

Example:

# Expecting user input
data = input("Enter something: ")

If the input stream ends (e.g., in a file or redirected input) without providing data, Python raises:

EOFError: EOF when reading a line

Key Point for Exam:

EOFError occurs when input is expected but the end-of-file is reached before any data is read.

Explanation:
User-defined exceptions are custom exceptions created by programmers to handle specific situations that built-in exceptions cannot adequately address.
This allows the programmer to provide more precise and meaningful error handling in a program.

Example:

# Define a custom exception
class NegativeValueError(Exception):
    pass

def check_value(x):
    if x < 0:
        raise NegativeValueError("Negative values are not allowed")

# Usage
try:
    check_value(-5)
except NegativeValueError as e:
    print("Error:", e)

Output:

Error: Negative values are not allowed

Key Point for Exam:

User-defined exceptions let programmers create custom error types for situations not covered by Python’s built-in exceptions.

Explanation:
When an exception is raised using the raise statement:

1. Python immediately stops executing the current block of code.
2. The control jumps to the corresponding exception handler (except block).
3. Any statements after the raise in the same block are not executed.

This ensures that errors are properly handled without letting the program continue in an unstable state.

Example:

try:
    raise Exception("OOPS!! An Exception has occurred")
    print("This line will not execute")
except Exception as e:
    print("Exception caught:", e)

Output:

Exception caught: OOPS!! An Exception has occurred

Here, the line after raise is skipped, and control moves directly to the except block.

Key Point for Exam:

The raise statement interrupts normal execution and transfers control to the appropriate exception handler.

Explanation:
The raise statement is used to explicitly throw an exception in Python.

• The exception name specifies the type of error.
• The optional argument is usually a string describing the error message.

Example:

raise Exception("OOPS!! An Exception has occurred")

Output:

Traceback (most recent call last):
  ...
Exception: OOPS!! An Exception has occurred

Here, Python raises an Exception and displays the error message provided as the argument.

Key Point for Exam:

Use raise Exception("message") to explicitly trigger an exception with a custom message.

Explanation:
The raise statement in Python can be used to manually trigger both:

1. Built-in exceptions — such as IndexError, ValueError, or ZeroDivisionError.
2. User-defined exceptions — custom exceptions created by the programmer to handle specific situations.

Examples:

# Raising a built-in exception
raise IndexError("List index out of range")

# Raising a user-defined exception
class MyError(Exception):
    pass

raise MyError("Custom exception raised by user")

Both examples stop program execution and display the corresponding error message until handled using a try-except block.

Key Point for Exam:

The raise statement can generate any exception type, whether predefined (built-in) or created by the user (custom).

Explanation:
The value of length is greater than the length of the list numbers.
When the condition length > len(numbers) evaluates to True, Python executes the raise IndexError statement.

• The raise statement immediately interrupts the normal flow of the program.
• Any statements after raise in the same block (like print("NO EXECUTION")) are not executed.

Hence, an IndexError is raised, and the message "NO EXECUTION" is not displayed.

Key Point for Exam:

The raise statement halts execution instantly; code written after it in the same block will never run.

Explanation:
When raising an exception using the raise statement, an optional argument can be provided — usually a string message.
This message helps describe the cause of the error, making debugging easier and output more meaningful.

Example:

raise Exception("OOPS!! An Exception has occurred")

Output:

Exception: OOPS!! An Exception has occurred

Here, the message "OOPS!! An Exception has occurred" clearly explains why the exception was raised.

Key Point for Exam:

The argument in the raise statement provides a custom error message that helps identify the cause of the exception.

Explanation:
When an exception occurs, Python displays a stack traceback — a structured message showing where and how the error happened.
It lists the sequence of function calls (from first to last) that led to the exception.
The last line in the traceback indicates the exact location where the error was raised.

This information helps programmers debug the code and trace the source of the problem.

Example:

numbers = [40, 50, 60, 70]
length = 10

if length > len(numbers):
    raise IndexError

Output:

Traceback (most recent call last):
  File "<pyshell#7>", line 4, in <module>
    raise IndexError
IndexError

Key Point for Exam:

A stack traceback shows the chain of function calls that led to an exception, helping in error tracking and debugging.

Explanation:
The assert statement is used for debugging and validation.
It checks whether a condition (expression) is True.

• If the condition is True, the program continues normally.
• If the condition is False, Python raises an AssertionError with an optional custom message.

This is often used to ensure that certain conditions hold true during program execution.

Syntax:

assert Expression[, "Optional error message"]

Example:

def negativecheck(number):
    assert number >= 0, "OOPS... Negative Number"

negativecheck(-5)

Output:

AssertionError: OOPS... Negative Number

Key Point for Exam:

The assert statement acts as a self-check tool to verify assumptions in your code. If the assumption fails, it raises an AssertionError automatically.

Explanation:
The assert statement is primarily used for testing assumptions and validating input conditions during development.
It ensures that certain conditions hold true before the program proceeds further.
If the condition fails, an AssertionError is raised immediately, helping developers identify logic or input errors early.

Example:

def square_root(n):
    assert n >= 0, "Negative input not allowed"
    return n ** 0.5

square_root(-4)

Output:

AssertionError: Negative input not allowed

Key Point for Exam:

Use assert for internal checks and debugging, not for handling runtime or user-generated errors.

Explanation:
When the condition (expression) in an assert statement evaluates to True, Python simply does nothing — it proceeds to execute the next lines of code normally.
The AssertionError is raised only if the condition evaluates to False.

Example:

x = 10
assert x > 0, "x must be positive"
print("Program continues")

Output:

Program continues

Key Point for Exam:

The assert statement is a debugging aid — it only interrupts execution when the tested condition is False.

Explanation:
When the condition in an assert statement evaluates to False, Python immediately raises an AssertionError.
This halts execution of the current block or function, and no statements after the failed assertion are executed.
It is mainly used to validate assumptions and check preconditions in code.

Example:

def negativecheck(number):
    assert number >= 0, "OOPS... Negative Number"

print(negativecheck(100))   # Works fine
print(negativecheck(-350))  # Raises AssertionError

Output:

None
Traceback (most recent call last):
AssertionError: OOPS... Negative Number

Key Point for Exam:

When an assert fails, Python raises an AssertionError and stops execution immediately — it never continues to the next line.

Explanation:
Exception handling in Python ensures that runtime errors (like division by zero, file not found, etc.) do not cause the program to crash unexpectedly.
Instead, programmers can catch these exceptions and handle them gracefully — for example, by showing a helpful message or taking corrective action.
This improves the user experience and program stability.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
    print("Result:", result)
except ZeroDivisionError:
    print("Cannot divide by zero!")

Output (if user enters 0):

Cannot divide by zero!

Key Point for Exam:

Exception handling doesn’t fix errors — it manages them so the program can respond gracefully instead of crashing.

Explanation

1. Default return value in Python functions:
   • In Python, if a function does not have a return statement, it implicitly returns None.
   • Example: def foo(): pass print(foo()) # Output: None
2. Behavior of negativecheck function:
   • Suppose Program 1-1 defines the function as: def negativecheck(x): assert x >= 0, "Negative value not allowed"
   • When you call negativecheck(100):
     • The assertion passes because 100 ≥ 0.
     • The function has no return statement, so Python returns None.
     • If you print the function call, None appears in the output.
3. When AssertionError occurs:
   • If the input is negative, e.g., negativecheck(-5):
     • The assertion fails.
     • Python immediately raises an AssertionError.
     • The function never reaches a return statement, so None is not printed.
4. Why other options are wrong:
   • (B) assert does not print None.
   • (C) Negative input triggers only AssertionError, not None.
   • (D) Python does not automatically insert None; it only returns None for functions without an explicit return.

Key Point for Exam:

• None appears because the function does not explicitly return a value, and Python automatically returns None in such cases.
• AssertionError occurs before return if the input violates the assertion, so None is not printed then.

Explanation:
Reason for categorizing exceptions:

• Python categorizes exceptions into different types so that programmers can write specific exception handlers for each type of error.
• This allows different types of errors to be handled differently.

Benefits:

• Keeps the main logic of the program separate from error-handling code.
• Makes programs more robust, readable, and maintainable.

Example:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

try:
    file = open("data.txt", "r")
except FileNotFoundError:
    print("File not found!")

• ZeroDivisionError is handled separately from FileNotFoundError.

Key Point for Exam:

Each type of exception can have a custom handler, improving program robustness.
Categorizing exceptions allows precise control over error handling.

Call Stack in Exception Handling

Definition:

• The call stack is a hierarchy of active functions/methods at a specific point during program execution.

Purpose in Exception Handling:

• When an exception occurs, Python searches for an appropriate handler starting from the function where the exception was raised.
• If no handler is found, Python moves up the call stack (to the calling function) until a suitable handler is found or the top-level program is reached.

Mechanism:

• The call stack follows a Last-In, First-Out (LIFO) order.
• The most recently called function is checked first for an exception handler.
• Executing the found handler is called catching the exception.

Example:

def divide(a, b):
    return a / b

def calculate():
    try:
        result = divide(10, 0)
    except ZeroDivisionError:
        print("Cannot divide by zero!")

calculate()

Output:

Cannot divide by zero!

Flow Explanation (Step-wise):

1. calculate() calls divide(10, 0).
2. ZeroDivisionError occurs in divide(). Python checks for a handler in divide() → none found.
3. Python moves up to calculate() → finds the handler → exception is caught.

Key Points for Exam:

• Call stack ensures organized and controlled exception handling.
• Python searches for exception handlers in reverse order of function calls, preventing abrupt program crashes.

Explanation:

1. What is an Exception?

• An exception is an error that occurs during the execution of a program.
• Examples: dividing by zero (ZeroDivisionError), accessing a file that doesn’t exist (FileNotFoundError), using an undefined variable (NameError).
• When an exception occurs, Python raises it, which means it signals that an error has happened.

2. Catching an Exception

• Catching an exception means that Python detects the error and then executes a block of code specifically written to handle it.
• This is done using try and except blocks.
• Instead of letting the program terminate abruptly (crash), the program can handle the error gracefully.

3. Why is it important?

• Keeps the main program logic separate from error-handling code.
• Makes the program robust, readable, and maintainable.
• Allows different types of errors to be handled differently, giving the programmer precise control over error handling.

4. How it works (Flow)

1. Python executes code inside a try block.
2. If no error occurs → except block is skipped.
3. If an error occurs → Python searches for a matching except block.
4. The matched handler executes → program continues without crashing.

5. Example:

# Example 1: Handling division by zero
try:
    x = 10 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")

# Example 2: Handling file not found
try:
    file = open("data.txt", "r")
except FileNotFoundError:
    print("File not found!")

Output:

Cannot divide by zero!
File not found!

• Notice how each type of exception (ZeroDivisionError, FileNotFoundError) is handled separately.

6. Key Exam Points:

• Catching an exception = handling errors gracefully.
• Use try–except blocks to prevent program crashes.
• Specific exception types can have custom handlers → more precise error handling.
• Improves program robustness, readability, and maintainability.

Explanation:

1. Definition of a Caught Exception

• When an exception occurs in Python, it is “caught” if the exception handler code written for that type of exception is executed.
• This ensures that the program can handle the error gracefully instead of terminating abruptly.

2. How it Works

1. Python executes code inside a try block.
2. If an error occurs that matches an except block, Python executes the handler code inside that except block.
3. The exception is now considered caught.
4. If no matching handler exists, the program terminates with an error message.

3. Why Catching Exceptions is Useful

• Prevents the program from crashing unexpectedly.
• Allows the programmer to display meaningful error messages or take alternative actions.
• Keeps the main logic separate from error-handling code.

4. Example:

try:
    number = int(input("Enter a number: "))
    result = 10 / number
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter an integer.")

Explanation of Example:

• If the user enters 0 → ZeroDivisionError is caught → prints "Cannot divide by zero!"
• If the user enters "abc" → ValueError is caught → prints "Invalid input! Please enter an integer."
• Program does not crash; appropriate messages are displayed.

5. Key Exam Points:

• Catching an exception = executing the specific handler code.
• Use try-except blocks to handle expected runtime errors.
• Helps in making programs robust, readable, and user-friendly.

Explanation:

1. How Python Handles Exceptions

• When an exception occurs, Python searches for a matching exception handler in the current scope or method.
• If no handler is found there, it moves up the call stack (i.e., checks the functions/methods that called the current function) to find a suitable handler.

2. What Happens if No Handler is Found

• If Python cannot find a suitable handler anywhere in the call stack:
  • The program terminates immediately.
  • Python displays a traceback, showing the error type, message, and the sequence of function calls that led to the exception.

3. Why This Happens

• Allowing a program to continue after an unhandled exception could put it in an unpredictable state.
• Terminating execution ensures data integrity and signals clearly that an error occurred.

4. Example:

def divide(a, b):
    return a / b  # may raise ZeroDivisionError

def main():
    result = divide(10, 0)  # no try-except here

main()

Output:

Traceback (most recent call last):
  File "example.py", line 7, in <module>
    main()
  File "example.py", line 5, in main
    result = divide(10, 0)
  File "example.py", line 2, in divide
    return a / b
ZeroDivisionError: division by zero

• Here, no handler exists, so Python terminates and prints the traceback.

5. Key Exam Points:

• If no suitable exception handler is found, Python terminates execution.
• Traceback helps in debugging by showing the call stack and error details.
• Always anticipate possible exceptions and handle them using try-except blocks to prevent abrupt termination.

Explanation:

1. Step 1: Exception Object Creation

• When an error occurs in Python, the interpreter creates an exception object.
• This object contains information about the error, such as the type of exception and the error message.

2. Step 2: Exception Raised

• The exception object is raised (or thrown), signaling that an error has occurred.
• At this point, normal program execution is interrupted.

3. Step 3: Runtime Searches for Handler

• Python searches for a matching exception handler:
  1. First, in the current function or method.
  2. Then, in reverse order of the call stack (the functions that called the current function).

4. Step 4: Handler Executed (if found)

• If a suitable except block is found, it executes the handler code, which is also called catching the exception.
• This prevents the program from terminating abruptly and allows it to handle the error gracefully.

5. Step 5: Program Continues or Terminates

• If the exception is handled, the program continues execution after the except block.
• If no handler is found in the call stack, the program terminates, and Python displays a traceback showing the error details.

6. Example:

def divide(a, b):
    return a / b  # may raise ZeroDivisionError

try:
    result = divide(10, 0)
except ZeroDivisionError:
    print("Cannot divide by zero!")

print("Program continues execution.")

Output:

Cannot divide by zero!
Program continues execution.

• Stepwise sequence in this example:
  1. ZeroDivisionError object created
  2. Exception raised
  3. Runtime searches for handler → finds except ZeroDivisionError
  4. Handler executed → prints message
  5. Program continues → prints "Program continues execution."

7. Key Exam Points:

• Always remember the sequence:
  Exception object → Raised → Handler search → Handler executed → Continue/Terminate
• Proper exception handling ensures robust and predictable programs.

Explanation:

1. Definition of Forwarding an Exception

• Forwarding an exception means that if Python cannot find a suitable handler in the current method, it passes the exception to the calling method.
• This process continues up the call stack until a handler is found or the program terminates.

2. Why Forwarding is Important

• It allows higher-level methods to handle exceptions that lower-level methods cannot.
• Ensures that exceptions are not lost, and the program can take appropriate action or terminate safely.

3. How it Works

1. Exception occurs in a method/function.
2. Python searches for a handler in the current method.
3. If none is found → forwards the exception to the method that called the current one.
4. The search continues up the call stack until a handler is found or the program terminates.

4. Example:

def divide(a, b):
    return a / b  # may raise ZeroDivisionError

def calculate():
    result = divide(10, 0)  # no try-except here

try:
    calculate()  # forwarding exception will be caught here
except ZeroDivisionError:
    print("Exception caught in the calling method.")

Output:

Exception caught in the calling method.

• Explanation:
  • divide() raises ZeroDivisionError
  • No handler in divide() → forwarded to calculate()
  • No handler in calculate() → forwarded to outer try-except
  • Exception caught in outermost try block

5. Key Exam Points:

• Forwarding = searching for a handler higher in the call stack.
• Helps in centralized exception handling.
• If no handler exists anywhere in the stack → program terminates with traceback.

Explanation:

1. Purpose of the try Block

• The try block is used to enclose the code that might raise an exception.
• It allows Python to monitor for exceptions without stopping program execution abruptly.

2. How it Works

1. Python executes statements inside the try block.
2. If no exception occurs → the except block is skipped, and program continues normally.
3. If an exception occurs → control immediately transfers to the corresponding except block.
4. The exception is handled gracefully, preventing program crashes.

3. Why it is Important

• Separates normal program logic from error-handling code.
• Makes programs robust, readable, and maintainable.
• Allows specific handling of different types of exceptions using multiple except blocks.

4. Example:

try:
    number = int(input("Enter a number: "))
    result = 10 / number
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter an integer.")

print("Program continues execution.")

Output (if user enters 0):

Cannot divide by zero!
Program continues execution.

Output (if user enters “abc”):

Invalid input! Please enter an integer.
Program continues execution.

• The try block ensures exceptions are caught before the program crashes.

5. Key Exam Points:

• Try block = code monitored for exceptions.
• Except block = code that handles the exception.
• Using try-except ensures program robustness and graceful error handling.

Explanation:

1. Definition of a try Block

• A try block is used to contain code that may raise an exception.
• It allows Python to monitor for errors without stopping program execution abruptly.

2. How it Works

1. Python executes the statements inside the try block.
2. If no exception occurs → the except block is skipped, and program continues normally.
3. If an exception occurs → Python stops executing the remaining code inside the try block.
4. Control is transferred to the matching except block, where the error can be handled.

3. Why it is Important

• Separates normal program logic from error-handling code.
• Allows the program to handle errors gracefully instead of crashing.
• Enables handling different types of exceptions using multiple except blocks.

4. Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter an integer.")

print("Program continues execution.")

Output (if user enters 0):

Cannot divide by zero!
Program continues execution.

Output (if user enters “abc”):

Invalid input! Please enter an integer.
Program continues execution.

• The try block ensures any potential exception is caught before the program crashes.

5. Key Exam Points:

• Try block = monitored code for exceptions.
• Must be paired with except block(s) to handle errors.
• Ensures program robustness, readability, and graceful error handling.

Explanation:

1. Behavior of the try Block on Exception

• When an exception occurs inside a try block, Python immediately stops executing the remaining statements in that block.
• The rest of the code in the try block is skipped to prevent further errors.

2. Transfer of Control

• Control is then transferred to the corresponding except block that matches the exception type.
• The exception is handled gracefully, and the program can continue execution after the except block.

3. Why This Happens

• Prevents execution of statements that might depend on failed operations, avoiding further runtime errors.
• Ensures robustness and predictable program behavior.

4. Example:

try:
    print("Step 1")
    x = 10 / 0  # Raises ZeroDivisionError
    print("Step 2")  # This line is skipped
except ZeroDivisionError:
    print("Exception handled: Cannot divide by zero!")

print("Program continues...")

Output:

Step 1
Exception handled: Cannot divide by zero!
Program continues...

• Notice "Step 2" is skipped because the exception occurred before it.

5. Key Exam Points:

• Any remaining statements after an exception in a try block are skipped.
• The corresponding except block executes to handle the error.
• Helps in maintaining program stability and avoiding further runtime errors.

Explanation:

1. What Happens in the Code

• The division numerator / denom is inside a try block, which monitors for exceptions.
• If denom = 0, Python raises a ZeroDivisionError.

2. Control Flow on Exception

• Once the exception occurs:
  1. Python stops executing remaining statements in the try block (if any).
  2. Control is transferred to the matching except block.
  3. The except block executes the code: print("Denominator as ZERO not allowed").
• The program does not crash and continues after the except block.

3. Why This Happens

• ZeroDivisionError is a built-in exception for division by zero.
• Using try-except allows graceful handling of runtime errors.

4. Example with Values:

numerator = 10
denom = 0

try:
    quotient = numerator / denom
except ZeroDivisionError:
    print("Denominator as ZERO not allowed")

print("Program continues...")

Output:

Denominator as ZERO not allowed
Program continues...

• The exception is caught, and program continues execution after the except block.

5. Key Exam Points:

• Division by zero raises ZeroDivisionError.
• Try-except block handles the exception gracefully.
• The program does not terminate abruptly when the exception is caught.

Explanation:

1. Behavior of the Except Block

• The except block only executes if an exception occurs in the associated try block.
• If no error occurs, Python skips the except block entirely.

2. Control Flow

1. Python executes all statements inside the try block.
2. No exception → except block is ignored.
3. Execution continues with the next statement after the try…except block.

3. Why This Happens

• This ensures normal program flow when the code runs without errors.
• Prevents unnecessary execution of error-handling code.

4. Example:

try:
    result = 10 / 2  # No exception occurs
except ZeroDivisionError:
    print("Cannot divide by zero!")

print("Program continues execution.")

Output:

Program continues execution.

• The except block is skipped because no exception occurred.

5. Key Exam Points:

• Except block executes only if an exception occurs in the try block.
• Normal program execution resumes after the try…except block when no error occurs.
• Using try-except does not affect normal program flow if there are no exceptions.

Explanation:

1. Meaning of the else Block

• The else block in Python’s exception handling structure is optional.
• It contains code that should run only when no exception occurs in the try block.

In short:
If the try block runs successfully (without errors), the else block executes.

2. Syntax of try…except…else:

try:
    # Code that may raise an exception
except ExceptionName:
    # Code to handle the exception
else:
    # Code to run if no exception occurs

3. Control Flow

1. The code inside the try block executes.
2. If an exception occurs → control goes to the except block.
3. If no exception occurs → control goes to the else block.
4. After the else block executes, the program continues normally.

4. Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
else:
    print("Division successful. Result =", result)

Case 1:
If input = 0

Error: Cannot divide by zero.

Case 2:
If input = 5

Division successful. Result = 2.0

Note – The else block runs only when no exception occurs.

5. Key Exam Points

• The else block is executed only if no exception occurs in the try block.
• It helps in keeping the normal code separate from error-handling code.
• The use of else improves readability and logical clarity of programs.

Explanation:

• When the user enters a non-zero integer, no exception is raised.
• The try block executes completely, printing:
  "Division performed successfully".
• After the try…except block finishes, the program continues normally and executes the next statement:
  "OUTSIDE try..except block".

So, both messages appear sequentially.

Final Output Example (if input = 5):

10.0
Division performed successfully
OUTSIDE try..except block

Key Concept:

If no exception occurs, the except block is skipped and the program flow continues with the next statements after the try…except block.

Explanation:

• When the user enters 0 as the denominator, the statement print(numerator / denom) causes Python to raise a ZeroDivisionError, because division by zero is mathematically undefined.
• The except ZeroDivisionError: block catches this exception and executes its code: Denominator as ZERO not allowed
• After handling the exception, Python skips the remaining statements in the try block and continues with the next statement after the try…except block.

Example Output (if input = 0):

Denominator as ZERO not allowed
OUTSIDE try..except block

Key Concept:

The ZeroDivisionError is raised whenever a program tries to divide a number by zero.
Using a proper except block prevents program termination and allows smooth continuation of execution.

Explanation:

• A single try block can be followed by multiple except blocks, each designed to handle a different type of exception.
• When an exception occurs, Python searches for the first matching except block and executes it.
• All other except blocks are skipped once a match is found.

Example:

try:
    num1 = int(input("Enter numerator: "))
    num2 = int(input("Enter denominator: "))
    print(num1 / num2)
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
except ValueError:
    print("Error: Invalid input. Please enter integers only.")

Case 1:
Input → num1 = 10, num2 = 0
→ Output → Error: Cannot divide by zero.

Case 2:
Input → num1 = 10, num2 = 'a'
→ Output → Error: Invalid input. Please enter integers only.

Key Concept:

• Multiple except blocks = multiple exception types handled separately.
• Only one matching except block executes per raised exception.

Explanation:

1. Understanding the code:
   • input() always returns a string in Python.
   • int() tries to convert the input string into an integer.
2. What happens with invalid input:
   • If the user enters a non-integer string like "abc" or a float like "3.5", Python cannot convert it to an integer.
   • This raises a ValueError:
   denom = int("abc") # Raises ValueError
3. Why not other exceptions:
   • ZeroDivisionError → only occurs when dividing by zero.
   • TypeError → occurs when an operation is applied to an incompatible type, e.g., '5' + 3.
   • NameError → occurs when using a variable that is not defined.
4. Handling the exception:
   • You can prevent the program from crashing using an except ValueError block:
   try: denom = int(input("Enter the denominator: ")) except ValueError: print("Invalid input! Please enter an integer.")
5. Example runs:
   • Input: 'abc' → Output: Invalid input! Please enter an integer.
   • Input: '5' → Output: denom = 5 (no exception occurs)

Key Point:

• ValueError is raised whenever a function receives the correct type but an invalid value.
• Always use except ValueError: to safely handle input conversion errors.

Explanation:

1. Step 1 — Input and try block

denom = int(input("Enter the denominator: "))
print(numerator / denom)

• User enters 0.
• int("0") successfully converts the input to integer → no ValueError occurs.
• Next, numerator / denom = 50 / 0 → Python raises ZeroDivisionError.

2. Step 2 — Exception handling

• Python searches for an except block matching the raised exception.
• except ZeroDivisionError: matches → executes this block.
• except ValueError: does not match, so it is ignored.

3. Step 3 — Output

Denominator as ZERO not allowed

Key Concept:

• Python executes only the first matching except block for a raised exception.
• Other except blocks that do not match the exception type are skipped.

Quick Summary Table for this code:

Input	Exception Raised	Except Block Executed
0	ZeroDivisionError	ZeroDivisionError block
“abc”	ValueError	ValueError block
5	None	No except block, normal execution

This clearly demonstrates how multiple except blocks work in Python: only the matching one executes, and the rest are ignored..

Explanation:

1. Generic except block

• An except: block without an exception name is called a generic except block.
• It can catch any exception that has not been handled by previous specific except blocks.

2. Why it’s useful

• It prevents the program from crashing unexpectedly when an unanticipated exception occurs.
• Acts as a catch-all safety net.

3. Important rules

• Always place the generic except: block at the end after all specific except blocks.
• Otherwise, it would override specific exception handlers, preventing them from executing.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Invalid input! Enter an integer.")
except:
    print("An unexpected error occurred.")

Case 1: Input = 'abc' → ValueError → Executes except ValueError
Case 2: Input = 0 → ZeroDivisionError → Executes except ZeroDivisionError
Case 3: Some other unexpected exception occurs → Executes generic except:

Key Concept:

• Use generic except: for catching unexpected exceptions.
• Ensures the program does not terminate abruptly.
• Always keep it after all specific except blocks to maintain proper exception handling order.

Explanation:

1. Step 1 — Input and try block

• User enters 0 as the denominator.
• int("0") successfully converts the input → no ValueError.
• Next, numerator / denom = 50 / 0 → Python raises ZeroDivisionError.

2. Step 2 — Exception handling

• Python looks for a matching except block:
  • except ValueError: → does not match, so skipped.
  • except: → generic catch-all block → executes.

3. Step 3 — Output

OOPS...SOME EXCEPTION RAISED

Key Concept:

• A generic except: block catches any exception not explicitly handled by previous specific except blocks.
• This prevents the program from terminating abruptly when an unexpected exception occurs.

Quick Example Table for This Code:

Input	Exception Raised	Except Block Executed
0	ZeroDivisionError	Generic except: block
“abc”	ValueError	except ValueError: block
5	None	No exception, normal execution

Takeaway:

• Use specific except blocks for known exceptions.
• Use a generic except: at the end to handle unexpected errors safely.

Explanation:

1. Python executes except blocks sequentially:

• Python checks each except block in the order they appear.
• It executes the first matching except block for the raised exception.

2. Why place generic except last:

• A generic except: block matches any exception.
• If placed first, it will catch all exceptions, including those that specific except blocks are meant to handle.
• This prevents specific exception handlers from executing.

3. Correct order:

try:
    # risky code
except ZeroDivisionError:
    print("Cannot divide by zero.")  # specific handler
except ValueError:
    print("Invalid input!")           # specific handler
except:
    print("Some unexpected error occurred")  # generic catch

Key Concept:

• Specific exceptions first → Generic exception last.
• Ensures proper handling of known exceptions while still catching unexpected ones.

Takeaway:

• Always place except: at the end to avoid overriding specific exception handlers.

Explanation:

1. Purpose of the else clause:

• The else clause is optional in Python’s exception-handling structure.
• It contains code that should execute only when the try block succeeds without raising any exception.

2. Why use it:

• Helps keep normal execution code separate from exception-handling code, improving readability and logical clarity.

3. Syntax Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Invalid input! Enter an integer.")
else:
    print("Division successful. Result =", result)

Example Runs:

• Input = 5:
  Output:

Division successful. Result = 2.0

• Input = 0:
  Output:

Cannot divide by zero.

• Input = “abc”:
  Output:

Invalid input! Enter an integer.

Observation:

• else runs only when no exception occurs.
• If any exception occurs, the else block is skipped.

Key Concept:

• else is used for code that should run only under normal conditions.
• It separates normal execution from error handling, enhancing clarity and maintainability.

Explanation:

1. Multiple except blocks:

• A single try block can have multiple except blocks to handle different types of exceptions separately.

2. Generic except block:

• A generic except: block can catch any exception not handled by specific except blocks.
• It should be placed after all specific except blocks to avoid overriding them.

3. Optional else block:

• The else block executes only if no exceptions occur in the try block.
• It keeps normal execution separate from error-handling logic.

Example:

try:
    num1 = int(input("Enter numerator: "))
    num2 = int(input("Enter denominator: "))
    result = num1 / num2
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Invalid input! Enter an integer.")
except:
    print("Some unexpected error occurred.")
else:
    print("Division successful. Result =", result)

Observations:

• Handles multiple specific exceptions.
• Catches unhandled exceptions with generic except:.
• Runs else block only if no exception occurs.

Key Concept:

Python provides flexible and structured exception handling:

• Multiple specific handlers
• Generic catch-all handler
• Optional else for normal execution

This makes programs robust and easier to maintain.

Explanation:

1. Purpose of the else clause:

• The else clause is optional and runs only if the try block executes successfully without raising any exception.

2. Why it is useful:

• It separates normal execution code from exception-handling code, improving readability and maintainability.

3. Behavior:

• If an exception occurs → the corresponding except block executes, and the else block is skipped.
• If no exception occurs → the else block executes after the try block.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero.")
except ValueError:
    print("Invalid input! Enter an integer.")
else:
    print("Division successful. Result =", result)

Cases:

• Input = 5 → Output: "Division successful. Result = 2.0" → else executes
• Input = 0 → Output: "Cannot divide by zero." → else skipped
• Input = "abc" → Output: "Invalid input! Enter an integer." → else skipped

Key Concept:

• else runs only when the try block succeeds.
• It keeps normal execution separate from error-handling logic.

Explanation:

1. What happens step-by-step:
   • numerator = 50
   • denom = 5 → successfully converted to integer
   • quotient = 50 / 5 → 10.0
   • No exception is raised.
2. Control flow:
   • Since no exception occurs, both except blocks are skipped.
   • The program moves to the else block, which executes and displays: The result of division operation is 10.0
3. Why the else block runs:
   • The else clause in a try..except structure executes only when the try block runs successfully without any exceptions.

Key Concept:

• ZeroDivisionError → occurs only when denominator is 0.
• ValueError → occurs only when a non-integer input is entered.
• Else block → runs only when no exceptions occur.

Final Output:

The result of division operation is 10.0

Explanation:

1. Purpose of the finally clause:
   • The finally clause is used to define code that must always execute, whether an exception occurs or not.
   • It is typically used for cleanup operations like closing files, releasing memory, or disconnecting from a database.
2. Execution behavior:
   • If no exception occurs → finally executes after the try (and else, if present).
   • If an exception occurs and is caught → finally still executes after the except block.
   • If an exception occurs and is not caught, the finally block executes before the program terminates.

Example:

try:
    file = open("data.txt", "r")
    data = file.read()
except FileNotFoundError:
    print("File not found.")
finally:
    print("Closing file (if open).")
    try:
        file.close()
    except:
        pass

Output cases:

• If file exists → file is read, then “Closing file (if open).” is printed.
• If file doesn’t exist → “File not found.” and then “Closing file (if open).”

Key Concept:

• The finally clause guarantees the execution of important cleanup code.
• Ensures reliability and resource safety, even in case of runtime errors.

Summary:
The finally block in Python always executes, making it essential for cleanup, resource management, and program stability.

Explanation:

1. Execution Flow (when no exception occurs):
   • Step 1: The try block executes first.
   • Step 2: Since no exception occurs, all except blocks are skipped.
   • Step 3: The optional else block executes next.
   • Step 4: Finally, the finally block executes, regardless of the outcome.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero.")
else:
    print("Division successful. Result =", result)
finally:
    print("Program execution completed.")

Case: Input = 5

Output:

Division successful. Result = 2.0
Program execution completed.

Flow:
try → else → finally

Key Concept:

No Exception	try → else → finally
Exception Caught	try → except → finally
Exception Not Caught	try → finally (before program ends with error)

Summary:

• try runs first.
• If no error → else runs.
• Finally → finally always runs last.

This sequence ensures clear separation between normal execution, error handling, and cleanup operations.

Explanation:

1. Position of the finally clause:
   • The finally block must always be placed at the end of a try..except structure.
   • It comes after all except blocks and the optional else block (if present).
   • This ensures that the cleanup code in finally runs after all normal or error-handling code has finished.
2. Purpose:
   • The finally clause contains code that must always execute, such as closing files, releasing resources, or printing completion messages.

Correct Syntax Example:

try:
    # Code that may raise an exception
except SomeException:
    # Handle the exception
else:
    # Executes only if no exception occurs
finally:
    # Executes always, regardless of exception

Example in Practice:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Cannot divide by zero.")
else:
    print("Division successful. Result =", result)
finally:
    print("Program execution completed.")

Case 1: Input = 5
Output:

Division successful. Result = 2.0
Program execution completed.

Case 2: Input = 0
Output:

Cannot divide by zero.
Program execution completed.

Key Concept:

• The finally block must be the last clause in the exception-handling sequence.
• It ensures proper cleanup and resource release regardless of what happens in the try or except blocks.

Summary:
The correct placement of the finally block — after all except and else clauses — guarantees that it executes last, maintaining clean and predictable program flow.

Explanation:

1. Step-by-step execution:
   • The user enters 0.
   • Python attempts to execute quotient = numerator / denom, i.e., 50 / 0.
   • This raises a ZeroDivisionError.
2. Control flow:
   • The except ZeroDivisionError block executes, printing:
     "Denominator as ZERO is not allowed"
   • Since an exception occurred, the else block is skipped.
   • The finally block always executes, printing:
     "OVER AND OUT"
3. Final Output: Denominator as ZERO is not allowed OVER AND OUT

Key Points to Remember:

• else block executes only if no exception occurs.
• finally block executes always, regardless of exceptions.
• When an exception occurs, control moves directly to the matching except block.

Summary:
When the denominator is 0 →

• The program prints the error message from except.
• The cleanup message from finally is printed.
  Hence, the correct answer is (D) Both B and C.

Explanation:

1. Execution Flow (No Exception Occurs):
   • Step 1: The code inside the try block executes first.
     If no exception occurs, Python moves to the next step.
   • Step 2: The else block executes (optional).
     This block runs only when the try block executes successfully without any errors.
   • Step 3: The finally block executes.
     This block always executes, regardless of whether an exception occurred or not.
2. Control Flow Summary: try → else → finally
3. Why This Order?
   • try: contains main operation (may raise exceptions).
   • else: runs only if try succeeded (used for post-success actions).
   • finally: runs always (used for cleanup, closing files, etc.).

Example Code:

try:
    print("In try block")
except ZeroDivisionError:
    print("In except block")
else:
    print("In else block")
finally:
    print("In finally block")

Output:

In try block
In else block
In finally block

Key Point to Remember:

• else executes only if no exception occurs.
• finally executes always, whether an exception occurs or not.

Summary:
When no exception occurs, Python executes blocks in this order →
try → else → finally
Hence, the correct answer is (B).

Explanation:

1. Purpose of the finally Block:
   • The finally clause is used to define cleanup code that must run no matter what happens—
     whether the code in the try block succeeds, fails, or even raises an exception.
   • It is especially useful for releasing resources (like files, database connections, or memory).
2. Execution Behavior:
   • If no exception occurs → finally executes after try (and else, if present).
   • If an exception occurs → finally executes after the except block.
   • If the program exits or returns from inside try or except → finally still executes before exiting.

Example Code 1 (No Exception):

try:
    print("In try block")
except:
    print("In except block")
finally:
    print("In finally block")

Output:

In try block
In finally block

Example Code 2 (With Exception):

try:
    print(10 / 0)
except ZeroDivisionError:
    print("Exception caught")
finally:
    print("Finally always executes")

Output:

Exception caught
Finally always executes

Key Points to Remember:

• finally block always runs (even if return, break, or continue appears in try/except).
• Used mainly for resource cleanup (closing files, freeing memory, etc.).
• It cannot appear before the try block. It must be placed after all except/else blocks.

Summary:
The finally block always executes, regardless of whether an exception occurs or not, ensuring essential cleanup tasks are completed.

Explanation:

1. When an exception occurs:
   • Python searches for a matching except block that can handle the exception.
   • If no matching except block is found, Python prepares to terminate the program by re-raising the exception.
2. Role of the finally Block:
   • Before the program terminates, Python always executes the finally block (if it exists).
   • This ensures that cleanup code (like closing files, releasing resources, etc.) runs even if the exception is unhandled.
3. Program Termination:
   • After the finally block finishes execution, Python terminates the program and displays the error traceback message indicating the unhandled exception.

Example Code:

try:
    print("In try block")
    x = 10 / 0
finally:
    print("In finally block")

Output:

In try block
In finally block
Traceback (most recent call last):
  File "example.py", line 3, in <module>
    x = 10 / 0
ZeroDivisionError: division by zero

Explanation of Output:

• The ZeroDivisionError exception occurs.
• There is no except block to handle it.
• Before terminating, Python executes the finally block (In finally block).
• After that, the program ends with a traceback showing the error.

Key Points to Remember:

• The finally block always executes, even when there’s no matching except.
• The program still terminates afterward because the exception remains unhandled.
• The exception is not ignored, and the else block never executes if an exception occurs.

Summary:
If an exception occurs and no suitable except block is found, Python executes the finally block first, then terminates the program by re-raising the exception.

Explanation:

1. try block → Mandatory
   • It contains the code that may raise exceptions.
   • You cannot have exception handling without a try block.
2. except block → Mandatory (at least one required)
   • It handles the exception raised in the try block.
   • You can have multiple except blocks for different exception types.
   • A generic except: can also be used if you want to handle all exceptions.
3. else block → Optional
   • Executes only if no exception occurs in the try block.
   • Useful for code that should run only after a successful try block.
   • Helps separate “normal logic” from “error-handling logic”.
4. finally block → Optional but recommended
   • Executes regardless of whether an exception occurs or not.
   • Commonly used for cleanup operations like closing files, releasing memory, or disconnecting from databases.

Example Code:

try:
    x = int(input("Enter a number: "))
    print(10 / x)
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print("Division successful!")
finally:
    print("Execution completed.")

Case 1: Input = 5

2.0
Division successful!
Execution completed.

Case 2: Input = 0

Cannot divide by zero!
Execution completed.

Explanation of Output:

• When no exception → try → else → finally
• When exception occurs → try → except → finally
• The else block runs only when try executes successfully without any exception.

Key Takeaways:

• else is the only optional block that executes only if no exception occurs.
• finally is optional but strongly recommended for cleanup tasks.
• try and except are mandatory; Python will raise a syntax error if they are missing.

Summary:
In Python’s try..except..else..finally structure:

• try → mandatory
• except → at least one mandatory
• else → optional
• finally → optional but commonly used

Explanation:

1. What happens when a non-numeric value is entered?
   • The statement denom = int(input("Enter the denominator: ")) tries to convert user input to an integer.
   • If the input is non-numeric (e.g., “abc”), Python cannot convert it to an integer →
     This raises a ValueError exception.
2. Is the ValueError handled in the code?
   • The code only has an except ZeroDivisionError: block.
   • Since there is no except block for ValueError, the program does not handle this exception.
3. What executes next?
   • Before the program terminates, the finally block executes.
   • This block always runs — no matter what happens (exception, no exception, or even a return statement).
   Hence, it prints: OVER AND OUT
4. What happens after the finally block?
   • After executing finally, the unhandled ValueError is re-raised automatically by Python.
   • The program then stops with a traceback (error message) because there’s no handler for that exception.

Step-by-Step Flow (when input = “abc”):

1	denom = int("abc")	Raises ValueError
2	except ZeroDivisionError	Skipped (doesn’t match)
3	else	Skipped (exception occurred)
4	finally	Executes → prints "OVER AND OUT"
5	Exception	Re-raised → Program terminates with traceback

Output on screen:

OVER AND OUT
Traceback (most recent call last):
  ...
ValueError: invalid literal for int() with base 10: 'abc'

Key Takeaways:

• The finally block always executes, regardless of whether an exception occurs or not.
• If an exception is not caught by any except block, it is re-raised after finally.
• The else block executes only if no exception occurs.
• Best practice: Always include handlers for all possible exceptions (e.g., ValueError, ZeroDivisionError) when dealing with user input.

Summary:
When a non-numeric value is entered:

• A ValueError occurs.
• No matching except block is found.
• finally executes → prints "OVER AND OUT".
• Then the unhandled exception terminates the program.

Explanation:

1. Purpose of the finally block:
   • The finally block is used to guarantee execution of important code, such as cleanup operations, regardless of whether an exception occurs.
   • It does not suppress or terminate exceptions.
2. Behavior with unhandled exceptions:
   • If an exception occurs in the try block and there is no matching except block, Python does the following:
     1. Executes the finally block first.
     2. After finally executes, the unhandled exception is automatically re-raised, causing the program to terminate with a traceback.
3. Why this matters:
   • This behavior ensures that cleanup operations (like closing files, releasing resources, etc.) always occur, even when an error is not handled.
   • Programmers can safely rely on finally to maintain program stability and resource safety.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
finally:
    print("This always executes")

# No except block

Case 1: Input = 0

Output:

This always executes
Traceback (most recent call last):
  File "example.py", line 3, in <module>
    result = 10 / 0
ZeroDivisionError: division by zero

Explanation:

• finally prints "This always executes".
• Since there is no except block, ZeroDivisionError is re-raised after finally.

Key Points:

• finally always executes, no matter what.
• Unhandled exceptions are not suppressed by finally.
• After finally, the unhandled exception is re-raised, terminating the program if not caught at a higher level.

Summary:
The finally block ensures cleanup code runs while allowing unhandled exceptions to propagate.

Explanation:

1. Try block:
   • The code inside the try block always executes first, regardless of whether an exception occurs later.
   • It is used to enclose code that may potentially raise exceptions.
2. Except block:
   • Executes only if a matching exception occurs in the try block.
   • If no exception occurs, the except block is skipped.
3. Else block:
   • Executes only if the try block completes successfully without raising any exceptions.
   • Useful for separating normal execution logic from error-handling logic.
4. Finally block:
   • Executes always, whether an exception occurs or not.
   • Commonly used for cleanup actions (like closing files or releasing resources).

Example Code:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print("Division successful:", result)
finally:
    print("Execution finished.")

Case 1: Input = 2
Output:

Division successful: 5.0
Execution finished.

Case 2: Input = 0
Output:

Cannot divide by zero!
Execution finished.

Key Points:

Block	Executes When?
try	Always first
except	Only if a matching exception occurs
else	Only if no exception occurs
finally	Always executes

Summary:

• The else block executes only when the try block succeeds without exceptions, making.

Explanation:

1. Execution Flow:
   Try Block:
   The code inside the try block is executed first.
   This block contains the statements that might raise exceptions.
   Except Block:
   If an exception occurs in the try block and matches the type specified in an except block, that except block executes.
   If no exception occurs, the except block is skipped entirely.
   Else Block:
   The else block executes only if the try block runs successfully without raising any exceptions.
   This is useful for code that should run only when no errors occur.
   Finally Block:
   The finally block executes always, regardless of whether an exception occurred or not.
   It is commonly used for cleanup tasks, like closing files, releasing resources, or other mandatory operations.
   Next Statements:
   After the finally block executes, the program continues with the statements following the try..except..else..finally construct.
   
2. Why Option B is Correct:
   • It correctly reflects conditional execution of except and else.
   • It ensures finally runs always, and the program continues with the next statements after the construct.
3. Incorrect Options:
   • (A) → Incorrect because except may not always run; else does not execute after except.
   • (C) → Incorrect order; else cannot execute before except.
   • (D) → Incorrect; finally cannot execute before except or else.

Example Code Demonstrating Flow:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print("Division successful:", result)
finally:
    print("This always executes")
print("Program continues...")

Case 1: Input = 2

Division successful: 5.0
This always executes
Program continues...

Case 2: Input = 0

Cannot divide by zero!
This always executes
Program continues...

Key Points:

• try → always first
• except → executes only if exception occurs
• else → executes only if no exception occurs
• finally → executes always
• Execution continues with the next statements after finally

Summary:

The correct flow of execution in a try..except..else..finally construct is:

Try → Except (if matched) → Else (if no exception) → Finally → Next statement

Explanation:

1. Purpose of the finally block:
   • The finally block is designed to execute always, regardless of whether an exception occurs in the try block.
   • This makes it perfect for tasks that must be performed no matter what, such as releasing resources.
2. Working with resources:
   • When a program opens a file, network connection, or database connection, it is crucial to close or release the resource after use.
   • If the program raises an exception before releasing the resource, it could lead to resource leaks or locked resources.
3. How finally helps:
   • By placing cleanup code inside finally, you guarantee that the resource is released even if an exception occurs in the try block.

Example Code:

try:
    file = open("example.txt", "r")
    data = file.read()
    print(data)
except FileNotFoundError:
    print("File not found!")
finally:
    file.close()
    print("File closed successfully")

Explanation of Output:

• If the file exists → try executes → data is printed → finally executes → file is closed.
• If the file does not exist → except executes → prints “File not found!” → finally executes → ensures file is closed.

Key Points:

• Ensures resource cleanup (files, network connections, database connections, etc.).
• Prevents resource leaks even when exceptions occur.
• Does not ignore exceptions; it simply guarantees execution of cleanup code.

Summary:
The finally block is essential for managing resources safely. It ensures that resources like files or network connections are always released, even in the presence of exceptions.

Explanation:

1. What is a Syntax Error?
   • A syntax error occurs when the code violates the rules of Python grammar.
   • Examples include missing colons, unmatched parentheses, or incorrect indentation.
2. Python’s Response:
   • When a syntax error is detected, Python immediately stops program execution.
   • It displays the error name (SyntaxError) and a brief description of the problem.
   • Execution cannot proceed until the error is corrected.
3. Key Points:
   • Syntax errors are not runtime errors; they prevent the program from starting.
   • Unlike exceptions, syntax errors cannot be caught using try..except because the program never executes beyond the point of the error.

Example Code with Syntax Error:

# Missing colon after if statement
x = 10
if x > 5
    print("x is greater than 5")

Output:

  File "example.py", line 3
    if x > 5
            ^
SyntaxError: expected ':'

• Python points out where the error occurred and gives a description (expected ':').
• The program does not run until the error is fixed.

Summary:

• Syntax errors stop program execution immediately.
• Python displays the error name and description.
• Program execution can continue only after correcting the error.

Explanation:

1. Definition of Exception

• An exception in Python is a runtime object that indicates an error occurred during program execution.
• Exceptions are not syntax errors; they occur while the program is running.

2. Examples of Exceptions

• ZeroDivisionError → dividing a number by zero
• FileNotFoundError → trying to open a file that doesn’t exist
• NameError → using an undefined variable

3. Exception Objects

• Every exception in Python is an object.
• It contains information about the type of error and an optional error message.

4. Handling Exceptions

• Python provides try..except blocks to catch and handle exceptions, preventing program crashes.
• Both built-in and user-defined exceptions can be handled.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Please enter an integer.")
else:
    print("Result:", result)

• If the user enters 0, ZeroDivisionError is caught.
• If the user enters a non-integer, ValueError is caught.
• If the user enters a valid number, the else block executes.

Summary:

• Exceptions are Python objects representing runtime errors.
• They can be built-in or user-defined.
• Using try..except ensures robust and maintainable code.

Explanation:

1. Built-in Exceptions in Python

• Python provides a large number of built-in exception classes to indicate different types of runtime errors.
• These exceptions are predefined Python objects and are automatically raised by the interpreter when an error occurs.

2. Common Examples

• SyntaxError → invalid Python syntax
• ValueError → invalid value type (e.g., int("abc"))
• ZeroDivisionError → division by zero
• IOError / FileNotFoundError → file operations fail
• KeyboardInterrupt → user interrupts program (Ctrl+C)
• ImportError → failed import of module or package
• EOFError → end-of-file reached unexpectedly
• NameError → variable not defined
• TypeError → operation on incompatible types
• IndentationError → incorrect indentation
• OverflowError → numeric overflow

3. Purpose of Built-in Exceptions

• Each exception informs the programmer about the type of error that occurred.
• They can be caught using try..except blocks, allowing the program to handle errors gracefully and continue execution.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")
except ValueError:
    print("Invalid input! Enter an integer.")

• The above program can handle multiple built-in exceptions like ValueError and ZeroDivisionError.

Summary:

• Python has many built-in exceptions for common runtime errors.
• These exceptions are objects that can be caught and handled to make programs more robust.
• All examples in options A, B, and C are valid built-in exceptions, so the correct answer is D.

Explanation:

1. Definition of Exception Handlers

• An exception handler is a block of code (inside an except clause) designed to handle specific runtime errors (exceptions).
• Exception handlers catch errors and allow the program to continue execution safely.

2. Purpose

• Prevent abrupt termination of the program.
• Provide a way to respond to errors gracefully, such as printing an error message or taking corrective action.
• Improve program robustness, reliability, and maintainability.

3. How Exception Handlers Work

• The try block contains code that may raise exceptions.
• The except block is the exception handler that executes when a matching exception occurs.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")  # Exception handler
except ValueError:
    print("Invalid input! Please enter an integer.")  # Exception handler
else:
    print("Result:", result)

• If an exception occurs (like dividing by zero or invalid input), the corresponding exception handler executes.
• The program does not crash; it continues execution after handling the error.

Summary:

• Exception handlers catch runtime errors and prevent the program from terminating unexpectedly.
• They allow graceful error handling and improve the program’s robustness.

Explanation:

1. Raising Exceptions Manually

• Python allows programmers to raise exceptions intentionally using the raise statement.
• This is useful when you want to signal an error condition in your code.

Example:

x = -5
if x < 0:
    raise ValueError("Negative value not allowed")

• Output: ValueError: Negative value not allowed
• The program stops unless this exception is handled with a try..except block.

2. Using assert Statement

• The assert statement is used to check a condition.
• If the condition is False, Python raises an AssertionError.
• This is commonly used for debugging and validating assumptions.

Example:

x = 10
assert x > 0, "x must be positive"

• If x is not greater than 0, AssertionError is raised with the provided message.

3. Effect of Raising Exceptions

• Raising an exception interrupts normal program flow.
• Control is transferred to the appropriate exception handler if one exists; otherwise, the program terminates with an error.

Summary:

• raise → manually raises any specified exception.
• assert → raises an AssertionError if a condition is false.
• Both are used to intentionally trigger exceptions for error handling or debugging purposes.

Explanation:

1. Definition of Finally Block

• The finally block is an optional part of a try..except structure.
• It contains code that must be executed no matter what, whether an exception occurs or not.

2. Purpose of Finally

• Commonly used for cleanup activities, such as:
  • Closing files
  • Releasing network or database resources
  • Releasing locks or other resources

3. Execution Flow

• try block executes first.
• If an exception occurs: the matching except block executes.
• Regardless of whether except executes or not, the finally block always executes.
• If the exception is unhandled, it is re-raised after finally executes.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")
finally:
    print("This will always execute")

• Input = 0 → except executes, then finally executes
• Input = 5 → no exception, try executes, then finally executes

Output when input = 0:

Cannot divide by zero!
This will always execute

Output when input = 5:

This will always execute

Summary:

• Finally block executes always, regardless of exceptions.
• It ensures essential cleanup tasks are performed.
• Exceptions are not suppressed; they are re-raised after finally if unhandled.

Explanation:

1. Definition of Catching an Exception

• Catching an exception means that Python detects a runtime error (exception) and then executes a corresponding except block to handle it.
• This prevents the program from terminating abruptly.

2. How It Works

• Python executes the try block.
• If no exception occurs → except block is skipped.
• If an exception occurs → Python searches for a matching except block.
• When a matching except block is found and executed, the exception is considered caught.

3. Benefits of Catching Exceptions

• Graceful error handling: The program can display an error message or take corrective action.
• Program continuity: The program does not crash and continues execution after the except block.
• Robust code: Specific errors can be handled differently for better control.

Example:

try:
    x = int(input("Enter a number: "))
    result = 10 / x
except ZeroDivisionError:
    print("Cannot divide by zero!")  # Exception caught here
except ValueError:
    print("Invalid input!")  # Exception caught here
else:
    print("Result:", result)

• Input = 0 → ZeroDivisionError occurs → caught by the first except block
• Input = abc → ValueError occurs → caught by the second except block

Summary:

• An exception is caught only when the matching except block executes.
• This allows error handling and prevents abrupt termination.