NCERT Solutions Class 12 Computer Science Chapter 1 Exception Handling

A syntax error is an error Python finds while it reads (parses) your code, before the program runs, when the code breaks the grammar rules, like a missing colon. An exception is an error that occurs while a syntactically correct program is running. In Python's error class tree, every error type, including SyntaxError, is a class, with BaseException at the top and Exception below it. SyntaxError sits under Exception.

• First half (true). SyntaxError is a subclass of Exception, so raising a syntax error creates an exception object. Hence a syntax error is also an exception.
• Second half (true). Many exceptions have nothing to do with grammar; they appear only when a correct program runs and hits a bad situation, like dividing by zero or using an undefined name.

A syntax error stops parsing, so Python refuses to run the file at all:

if x > 5      # missing colon, breaks grammar
    print(x)

SyntaxError: expected ':'

A run-time exception, by contrast, happens in grammatically correct code:

a = 10
b = 0
print(a / b)

ZeroDivisionError: division by zero

The ZeroDivisionError is an exception but clearly not a syntax error, which proves the second half.

Answer: A syntax error is a special case of an exception (a subclass of Exception), so every syntax error is an exception. But most exceptions, such as ZeroDivisionError, arise at run time in correct code and are not syntax errors. Hence every exception cannot be a syntax error.

A built-in exception is an error class Python already provides and raises automatically when a specific bad situation happens at run time. Each class name describes the kind of problem.

a) ImportError. Raised when an import fails to find the module, or to find a name inside it.

import mymodule        # no such module exists

ModuleNotFoundError: No module named 'mymodule'

Since Python 3.6 a missing module raises ModuleNotFoundError, a subclass of ImportError; from math import sqart still raises a plain ImportError.

b) IOError. Raised when an input or output operation fails, most commonly opening a file that does not exist.

f = open("data.txt", "r")   # file is not present

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

In current Python, IOError is an alias of OSError, and a missing file is FileNotFoundError, a subclass of OSError.

c) NameError. Raised when the program uses a name that has not been defined.

print(marks + 10)      # 'marks' was never assigned

NameError: name 'marks' is not defined

d) ZeroDivisionError. Raised when a number is divided, or a remainder taken, with zero as the divisor.

result = 25 / 0

ZeroDivisionError: division by zero

Answer: ImportError: module or name cannot be imported. IOError: an I/O action such as opening a file fails. NameError: an undefined name is used. ZeroDivisionError: a number is divided by zero.

The raise statement lets the programmer signal an error on purpose. With raise you can force a chosen exception when your own condition is broken, for example when a denominator is zero. The form is raise ExceptionName("message"). Once raised, control jumps to the nearest matching except block. The quotient is the result of num1 / num2.

try:
    num1 = int(input("Enter the numerator: "))
    num2 = int(input("Enter the denominator: "))
    if num2 == 0:
        raise ZeroDivisionError("Denominator cannot be zero")
    quotient = num1 / num2
    print("Quotient =", quotient)
except ZeroDivisionError as e:
    print("Error:", e)

Enter the numerator: 20
Enter the denominator: 0
Error: Denominator cannot be zero

Enter the numerator: 20
Enter the denominator: 4
Quotient = 5.0

Writing except ZeroDivisionError as e stores the exception object in e, so print(e) shows the exact message you passed to raise.

Answer: The raise statement throws an exception by choice. The program raises ZeroDivisionError("Denominator cannot be zero") when num2 == 0, and the except block prints the message instead of crashing. For valid input it prints the quotient, for example 20 / 4 = 5.0.

The assert statement checks that a condition is true. Its form is assert condition, message. If the condition is true, the program continues silently. If it is false, Python raises an AssertionError and shows the message. We use it to make sure num2 is not zero before the division.

try:
    num1 = int(input("Enter the numerator: "))
    num2 = int(input("Enter the denominator: "))
    assert num2 != 0, "Denominator cannot be zero"
    quotient = num1 / num2
    print("Quotient =", quotient)
except AssertionError as e:
    print("Assertion failed:", e)

Enter the numerator: 36
Enter the denominator: 0
Assertion failed: Denominator cannot be zero

Enter the numerator: 36
Enter the denominator: 6
Quotient = 6.0

assert num2 != 0, "msg" is a short way of writing if not (num2 != 0): raise AssertionError("msg"). Both do the same job.

Answer: Adding assert num2 != 0, "Denominator cannot be zero" before the division tests the expression. A zero denominator raises AssertionError, which the except block reports; valid input prints the quotient, for example 36 / 6 = 6.0.

These three terms describe the whole flow of dealing with run-time errors in Python. An exception is an error that happens while a program runs; the terms below name the parts of how a program reacts so that it does not stop abruptly.

• a) Exception Handling. The process of responding to run-time errors in a controlled way so the program does not crash. The program detects the error, runs special code to deal with it, and, if possible, continues. In Python this uses the try, except, else and finally blocks.
• b) Throwing an exception. Throwing (also called raising) means signalling that an error has occurred. The current block stops, an exception object is created and passed on, looking for code that can deal with it. Python throws automatically, and a programmer can throw on purpose with raise.
• c) Catching an exception. Receiving an exception that was thrown and running code to handle it, done with an except block that names the exception type. When a matching exception is thrown, control moves into that block.

try:
    raise ValueError("bad value")   # throwing
except ValueError as e:             # catching
    print("Caught:", e)             # handling

Caught: bad value

"Throwing" is the sender side (an error goes out); "catching" is the receiver side (an error is taken in); "exception handling" is the name for the whole cycle.

Answer: Exception handling is the controlled response to run-time errors. Throwing (raising) an exception is signalling that an error has occurred. Catching an exception is receiving that error in an except block and running code to deal with it.

The try-except block is Python's main tool for catching exceptions. Code that might fail goes inside try. If an exception is raised there, Python stops the rest of the try block and looks for an except block whose named exception matches. If it matches, that block runs and the program continues. If no exception is raised, the except block is skipped.

• Python runs the statements inside try one by one.
• The moment a statement raises an exception, Python leaves the try block at that point.
• Python checks each except clause in order; the first whose type matches is run.
• After the chosen except block finishes, the program carries on after the whole try-except. If no except matches, the exception is passed up and may crash the program.

try:
    a = int(input("Enter a number: "))
    b = int(input("Enter another number: "))
    print("Result =", a / b)
except ValueError:
    print("Please enter only whole numbers")
except ZeroDivisionError:
    print("The second number must not be zero")

Enter a number: 12
Enter another number: 0
The second number must not be zero

Enter a number: hello
Please enter only whole numbers

Answer: Risky code goes in try. If it raises an exception, Python jumps to the first matching except block, runs the handling code, and then continues. If nothing fails, the except blocks are skipped. You can have several except blocks for different exception types.

Each blank is decided by what the comment beside it describes. ValueError is raised when int() is given text that is not a whole number, so it covers "to enter only integers". ZeroDivisionError is raised when num1 / num2 divides by zero, so it covers "denominator should not be zero". The finally clause holds code that always runs at the end.

• Blank 1 is the exception for non-integer input. If the user types letters, int(input(...)) raises ValueError. So Blank 1 is ValueError.
• Blank 2 is the exception for a zero denominator. num1 / num2 with num2 == 0 raises ZeroDivisionError. So Blank 2 is ZeroDivisionError.
• Blank 3 must run at the end no matter what. That is the job of finally. So Blank 3 is finally.

print(" Learning Exceptions...")
try:
    num1 = int(input("Enter the first number"))
    num2 = int(input("Enter the second number"))
    quotient = (num1 / num2)
    print("Both the numbers entered were correct")
except ValueError:           # to enter only integers
    print(" Please enter only numbers")
except ZeroDivisionError:    # Denominator should not be zero
    print(" Number 2 should not be zero")
else:
    print(" Great .. you are a good programmer")
finally:                     # to be executed at the end
    print(" JOB OVER... GO GET SOME REST")

 Learning Exceptions...
Both the numbers entered were correct
 Great .. you are a good programmer
 JOB OVER... GO GET SOME REST

 Learning Exceptions...
 Number 2 should not be zero
 JOB OVER... GO GET SOME REST

The else block runs only when the try block raises no exception. On a zero denominator the else line is skipped, but finally still runs.

Answer: Blank 1 = ValueError, Blank 2 = ZeroDivisionError, Blank 3 = finally. With valid input all four lines after try print; with a zero denominator only the ZeroDivisionError message and the finally message print.

The math module gives ready-made functions like math.sqrt(x) (square root) and math.pow(x, y) (x raised to power y). A ValueError is raised when a function gets an argument of the right type but an unacceptable value. For math.sqrt, a negative number is outside the function's allowed range (its domain), so it raises ValueError: math domain error. We catch it with a try-except block.

import math

try:
    num = -25
    print("Square root =", math.sqrt(num))
except ValueError:
    print("ValueError: cannot take square root of a negative number")

ValueError: cannot take square root of a negative number

A wrong value (a negative number) gives ValueError. A wrong type (text instead of a number, like math.sqrt("9")) would give TypeError. The question asks to catch ValueError, so feed a value that is out of range.

Answer: Calling math.sqrt(-25) raises ValueError: math domain error because a negative number is outside the function's allowed range. The try-except block catches the ValueError and prints a clear message instead of crashing.

The finally clause is an optional block attached to a try statement. The code inside finally always runs, whether or not an exception was raised, and whether or not it was caught. It is used for clean-up work that must happen in every case, such as closing a file or printing a final message. (Question 7 already includes a finally clause; here we explain its role.)

• Python runs the try block first.
• If an exception is raised, the matching except block runs; if none is raised, the else block runs.
• No matter which happened, Python runs the finally block last, just before leaving the try statement. So the "JOB OVER" message prints in every situation.

print(" Learning Exceptions...")
try:
    num1 = int(input("Enter the first number"))
    num2 = int(input("Enter the second number"))
    quotient = (num1 / num2)
    print("Both the numbers entered were correct")
except ValueError:
    print(" Please enter only numbers")
except ZeroDivisionError:
    print(" Number 2 should not be zero")
else:
    print(" Great .. you are a good programmer")
finally:
    print(" JOB OVER... GO GET SOME REST")

 Learning Exceptions...
Both the numbers entered were correct
 Great .. you are a good programmer
 JOB OVER... GO GET SOME REST

 Learning Exceptions...
 Number 2 should not be zero
 JOB OVER... GO GET SOME REST

Use finally for resource clean-up. If you open a file in try, close it in finally so it is closed even when the read fails.

Answer: The finally clause holds code that always runs after the try statement, regardless of whether an exception was raised or caught. In the Question 7 program, finally prints "JOB OVER... GO GET SOME REST" in every case, valid input or zero denominator alike.