Exception Handling in Python — NCERT Solutions

Given concept: Relationship between syntax errors and exceptions in Python.

Justification:

Part 1 — Every syntax error is an exception:
In Python, syntax errors are treated as a special type of exception called SyntaxError. When the Python interpreter encounters code that violates the grammatical rules of the language (e.g., missing colon, incorrect indentation), it raises a SyntaxError exception. Thus, every syntax error is indeed an exception.

Example:

if x = 5:   # SyntaxError: invalid syntax
    print(x)

Here Python raises: SyntaxError: invalid syntax

Part 2 — Every exception cannot be a syntax error:
Exceptions are a much broader category. Many exceptions occur at runtime (during execution) even when the code is syntactically correct. These are called runtime exceptions or logical exceptions and have nothing to do with syntax rules.

Examples:

• ZeroDivisionError — occurs when a number is divided by zero (syntax is correct).
• ValueError — occurs when a function receives an argument of the correct type but inappropriate value.
• NameError — occurs when a variable is used before being defined.

a = 10
b = 0
print(a / b)   # ZeroDivisionError — syntax is perfectly correct

Conclusion: Since syntax errors form only a subset of all possible exceptions, every syntax error is an exception, but every exception cannot be a syntax error. Hence the statement is justified.

a) ImportError

When raised: ImportError is raised when the import statement fails to find the module being imported, or when a name cannot be imported from a module.

Example:

import mathematics   # No such module exists

Output:

ModuleNotFoundError: No module named 'mathematics'

(Note: ModuleNotFoundError is a subclass of ImportError.)

Another example:

from math import squareroot   # 'squareroot' does not exist in math

Output:

ImportError: cannot import name 'squareroot' from 'math'

b) IOError

When raised: IOError (also known as OSError in Python 3) is raised when an input/output operation fails. Common causes include trying to open a file that does not exist, or lacking permission to read/write a file.

Example:

f = open("nonexistent_file.txt", "r")   # File does not exist

Output:

FileNotFoundError: [Errno 2] No such file or directory: 'nonexistent_file.txt'

(Note: FileNotFoundError is a subclass of IOError/OSError.)

c) NameError

When raised: NameError is raised when a local or global variable (name) is referenced but has not been defined or assigned any value.

Example:

print(total)   # 'total' has not been defined anywhere

Output:

NameError: name 'total' is not defined

d) ZeroDivisionError

When raised: ZeroDivisionError is raised when the second operand (divisor/denominator) in a division or modulo operation is zero.

Example:

a = 10
b = 0
result = a / b   # Division by zero
print(result)

Output:

ZeroDivisionError: division by zero

Use of raise statement:
The raise statement is used to explicitly raise (throw) an exception in a program. It allows the programmer to force a specific exception to occur when a certain condition is met, even if Python would not raise it automatically. It is useful for enforcing constraints and validating inputs.

Syntax:

raise ExceptionType("message")

Code:

try:
    num1 = int(input("Enter the first number (numerator): "))
    num2 = int(input("Enter the second number (denominator): "))
    if num2 == 0:
        raise ZeroDivisionError("Denominator cannot be zero!")
    quotient = num1 / num2
    print("Quotient =", quotient)
except ZeroDivisionError as e:
    print("Error:", e)
except ValueError:
    print("Please enter valid integer numbers only.")

Sample Output 1 (valid input):

Enter the first number (numerator): 10
Enter the second number (denominator): 2
Quotient = 5.0

Sample Output 2 (denominator = 0):

Enter the first number (numerator): 10
Enter the second number (denominator): 0
Error: Denominator cannot be zero!

Explanation:

• If num2 is 0, the raise statement explicitly raises a ZeroDivisionError with a custom message.
• The except block catches this exception and displays the error message without crashing the program.

Concept: The assert statement is used to test a condition. If the condition is True, execution continues normally. If the condition is False, Python raises an AssertionError with an optional message.

Syntax:

assert condition, "Error message"

Code using assert:

try:
    num1 = int(input("Enter the first number (numerator): "))
    num2 = int(input("Enter the second number (denominator): "))
    assert num2 != 0, "Denominator cannot be zero!"
    quotient = num1 / num2
    print("Quotient =", quotient)
except AssertionError as e:
    print("AssertionError:", e)
except ValueError:
    print("Please enter valid integer numbers only.")

Sample Output 1 (valid input):

Enter the first number (numerator): 15
Enter the second number (denominator): 3
Quotient = 5.0

Sample Output 2 (denominator = 0):

Enter the first number (numerator): 15
Enter the second number (denominator): 0
AssertionError: Denominator cannot be zero!

Explanation:

• assert num2 != 0 checks that the denominator is not zero.
• If num2 == 0, the assertion fails and Python raises AssertionError with the message "Denominator cannot be zero!".
• The except AssertionError block catches and displays this error gracefully.

a) Exception Handling:

Exception handling is the process of writing additional code in a program to deal with runtime errors (exceptions) gracefully, so that the program does not terminate abruptly. It involves:

• Detecting the occurrence of an error.
• Transferring control to a special block of code called the exception handler.
• Displaying meaningful messages to the user and allowing the program to continue or terminate cleanly.

In Python, exception handling is implemented using try, except, else, and finally blocks.

b) Throwing an Exception:

When an error occurs during the execution of a program, the Python interpreter creates an exception object containing information about the error (its type, file name, and position in the program). The process of creating this exception object and handing it over to the runtime system is called throwing (or raising) an exception.

This can happen:

• Automatically — when Python detects a runtime error (e.g., division by zero).
• Explicitly — when the programmer uses the raise or assert statement.

c) Catching an Exception:

An exception is said to be caught when the code specifically designed to handle that particular exception (the exception handler) is executed. In Python, exceptions are caught inside the except block that follows the try block. When the runtime system finds a matching except handler in the call stack, it executes that handler — this process is called catching the exception.

Example:

try:
    x = 10 / 0          # Exception is thrown here
except ZeroDivisionError:  # Exception is caught here
    print("Cannot divide by zero")