编写软件是一项远非完美的活动。从构思到生产，可能会出现错误，在某些情况下，可能会故意发生失败。这就是为什么理解主要编程语言中的错误处理和日志记录是一项需要掌握的关键技能。
错误可能会发生，情况也可能会出现，但是您的应对方式（包括有关错误的准备和信息）将使您尽快摆脱困境。
在本文中，我们将了解 Python 中的错误处理和日志记录。我们将主要探讨异常以及如何使用Python的logging包来编写各种类型的日志。
如果您对此类主题的更多内容感兴趣，请订阅我的 时事通讯 有关软件编程、架构和技术的定期更新与技术相关的见解。
与许多其他编程语言一样，Python 能够在发生错误时引发异常。在编程中，异常是在程序执行期间发生的事件，扰乱了正常的指令流。
在Python中，异常是在执行过程中检测到的错误。当异常发生时，Python 会停止运行代码并寻找特殊的代码块（try/ except 块）来处理错误。
以下是 Python 程序中可能发生的一些常见异常：
ZeroDivisionError：尝试将数字除以零时发生。
FileNotFoundError：尝试打开不存在的文件时发生。
ValueError：当字符串不代表数字时尝试将字符串转换为整数时发生。
IndexError: 尝试从索引不存在的列表中检索元素时发生。
还有更多的异常，如果您需要自定义行为，Python 使您能够创建自己的异常。我们将在本文后面探讨这个功能。
要处理Python异常，你需要捕获它们。捕获异常需要一种称为 try/ except 的简单语法。让我们来探索一下。
try/ except 块用于处理异常。可能引发异常的代码放在try块中，如果发生异常，则执行 except块。以下是代码块中 try/ except 的语法：
try:
# Code that might raise an exception
pass
except ExceptionType as e:
# Code to handle the exception
pass
可能失败的代码放在 try 块内。如果出现问题，程序的执行会进入 except 块。
这是一个流程图，说明了 try/ except 的工作原理：
让我们看看如何用这种方法处理被零除的情况：
# Handling division by zero
try:
result = 10 / 0
except ZeroDivisionError:
print("Error: Cannot divide by zero.")
# The code will continue its execution
try/ except 语法中还有其他块，例如 else 和 finally：
try:
# Code that might raise an exception
pass
except ExceptionType as e:
# Code to handle the exception
pass
else:
# Code to run if no exception is raised
pass
finally:
# Code that always runs, regardless of whether an exception was raised or not
pass
这些块是可选的，但有特定用途：
else 块（可选）：包含在 try 块中没有引发异常时运行的代码。它对于只应在 try 块成功时运行的代码很有用。
finally 块（可选）：包含始终运行的代码，无论是否引发异常。这通常用于清理操作，例如关闭文件或释放资源。
这是一个示例，我们在出现错误时在 finally 中处理文件的关闭：
try:
# Open the file
file = open('example.txt', 'r')
# Read from the file
content = file.read()
# Print file content (this will only execute if no exceptions are raised)
print(content)
except FileNotFoundError as e:
# Handle the specific exception
print(f"Error: {e}")
except Exception as e:
# Handle any other exceptions
print(f"An unexpected error occurred: {e}")
else:
# Code that runs if no exception was raised in the try block
print("File read successfully.")
finally:
# Ensure the file is closed, regardless of whether an exception was raised
try:
file.close()
print("File closed.")
except:
# Handle the case where file was never opened (e.g., if open() failed)
print("File was not opened or already closed.")
免责声明： 上面的示例演示了使用 try/ except/finally 进行文件处理，以确保即使发生错误也能正确关闭文件。然而，这种方法对于日常文件操作来说并不理想。在实践中，建议在Python中使用with语句进行文件处理。 with 语句自动管理文件的打开和关闭，确保文件在其套件完成后正确关闭，即使发生异常也是如此。
这就是 try/ except 的工作原理。现在，if/else 可能会造成一些混淆。什么时候应该使用 try/ except，什么时候应该使用 if/else？
try/ except 和 if/else 有什么区别？当您想要检查可以在导致错误之前预测和处理的条件时，请使用 if/else，并使用 try/ except 来捕获和管理代码执行期间发生的异常，特别是对于您无法轻易预见的错误。
在下面的情况下，if/else 将无法正常工作：
filename = 'non_existent_file.txt'
if filename: # This only checks if filename is not empty, not if the file exists
# The following line will raise an exception if the file doesn't exist
content = open(filename, 'r').read() # This will crash if the file does not exist
if content:
print("File content exists:")
print(content)
else:
print("File is empty.")
else:
print("Filename is invalid.")
这里有一个更好的 try/ except 解决方案：
filename = 'non_existent_file.txt'
try:
content = open(filename, 'r').read()
if content:
print("File content exists:")
print(content)
else:
print("File is empty.")
except FileNotFoundError:
print("Error: File not found.")
In the solution above, the code attempts to open and read a file, checking if its content exists and printing it if present. If the file does not exist, it catches the FileNotFoundError and prints an error message, preventing the program from crashing.
As mentioned earlier in the article, Python allows for custom exceptions. Let’s learn more about it.
In Python, you can define your own exceptions to handle specific error conditions in a more granular way. Custom exceptions are particularly useful in complex applications, such as fintech, where you may need to enforce business rules or handle specific error cases uniquely.
For example, in a fintech application, you might have a scenario where a wallet’s balance is checked against certain criteria. You may want to raise an exception if a wallet’s balance is not sufficient or does not conform to specific rules. Here’s how you can create and use a custom exception for this purpose:
# Define a custom exception
class WalletBalanceError(Exception):
def __init__(self, message):
self.message = message
super().__init__(self.message)
# Function that checks wallet balance
def check_wallet_balance(wallet_balance, required_balance):
if wallet_balance < required_balance:
# Raise the custom exception with a specific message
raise WalletBalanceError(f"Insufficient balance: Wallet balance of {wallet_balance} is less than the required {required_balance}.")
# Example usage
try:
# Example wallet balance and required balance
wallet_balance = 50
required_balance = 100
# Check if the wallet balance is sufficient
check_wallet_balance(wallet_balance, required_balance)
except WalletBalanceError as e:
# Handle the custom exception
print(f"Error: {e}")
In this example, we define a custom exception WalletBalanceError to handle cases where a wallet’s balance does not meet the required criteria. The check_wallet_balance function raises this exception if the wallet’s balance is insufficient, providing a clear and specific error message.
Custom exceptions in Python help make the code more readable and maintainable by clearly defining specific error conditions and handling them in a structured manner.
Now that we know how to handle errors in Python, it’s time to understand what to do when these errors occur. There are many strategies, but keeping a log of these errors can help identify issues later and correct them. In the next section of this article, we will explore logging.
Logging helps developers track errors, events, or any runtime information in an application or program. Logging is an important and crucial aspect of software engineering as it has the ability to record everything that goes right or wrong in a post-development application. Logging is one of the most important pillars of monitoring.
Python provides a built-in module that can be used for logging
purposes. To use this module, the first thing to do is to import it.
import logging
Then, configure the logger using the basicConfig method. You need to pass parameters to it, such as the log level, the format of the message, and the output file to save the log.
import logging
# Set up the basic configuration for logging
logging.basicConfig(filename='app.log', level=logging.DEBUG,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Log messages of various severity levels
logging.debug('This is a debug message')
logging.info('This is an info message')
logging.warning('This is a warning message')
logging.error('This is an error message')
logging.critical('This is a critical message')
In the example above, logs will be written to a file called app.log. The log message format includes the timestamp, logger name, log level, and the actual message.
Python logging has different log levels that indicate the severity of an event or message. These log levels allow you to categorize and filter messages based on their importance. Here’s a breakdown of the common log levels in Python:
DEBUG: Detailed information, typically of interest only when diagnosing problems. Used for debugging purposes during development.
INFO: Confirmation that things are working as expected. This is the level you would use for normal operations and informational messages.
WARNING: An indication that something unexpected happened, or indicative of some problem in the near future (e.g., "disk space low"). The software is still working as expected.
ERROR: Due to a more serious problem, the software has not been able to perform some function. An error indicates a significant issue that needs attention.
CRITICAL: A very serious error, indicating that the program itself may be unable to continue running. Critical errors often represent severe problems that require immediate action.
The logging module allows you to control which messages are recorded by setting the logging level. Only messages that are equal to or more severe than the set level will be logged. The default level is WARNING, meaning only WARNING, ERROR, and CRITICAL messages are logged unless you change the logging configuration.
In the code example above, we set the logging level to DEBUG, which means all log messages (DEBUG, INFO, WARNING, ERROR, and CRITICAL) will be recorded in the app.log file.
You can also create custom loggers, which give you more control over how messages are logged. Custom loggers allow you to set up multiple loggers with different configurations, such as different log levels, formats, or output destinations. This is particularly useful in larger applications where you need to separate logs for different modules or components.
Here’s how you can create and use a custom logger:
import logging
# Create a custom logger
logger = logging.getLogger('my_custom_logger')
# Set the log level for the custom logger
logger.setLevel(logging.DEBUG)
# Create a file handler to write logs to a file
file_handler = logging.FileHandler('custom.log')
# Create a console handler to output logs to the console
console_handler = logging.StreamHandler()
# Set log levels for the handlers
file_handler.setLevel(logging.ERROR)
console_handler.setLevel(logging.DEBUG)
# Create a formatter for log messages
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# Add the formatter to the handlers
file_handler.setFormatter(formatter)
console_handler.setFormatter(formatter)
# Add the handlers to the logger
logger.addHandler(file_handler)
logger.addHandler(console_handler)
# Log messages using the custom logger
logger.debug('This is a debug message')
logger.info('This is an info message')
logger.warning('This is a warning message')
logger.error('This is an error message')
logger.critical('This is a critical message')
In this example, we create a custom logger named my_custom_logger. This logger writes ERROR and more severe messages to a file called custom.log, while DEBUG and more severe messages are output to the console. By customizing the loggers, you can tailor the logging behavior to fit the specific needs of your application.
In a web application, logging plays a critical role in monitoring and maintaining the system’s health. For example, in a Flask web application, you might use logging to track incoming requests, errors, and performance metrics.
Here’s a basic example of how you can use logging in a Flask application:
from flask import Flask, request
import logging
app = Flask(__name__)
# Set up the basic configuration for logging
logging.basicConfig(filename='webapp.log', level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
@app.route('/')
def index():
app.logger.info('Index page accessed')
return 'Welcome to the Flask Web Application!'
@app.route('/error')
def error():
app.logger.error('Error page accessed')
raise ValueError('This is a simulated error')
if __name__ == '__main__':
app.run(debug=True)
In this Flask application, we configure logging to write logs to a file named webapp.log. Each time the index page is accessed, an informational log message is recorded. If the error page is accessed, an error log message is recorded, and a simulated error is raised.
By implementing logging in your web application, you can gain insights into user activity, system errors, and performance issues. This information is invaluable for debugging, troubleshooting, and optimizing the application.
Error handling and logging are essential aspects of software development, ensuring that applications run smoothly and that any issues are quickly identified and resolved.
In this article, we explored exceptions in Python, including how to handle them using try/except, and the importance of logging for tracking errors and events. We also discussed how to create custom exceptions and custom loggers to suit specific application needs.
By mastering error handling and logging, you’ll be better equipped to build robust and maintainable software that can gracefully handle unexpected situations and provide valuable insights into its operation.
If you enjoyed this article, consider subscribing to my newsletter so you don't miss out on future updates.
Your feedback is valuable! If you have any suggestions, critiques, or questions, please leave a comment below.
以上是Python 中的错误处理和日志记录的详细内容。更多信息请关注PHP中文网其他相关文章！
