Exception Handling in Python Class 12 Notes and Solutions

Exception Handling in Python: Class 12 Notes

Introduction

Exception handling is a crucial aspect of Python programming, enabling developers to manage and resolve errors that occur during the execution of a program. It ensures that the code runs smoothly, even when unexpected conditions arise, thereby preventing abrupt terminations and maintaining user experience.

Syntax Errors

Syntax errors, also known as parsing errors, occur when the rules of the programming language are not followed. These errors are detected by the Python interpreter during the parsing phase and must be rectified before the program can be executed. For instance:

if marks > 20:
    print "GOOD SCORE"

Fixed Syntax

if marks > 20:
    print("GOOD SCORE")

Here, the first snippet will cause a syntax error due to the missing parentheses in the print function.

Exceptions

Unlike syntax errors, exceptions occur during the actual execution of the program. They are runtime errors that can disrupt the normal flow of the program. Common examples include opening a non-existent file or division by zero. These errors need to be handled to prevent abnormal program termination.

Built-in Exceptions

Python's standard library comes with a collection of built-in exceptions that cover common errors. Some of these include:

Raising Exceptions

Python allows programmers to raise exceptions intentionally using the raise statement. This is useful for testing error-handling routines or when a specific condition must be met for the program to proceed.

raise Exception("This is a raised exception")

Handling Exceptions

Try and Except Blocks

The primary way to handle exceptions in Python is using try and except blocks. The code that might throw an exception is placed inside the try block, and the corresponding handling code is in the except block.

try:
    numerator = 10
    denominator = 0
    result = numerator / denominator
except ZeroDivisionError:
    print("Division by zero is not allowed")

The Finally Clause

The finally block contains code that will execute regardless of whether an exception was raised or not. This is commonly used for cleanup actions, such as closing files or releasing resources.

try:
    file = open("test.txt", "r")
except FileNotFoundError:
    print("File not found")
finally:
    file.close()
    print("File has been closed")

The Assert Statement

The assert statement is used to test, if a condition in the code returns True, otherwise it raises an AssertionError. It's a convenient way to insert debugging assertions into a program.

def check_age(age):
    assert age >= 0, "Age cannot be negative"
    return age
print(check_age(25))

The Process of Handling Exceptions

When an error occurs, Python creates an exception object. This object is then handled by the runtime system, which looks for a matching except block to catch and handle the error.

User-defined Exceptions

Python also allows the creation of custom exceptions tailored to specific needs using class definitions.

class CustomError(Exception):
    pass

try:
    raise CustomError("This is a custom error")
except CustomError as e:
    print(e)

Best Practices for Exception Handling

1. Catch Specific Exceptions: Avoid using a bare except clause; instead, catch specific exceptions to prevent catching unexpected errors.

2. Use Finally for Cleanup: Ensure resources are released whether an error occurs or not by using the finally block.

3. Document Your Code: Clearly document why and how exceptions are being handled for better code maintainability.

Conclusion

Understanding and implementing exception handling is essential for writing robust and error-free Python programs. By learning these techniques, you can ensure your programs are well-prepared to handle unexpected situations gracefully.