Error Handling and Exceptions

Lesson 12: Error Handling and Exceptions

Learning Objectives

By the end of this lesson, you will be able to: 1. Understand what errors and exceptions are in Python. 2. Use try, except, and finally blocks to handle exceptions gracefully. 3. Differentiate between different types of exceptions. 4. Implement custom exception handling in your programs. 5. Apply best practices for error handling in Python.

Introduction to Errors and Exceptions

In programming, errors are inevitable. They can occur due to a variety of reasons such as invalid input, resource unavailability, or even logical mistakes in the code. In Python, when an error occurs, it raises an exception. An exception is a signal that something went wrong during the execution of a program.

For instance, if you try to divide a number by zero, Python raises a ZeroDivisionError. If you try to access a file that doesn’t exist, a FileNotFoundError is raised. Instead of letting your program crash, Python allows you to handle these exceptions gracefully using error handling techniques.

Understanding Try and Except Blocks

The try and except blocks are the primary means of handling exceptions in Python. Here’s how they work:

1. Try Block: You place the code that might raise an exception inside the try block.
2. Except Block: If an exception occurs, the code inside the except block is executed.

Basic Syntax

try:
    # Code that might raise an exception
except ExceptionType:
    # Code to handle the exception

Let’s look at a simple example:

try:
    result = 10 / 0
except ZeroDivisionError:
    print("You can't divide by zero!")

In this example, the code attempts to divide 10 by 0, which raises a ZeroDivisionError. Instead of crashing the program, the except block captures the exception and prints a friendly message to the user.

Catching Multiple Exceptions

You can also handle multiple exceptions using a single except block. This can be done by specifying a tuple of exception types. Here’s how:

try:
    value = int(input("Enter a number: "))
    result = 10 / value
except (ValueError, ZeroDivisionError) as e:
    print(f"Error occurred: {e}")

In this example, if the user enters a non-integer value, a ValueError is raised. If the user enters zero, a ZeroDivisionError occurs. Both exceptions are handled in the same except block.

The Finally Block

The finally block can be used to execute code regardless of whether an exception occurred or not. It is often used for cleanup actions, such as closing files or releasing resources. Here’s the syntax:

try:
    # Code that might raise an exception
except ExceptionType:
    # Code to handle the exception
finally:
    # Code that will run no matter what

Example of Finally Block

try:
    file = open('example.txt', 'r')
    content = file.read()
except FileNotFoundError:
    print("File not found.")
finally:
    if 'file' in locals():
        file.close()

In this example, if the file example.txt does not exist, a FileNotFoundError is raised, but the finally block ensures that the file is closed if it was opened successfully.

Raising Exceptions

You can also raise exceptions manually in your code using the raise statement. This is useful when you want to enforce certain conditions in your application. Here’s how:

age = -1
if age < 0:
    raise ValueError("Age cannot be negative.")

In this example, if the age is less than zero, a ValueError is raised with a custom message. This allows you to provide meaningful feedback to the user or calling code.

Creating Custom Exceptions

Sometimes, you may want to create your own exception classes to handle specific errors in your application. This is done by subclassing the built-in Exception class. Here’s an example:

class NegativeAgeError(Exception):
    pass

age = -1
if age < 0:
    raise NegativeAgeError("Age cannot be negative.")

In this example, we define a custom exception called NegativeAgeError. When the age is negative, we raise this custom exception instead of a built-in one.

Common Mistakes and How to Avoid Them

1. Ignoring Exceptions: Failing to handle exceptions can lead to crashes. Always use try and except blocks to catch exceptions.
2. Overly Broad Exception Handling: Catching all exceptions with a bare except: can mask bugs. Always specify the exception type you want to handle.
3. Not Using Finally: Forgetting to use finally can lead to resource leaks. Always clean up resources such as files or network connections in the finally block.

Best Practices for Error Handling

• Be Specific: Catch specific exceptions rather than general ones to avoid hiding bugs.
• Log Errors: Use logging to record exceptions. This helps in debugging issues later.
• Provide User-Friendly Messages: When handling exceptions, provide clear messages to the user to help them understand what went wrong.
• Test Exception Handling: Write tests for your exception handling code to ensure it behaves as expected.

Key Takeaways

• Exceptions are errors that occur during program execution.
• Use try and except blocks to handle exceptions gracefully.
• The finally block can be used for cleanup actions.
• You can raise exceptions manually and create custom exceptions.
• Follow best practices to ensure robust error handling in your applications.

Conclusion

In this lesson, you learned how to handle errors and exceptions in Python using try, except, and finally blocks. You also explored raising exceptions and creating custom exception classes. Mastering error handling is crucial for building robust applications that can handle unexpected situations gracefully.

In the next lesson, we will explore Modules and Packages, which will allow you to organize your code better and reuse it across different projects. Get ready to delve into the world of modular programming in Python!

• Exercise 1: Write a program that asks the user for two numbers and divides them. Handle the potential ZeroDivisionError and ValueError exceptions with appropriate messages.
• Exercise 2: Create a function that takes a file name as an argument and attempts to read from it. Handle the FileNotFoundError exception and return a custom error message if the file does not exist.
• Exercise 3: Implement a custom exception called InvalidInputError. Raise this exception when the user inputs a negative number. Write a program that asks for user input and raises the exception if the input is invalid.
• Exercise 4: Write a program that reads integers from a list and calculates their average. Handle any exceptions that might arise from invalid data types in the list.
• Practical Assignment: Create a small calculator application that supports addition, subtraction, multiplication, and division. Implement error handling for invalid inputs and division by zero. Ensure the program runs continuously until the user decides to exit.

• Exceptions are errors that occur during program execution and can be handled using try and except blocks.
• The finally block ensures that code runs regardless of whether an exception occurred.
• You can raise exceptions manually and create custom exceptions for specific error handling.
• Always catch specific exceptions and provide clear user messages.
• Following best practices in error handling leads to more robust and maintainable code.