Python Built-in Exceptions (With Examples)

Python, being a versatile and widely used programming language, offers a rich set of built-in exceptions to help developers handle errors and exceptions effectively. These exceptions provide valuable information about the nature of errors that occur during the execution of a program, making debugging and error handling more efficient. In this tutorial, we will delve into the world of Python’s built-in exceptions, exploring their types and providing comprehensive examples to illustrate their usage.

Table of Contents

1. Introduction to Exceptions
2. Common Built-in Exceptions
   • SyntaxError
   • NameError
   • TypeError
   • ValueError
   • ZeroDivisionError
3. Advanced Built-in Exceptions
   • FileNotFoundError
   • KeyError
   • IndexError
   • AssertionError
4. Creating Custom Exceptions
5. Handling Exceptions
   • Using try and except
   • Handling Multiple Exceptions
   • else and finally Clauses
6. Conclusion

1. Introduction to Exceptions

In Python, an exception is a runtime error that disrupts the normal flow of a program. These errors can occur for various reasons, such as invalid input, unexpected behavior, or incorrect logic. When an exception occurs, it generates an exception object that contains information about the error, including the type of exception, a description, and sometimes additional data that can help identify the root cause.

Handling exceptions is crucial for writing robust and reliable code. Python provides a variety of built-in exception classes to capture and manage different types of errors. By understanding these exceptions and their use cases, developers can create more resilient programs that gracefully handle unexpected situations.

2. Common Built-in Exceptions

SyntaxError

The SyntaxError exception is raised when the interpreter encounters invalid syntax in the code. This usually happens when a programmer makes a mistake while writing the code and violates the language’s syntax rules.

Example:

# This code will raise a SyntaxError
if x > 10
    print("x is greater than 10")

In this example, the missing colon at the end of the if statement will trigger a SyntaxError.

NameError

The NameError exception occurs when a variable or name is used before it is defined. This can happen when trying to access a variable that is out of scope or has not been declared yet.

Example:

def print_message():
    print(msg)

print_message()

Here, the variable msg is not defined within the function’s scope, leading to a NameError.

TypeError

The TypeError exception is raised when an operation or function is applied to an object of inappropriate type. This typically occurs when incompatible data types are used together.

Example:

length = len(42)

In this example, trying to get the length of an integer (42) will raise a TypeError because the len() function expects a sequence (e.g., string, list) as input.

ValueError

The ValueError exception is raised when a function receives an argument of the correct data type but with an inappropriate value. This can occur when a function expects a certain range of values but receives something outside that range.

Example:

age = int(input("Enter your age: "))
if age < 0 or age > 120:
    raise ValueError("Invalid age entered")

If the user enters an age that is negative or greater than 120, a ValueError is raised with a custom error message.

ZeroDivisionError

The ZeroDivisionError exception is raised when attempting to divide by zero.

Example:

result = 10 / 0

In this case, dividing by zero will result in a ZeroDivisionError.

3. Advanced Built-in Exceptions

FileNotFoundError

The FileNotFoundError exception is raised when an attempt is made to open a file that does not exist.

Example:

try:
    with open("nonexistent_file.txt", "r") as file:
        content = file.read()
except FileNotFoundError:
    print("The file does not exist.")

In this example, the code inside the try block will raise a FileNotFoundError since the file “nonexistent_file.txt” does not exist.

KeyError

The KeyError exception is raised when trying to access a dictionary key that doesn’t exist.

Example:

my_dict = {"name": "Alice", "age": 30}
print(my_dict["city"])

Here, attempting to access the key “city” in the dictionary will raise a KeyError.

IndexError

The IndexError exception is raised when trying to access an index that is out of range in a sequence (e.g., list, string).

Example:

my_list = [1, 2, 3]
print(my_list[5])

In this case, accessing an index that is not present in the list will result in an IndexError.

AssertionError

The AssertionError exception is raised when an assert statement fails. The assert statement is used to check whether a given condition is True or not. If the condition is False, the AssertionError is raised.

Example:

x = 10
assert x > 20, "x should be greater than 20"

Here, the assertion will fail since the condition x > 20 is not satisfied, leading to an AssertionError with the specified error message.

4. Creating Custom Exceptions

While Python provides a rich set of built-in exceptions, there are cases where you might need to define your own custom exceptions to handle specific scenarios.

Example:

class InsufficientFundsError(Exception):
    def __init__(self, balance, amount):
        self.balance = balance
        self.amount = amount
        self.message = f"Insufficient funds. Current balance: {balance}, Required: {amount}"

try:
    balance = 100
    withdraw_amount = 150
    if withdraw_amount > balance:
        raise InsufficientFundsError(balance, withdraw_amount)
except InsufficientFundsError as e:
    print(e.message)

In this example, we define a custom exception class InsufficientFundsError that takes the current balance and the required withdrawal amount as arguments. If the withdrawal amount exceeds the balance, an instance of this exception is raised.

5. Handling Exceptions

Using try and except

To handle exceptions gracefully, Python provides the try and except blocks. The code within the try block is monitored for exceptions, and if an exception occurs, the code within the corresponding except block is executed.

Example:

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

In this example, the try block attempts to divide by zero, which raises a ZeroDivisionError. The code within the corresponding except block is then executed, printing an error message.

Handling Multiple Exceptions

You

can handle multiple exceptions by using multiple except blocks.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Invalid input. Please enter a valid number.")
except ZeroDivisionError:
    print("Division by zero is not allowed.")

In this case, both ValueError (for non-integer input) and ZeroDivisionError are caught separately.

else and finally Clauses

The else block is executed when no exceptions are raised in the try block.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ValueError:
    print("Invalid input. Please enter a valid number.")
except ZeroDivisionError:
    print("Division by zero is not allowed.")
else:
    print("Division successful. Result:", result)

The finally block is always executed, regardless of whether an exception occurred or not.

Example:

try:
    num = int(input("Enter a number: "))
    result = 10 / num
except ZeroDivisionError:
    print("Division by zero is not allowed.")
finally:
    print("Execution completed.")

6. Conclusion

Understanding Python’s built-in exceptions is essential for writing robust and reliable code. By recognizing the various types of exceptions and their use cases, developers can create programs that handle errors gracefully and provide meaningful feedback to users. Remember that exceptions are powerful tools for improving the stability and maintainability of your Python applications, so make sure to incorporate them into your coding practices.