Built-in Error Types and Exceptions

Error handling is a crucial aspect of programming in Python. It allows developers to gracefully manage and respond to unexpected events or errors that may occur during the execution of their code. Python has a built-in set of error types and exceptions that can be used to handle various types of errors. In this section, we will explore the different types of built-in error types and exceptions in Python.

Introduction to Error Handling

Error handling in Python is achieved using the try, except, and finally statements. The try block contains the code that may potentially raise an error, the except block contains the code that will be executed if an error occurs, and the finally block contains the code that will be executed regardless of whether an error occurred or not.

try:
    # Code that may potentially raise an error
    x = 1 / 0
except ZeroDivisionError:
    # Code that will be executed if a ZeroDivisionError occurs
    print("Cannot divide by zero!")
finally:
    # Code that will be executed regardless of whether an error occurred or not
    print("Execution complete")

Built-in Error Types

Python has a number of built-in error types that can be used to handle various types of errors. Some of the most common built-in error types include:

• SyntaxError: Raised when there is an error in the syntax of the code.
• TypeError: Raised when a variable or value is not of the expected type.
• ValueError: Raised when a function or operation receives an argument with an incorrect value.
• ZeroDivisionError: Raised when the divisor in a division operation is zero.
• IndexError: Raised when a sequence (such as a list or tuple) is indexed out of range.
• KeyError: Raised when a mapping (such as a dictionary) is indexed with a key that does not exist.

# Example of a TypeError
try:
    x = "hello" + 1
except TypeError:
    print("Cannot concatenate string and integer")
 
# Example of a ValueError
try:
    int("hello")
except ValueError:
    print("Invalid literal for int")
 
# Example of a ZeroDivisionError
try:
    x = 1 / 0
except ZeroDivisionError:
    print("Cannot divide by zero!")
 
# Example of an IndexError
try:
    my_list = [1, 2, 3]
    print(my_list[3])
except IndexError:
    print("Index out of range")
 
# Example of a KeyError
try:
    my_dict = {"name": "John", "age": 30}
    print(my_dict["city"])
except KeyError:
    print("Key not found")

Raising Custom Exceptions

In addition to the built-in error types, Python also allows developers to raise custom exceptions using the raise statement. This can be useful for creating custom error messages or for handling specific error conditions.

# Example of raising a custom exception
class InsufficientBalanceError(Exception):
    pass
 
class BankAccount:
    def __init__(self, balance):
        self.balance = balance
 
    def withdraw(self, amount):
        if amount > self.balance:
            raise InsufficientBalanceError("Insufficient balance")
        self.balance -= amount
 
try:
    account = BankAccount(100)
    account.withdraw(200)
except InsufficientBalanceError as e:
    print(e)

Best Practices for Error Handling

Here are some best practices for error handling in Python:

• Always use specific exception types instead of catching the general Exception class.
• Keep the code in the try block as short as possible to avoid catching unrelated exceptions.
• Use the as keyword to assign the exception object to a variable, allowing you to access its attributes and methods.
• Avoid using the finally block to release resources, instead use the with statement or a context manager.
• Log or report errors to track and diagnose issues.

# Example of logging an error
import logging
 
try:
    x = 1 / 0
except ZeroDivisionError as e:
    logging.error("Error occurred", exc_info=True)

Real-World Examples

Error handling is a critical aspect of real-world applications. Here are a few examples:

• A web application may use error handling to handle invalid user input, such as an invalid email address or password.
• A file processing application may use error handling to handle file not found or permission errors.
• A network application may use error handling to handle connection timeouts or refused connections.

# Example of error handling in a web application
from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
@app.route("/login", methods=["POST"])
def login():
    try:
        username = request.json["username"]
        password = request.json["password"]
        # Authenticate user
        if username == "admin" and password == "password":
            return jsonify({"message": "Login successful"})
        else:
            raise ValueError("Invalid username or password")
    except ValueError as e:
        return jsonify({"message": str(e)}), 401
 
if __name__ == "__main__":
    app.run(debug=True)

In conclusion, error handling is a crucial aspect of programming in Python. By using the built-in error types and exceptions, raising custom exceptions, and following best practices, developers can create robust and reliable applications that handle errors gracefully.