The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Handling Exceptions

Next ►
►

In this section, we will delve into handling exceptions in Python. Exception handling is a crucial aspect of writing robust and error-resistant code. By the end of this section, you will understand how to manage errors gracefully, ensuring your programs can handle unexpected situations without crashing.

Key Concepts

  1. Exception Handling Basics
  2. The try and except Blocks
  3. Catching Multiple Exceptions
  4. The else and finally Clauses
  5. Best Practices for Exception Handling

  1. Exception Handling Basics

Exceptions are errors detected during execution. When an error occurs, Python raises an exception. If not handled, the program will terminate. Common exceptions include ZeroDivisionError, TypeError, and ValueError.

  1. The try and except Blocks

The try block lets you test a block of code for errors. The except block lets you handle the error.

Syntax

try:
    # Code that might cause an exception
    risky_code()
except ExceptionType:
    # Code that runs if an exception occurs
    handle_exception()

Example

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

Explanation:

  • The try block contains code that might throw an exception.
  • The except block catches the ZeroDivisionError and handles it by printing a message.

  1. Catching Multiple Exceptions

You can catch multiple exceptions by specifying multiple except blocks or using a tuple.

Example with Multiple except Blocks

try:
    result = int("abc")
except ValueError:
    print("ValueError: Invalid literal for int()")
except TypeError:
    print("TypeError: Invalid operation")

Example with a Tuple

try:
    result = int("abc")
except (ValueError, TypeError) as e:
    print(f"An error occurred: {e}")

Explanation:

  • The first example uses separate except blocks for ValueError and TypeError.
  • The second example uses a tuple to catch both exceptions in a single block.

  1. The else and finally Clauses

  • else Clause: Runs if no exceptions are raised.
  • finally Clause: Runs regardless of whether an exception was raised or not.

Example

try:
    result = 10 / 2
except ZeroDivisionError:
    print("Cannot divide by zero!")
else:
    print(f"Result is {result}")
finally:
    print("Execution completed.")

Explanation:

  • The else block runs if no exceptions occur.
  • The finally block always runs, useful for cleanup actions like closing files.

  1. Best Practices for Exception Handling

  • Be Specific: Catch specific exceptions rather than using a generic except block.
  • Avoid Silent Failures: Always handle exceptions in a way that informs the user or logs the error.
  • Use finally for Cleanup: Ensure resources are released properly by using the finally block.

Practical Exercises

Exercise 1: Handling Division by Zero

Task: Write a function that takes two numbers and returns their division. Handle the ZeroDivisionError exception.

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        return "Cannot divide by zero!"

# Test the function
print(safe_divide(10, 2))  # Should print 5.0
print(safe_divide(10, 0))  # Should print "Cannot divide by zero!"

Exercise 2: Handling Multiple Exceptions

Task: Write a function that converts a string to an integer and handles both ValueError and TypeError.

def convert_to_int(value):
    try:
        return int(value)
    except (ValueError, TypeError) as e:
        return f"Error: {e}"

# Test the function
print(convert_to_int("123"))  # Should print 123
print(convert_to_int("abc"))  # Should print an error message
print(convert_to_int(None))   # Should print an error message

Conclusion

In this section, we covered the basics of handling exceptions in Python. You learned how to use try and except blocks, handle multiple exceptions, and utilize the else and finally clauses. By following best practices, you can write more robust and error-resistant code. In the next section, we will explore raising exceptions, allowing you to create custom error conditions in your programs.

◄ Previous
◄
Next ►
►

Python Programming Course

Module 1: Introduction to Python

Module 2: Control Structures

Module 3: Functions and Modules

Module 4: Data Structures

Module 5: Object-Oriented Programming

Module 6: File Handling

Module 7: Error Handling and Exceptions

Module 8: Advanced Topics

Module 9: Testing and Debugging

Module 10: Web Development with Python

Module 11: Data Science with Python

Module 12: Final Project

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved