From basic to advanced, you can play with exception handling in Python

During the programming process, we often encounter various runtime errors, such as zero-dividing errors, file not found errors, etc. To handle these errors, Python provides a powerful exception handling mechanism. By using exception handling rationally, we can make the program more robust and easy to maintain. This article will introduce the basic knowledge of Python exception handling and demonstrate its application in actual programming through some advanced cases.

1. The basics of exception handling

1.1 What is an exception

Exception refers to an error or exception that occurs during the program's running process. These errors will interrupt the normal execution process of the program. An exception in Python is an object that indicates an error or exception condition.

1.2 Catch exceptions

In Python, we can use the try and except keywords to catch and handle exceptions. The code in the try block is code that may throw exceptions, while the except block is used to handle these exceptions.

try:
    # Code that may throw exceptions    result = 10 / 0
except ZeroDivisionError:
    # Handle zero-deletion exception    print("The divisor cannot be zero!")

In the above code, when trying to perform a zero-dividing operation, a ZeroDivisionError exception is raised, and the program will jump to the except block and print the error message.

1.3 Multiple exception handling

A try block can correspond to multiple except blocks, used to handle different types of exceptions.

try:
    # Code that may throw exceptions    num = int("abc")
except ZeroDivisionError:
    print("The divisor cannot be zero!")
except ValueError:
    print("The input is not a valid integer!")
except Exception as e:
    print(f"An exception occurred：{e}")

In the above code, if int("abc") raises a ValueError exception, it will enter the corresponding except block for processing. Exception is a general exception class that can catch all other undefinitely caught exceptions.

1.4 else and finally clauses

The else clause is optional. When the code in the try block does not raise an exception, the code in the else clause will be executed. The finally clause is also optional, but is very useful because the code in the finally clause will be executed regardless of whether the exception is raised or not.

try:
    # Code that may throw exceptions    result = 10 / 2
except ZeroDivisionError:
    print("The divisor cannot be zero!")
else:
    print("The calculation was successful, and the result was:", result)
finally:
    print("Execution is completed, clean up resources")

In the above code, the code in the finally clause is executed regardless of whether the exception is raised or not, which is usually used to free resources or perform some cleaning work.

2. Advanced application

2.1 Custom exceptions

In addition to Python's built-in exception classes, we can also define our own exception classes. Custom exception classes need to inherit the built-in Exception class.

class MyCustomError(Exception):
    def __init__(self, message):
        super().__init__(message)
         = message
 
    def __str__(self):
        return 
 
try:
    # Code that may throw a custom exception    raise MyCustomError("This is a custom exception!")
except MyCustomError as e:
    print(e)

In the above code, we define a custom exception class called MyCustomError and raise the exception in the try block, then catch and process it in the except block.

2.2 Exception chain

In some cases, we want to raise a new exception after catching an exception, while retaining the information of the original exception. This can be achieved through exception chains.

try:
    # Code that may throw exceptions    num = int("abc")
except ValueError as e:
    # Catch ValueError exception and raise a new exception while retaining the information of the original exception.    raise RuntimeError("Conversion failed") from e

In the above code, when int("abc") raises a ValueError exception, we catch the exception in the except block and raise a new RuntimeError exception. Through the from e syntax, we append the information of the original exception e to the new exception.

2.3 Contextlib for context management

The contextlib module provides tools to simplify the creation and use of context managers. A context manager is an object that defines the __enter__ and __exit__ methods that perform some operations when entering and exiting a code block.

from contextlib import contextmanager
 
@contextmanager
def my_context_manager():
    print("Get into context")
    try:
        yield
    except Exception as e:
        print(f"Catched exception：{e}")
    finally:
        print("Exit context")
 
# Use the context managerwith my_context_manager():
    print("Execute code in context")
    raise ValueError("Render an exception")

In the above code, we define a context manager called my_context_manager and convert it into a generator function using the @contextmanager decorator. In the with statement, when entering the context, the __enter__ method (simulated by the code before yield) is executed, and when exiting the context, the __exit__ method (simulated by the code after yield) is executed. If an exception is raised in the context, it will be caught by the exception block.

2.4 Catch all exceptions (use with caution)

While it is possible to use Exception to catch all exceptions, this is usually not a good practice as it hides some potential errors, making debugging more difficult. However, in some cases, we may do need to catch all exceptions, which should be used with caution and logged as much as possible.

try:
    # Code that may throw exceptions    risky_operation()
except Exception as e:
    # Record exception information    import logging
    ("An unknown exception occurred:", exc_info=True)
    # Do some recovery operations or give users a friendly prompt    print("An error occurred, please try again later.")

In the above code, we use the logging module to record the exception information and give the user a friendly prompt. Note that the exc_info=True parameter will record the exception stack information into the log together.

2.5 Exception handling and function return value

When handling exceptions, sometimes we may want the function to be able to return a specific value instead of throwing the exception directly. This can be achieved by setting the return value in the except block.

def safe_divide(a, b):
    try:
        return a / b
    except ZeroDivisionError:
        # Return a specific value instead of throwing an exception        return float('inf')
 
result = safe_divide(10, 0)
print(result)  # Output: inf

In the above code, when b is zero, the safe_divide function catches the ZeroDivisionError exception and returns a specific value float('inf').

3. Practical cases

3.1 File read and write exception handling

When reading and writing files, you often encounter exceptions such as not found files and insufficient permissions. Through exception handling, we can make the program more robust.

def read_file(file_path):
    try:
        with open(file_path, 'r') as file:
            return ()
    except FileNotFoundError:
        print(f"file not found：{file_path}")
        return None
    except PermissionError:
        print(f"No permission to read files：{file_path}")
        return None
    except Exception as e:
        print(f"An unknown exception occurred while reading the file：{e}")
        return None
 
content = read_file('non_existent_file.txt')
print(content)  # Output：file not found：non_existent_file.txt，None

3.2 Network request exception handling

When making network requests, you often encounter exceptions such as connection timeout and request failure. Through exception handling, we can handle these cases better.

import requests
 
def fetch_url(url):
    try:
        response = (url, timeout=5)
        response.raise_for_status()  # If the response status code is not 200, an HTTPError exception will be raised        return 
    except :
        print("Request timed out!")
        return None
    except  as e:
        print(f"Request failed，Status code：{.status_code}")
        return None
    except  as e:
        print(f"An exception occurred while requesting：{e}")
        return None
 
html_content = fetch_url('/non_existent_page')
print(html_content)  # Output：Request failed，Status code：404，None

In the above code, we use the requests library to send HTTP requests and handle possible errors during the request process by catching different types of exceptions.

4. Summary

Exception handling is an integral part of programming, which can make our programs more robust and easy to maintain. By rationally using keywords such as try, except, else, and finally, we can effectively catch and handle exceptions to avoid the program crashing due to unhandled errors. In addition, advanced features such as custom exceptions, exception chains, and context managers further enhance the flexibility and powerful functions of Python exception handling.

In actual combat, file reading and writing and network request are two common scenarios that require exception handling. For file reading and writing, we may encounter exceptions such as file not found and insufficient permissions; for network requests, we may encounter exceptions such as connection timeout and request failure. Through reasonable exception handling, we can make the program run normally in these situations, or at least give the user a friendly prompt.

However, exception handling is not omnipotent. Abuse of exception handling can make the code difficult to understand and maintain. For example, over-catching exceptions (such as using naked except Exception:) can hide some potential errors, making debugging more difficult. Therefore, when using exception handling, we should follow best practices, such as only catching exceptions that we can handle, recording exception information for subsequent debugging, etc.

In addition, we need to pay attention to the relationship between exception handling and function return value. When handling exceptions, sometimes we may want the function to be able to return a specific value instead of throwing the exception directly. This can be achieved by setting the return value in the except block. However, this approach should be used with caution, as it may make the return value of the function unpredictable and understandable.

In short, exception handling is an indispensable part of Python programming. By rationally using exception handling mechanisms, we can make the program more robust and easy to maintain and debug. At the same time, we should also follow best practices to avoid potential problems caused by abuse of exception handling. In future programming practice, we should constantly explore and learn more techniques and methods about exception handling to deal with more complex and changeable programming scenarios.

This is the article about taking you through exception handling in Python from basics to advanced development. For more related Python exception handling content, please search for my previous articles or continue browsing the related articles below. I hope everyone will support me in the future!