Error Handling & Logging in Python

In Python software development, various types of errors will be encountered, such as syntax errors, logic errors and runtime errors.

Syntax errors usually occur in the early stages of program development and are caused by incorrect syntax. Syntax errors are easily discovered when compiling a program.

Logical errors are caused by improper logic implementation, such as a program accessing an unsorted list but assumes that it is sorted. Logical errors are one of the most difficult types of errors to track.

Runtime errors are common errors, usually occur because all boundary situations are not considered. For example, try to access a file that does not exist.

This tutorial will explain how to deal with errors in Python and how to log error logs to better understand problems in your application. We will cover the following topics:

• Use try and except to handle exceptions
• Multiple exception handling
• finallySentence
• Custom exception
• Python logging
• Get stack trace information

Python exception handling

Let's start with a simple Python addition program. The program takes two parameters as input and prints their sum:

def addNumbers(a, b):
    print(a + b)

addNumbers(5, 10)

Run the above program and the sum of the two numbers will be printed.

Creating custom exception classes can improve the readability and maintainability of your program. For example, suppose there is a program that needs to ensure that the discount price of the item is not higher than the sales price, we can create a custom exception for this type of error:

class PriceError(Exception):
    pass

Then, add exception handling to the program:

def discount(price, discounted_price):
    if discounted_price > price:
        raise PriceError
    else:
        print("Discount applied")

In the above code, if discounted_price is greater than price, an exception will be raised. PriceError

Python logging

Python's

module provides a mechanism to record program running information, including error messages. We can set different log levels such as DEBUG, INFO, WARNING, ERROR, and CRITICAL. The following code snippet shows how to record information using the logging module: logging

import logging

# 初始化日志设置
logging.basicConfig(filename='app.log', level=logging.INFO)

try:
    # ...你的代码...
except Exception as e:
    logging.exception(str(e))

Set the log level to INFO, and log information at INFO and above levels (including WARNING, ERROR and CRITICAL) will be recorded.

Get stack trace information

In the example above, there is only one program file, so it is easy to find where the error occurred. However, it is particularly important to get the wrong stack trace information when multiple program files are involved. You can use the

method to record the stack trace information of the exception, as shown below: logging.exception()

import logging

# 初始化日志设置
logging.basicConfig(filename='app.log', level=logging.INFO)

try:
    filePointer = open('appFile', 'r')
    try:
        content = filePointer.readline()
    finally:
        filePointer.close()
except IOError as e:
    logging.exception(str(e))

If the above program is run and an exception occurs, the error message will be logged into the log file, which contains the stack trace information.

Summary

This tutorial introduces the basic methods of Python error handling and logging, including the use of try, except and finally statements and the application of logging modules. It is recommended to read the official documentation for more detailed information.

This document has been updated and contains contributions from Esther Vaati. Esther is a software developer and contributor to Envato Tuts.

The above is the detailed content of Error Handling & Logging in Python. For more information, please follow other related articles on the PHP Chinese website!