Fehlerbehandlung und Protokollierung in Python

Das Schreiben von Software ist alles andere als perfekt. Von der Ideenfindung bis zur Produktion können Fehler auftreten, und in manchen Fällen kann es auch vorsätzlich zu Fehlern kommen. Aus diesem Grund ist das Verständnis der Fehlerbehandlung und -protokollierung in Ihrer primären Programmiersprache eine entscheidende Fähigkeit, die Sie beherrschen müssen.

Fehler können passieren und Situationen können entstehen, aber wie Sie darauf reagieren – mit Vorbereitung und Informationen über den Fehler – werden Sie so schnell wie möglich aus der Situation befreien.

In diesem Artikel erfahren Sie mehr über die Fehlerbehandlung und Protokollierung in Python. Wir werden uns hauptsächlich mit Ausnahmen und der Verwendung des Python-Protokollierungspakets zum Schreiben verschiedener Arten von Protokollen befassen.

Wenn Sie an weiteren Inhalten zu Themen wie diesem interessiert sind, abonnieren Sie meinen Newsletter für regelmäßige Updates zu Softwareprogrammierung, Architektur und technikbezogene Einblicke.

Ausnahmen in Python

Wie viele andere Programmiersprachen verfügt auch Python über die Möglichkeit, beim Auftreten von Fehlern Ausnahmen auszulösen. In der Programmierung ist eine Ausnahme ein Ereignis, das während der Ausführung eines Programms auftritt und den normalen Befehlsfluss stört.

In Python sind Ausnahmen Fehler, die während der Ausführung erkannt werden. Wenn eine Ausnahme auftritt, stoppt Python die Ausführung des Codes und sucht nach einem speziellen Codeblock (einem Try/Except-Block), um den Fehler zu behandeln.

Hier sind einige häufige Ausnahmen, die in einem Python-Programm auftreten können:

• ZeroDivisionError: Tritt auf, wenn versucht wird, eine Zahl durch Null zu dividieren.

• FileNotFoundError: Tritt auf, wenn versucht wird, eine Datei zu öffnen, die nicht existiert.

• ValueError: Tritt auf, wenn versucht wird, eine Zeichenfolge in eine Ganzzahl umzuwandeln, wenn die Zeichenfolge keine Zahl darstellt.

• IndexError: Tritt auf, wenn versucht wird, ein Element aus einer Liste mit einem nicht vorhandenen Index abzurufen.

Es gibt viele weitere Ausnahmen und Python bietet Ihnen die Möglichkeit, Ihre eigenen Ausnahmen zu erstellen, wenn Sie benutzerdefiniertes Verhalten benötigen. Dies ist eine Funktion, auf die wir später in diesem Artikel näher eingehen werden.

Um Python-Ausnahmen zu behandeln, müssen Sie sie abfangen. Das Abfangen von Ausnahmen erfordert eine einfache Syntax namens try/exclusive. Lassen Sie uns das erkunden.

Versuchen/Außer

Der try/exclusive-Block wird zur Behandlung von Ausnahmen verwendet. Code, der eine Ausnahme auslösen könnte, wird im Try-Block platziert, und wenn eine Ausnahme auftritt, wird der Except-Block ausgeführt. Hier ist die Syntax von try/exclusive in einem Codeblock:

try:
    # Code that might raise an exception
    pass
except ExceptionType as e:
    # Code to handle the exception
    pass

Der Code, der möglicherweise fehlschlagen könnte, wird in den Try-Block eingefügt. Wenn ein Problem auftritt, wird die Programmausführung in den Ausnahmeblock verschoben.

Hier ist ein Flussdiagramm, das veranschaulicht, wie Try/Except funktioniert:

Sehen wir uns an, wie wir mit diesem Ansatz eine Division durch Null bewältigen können:

# Handling division by zero
try:
    result = 10 / 0
except ZeroDivisionError:
    print("Error: Cannot divide by zero.")
# The code will continue its execution

Es gibt auch zusätzliche Blöcke in der Try/Except-Syntax, wie zum Beispiel else und schließlich:

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

Diese Blöcke sind optional, dienen aber bestimmten Zwecken:

• else-Block (optional): Enthält Code, der ausgeführt wird, wenn im try-Block keine Ausnahmen ausgelöst werden. Dies ist nützlich für Code, der nur ausgeführt werden soll, wenn der Try-Block erfolgreich ist.

• finally Block (Optional): Enthält Code, der immer ausgeführt wird, unabhängig davon, ob eine Ausnahme ausgelöst wurde oder nicht. Dies wird normalerweise für Bereinigungsaktionen verwendet, z. B. das Schließen von Dateien oder das Freigeben von Ressourcen.

Hier ist ein Beispiel, in dem wir das Schließen einer Datei im Falle eines Fehlers endgültig durchführen:

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.")

Haftungsausschluss: Das obige Beispiel zeigt die Dateiverarbeitung mit try/exclus/finally, um sicherzustellen, dass die Datei ordnungsgemäß geschlossen wird, auch wenn ein Fehler auftritt. Dieser Ansatz ist jedoch nicht ideal für alltägliche Dateivorgänge. In der Praxis wird empfohlen, die with-Anweisung für die Dateiverwaltung in Python zu verwenden. Die with-Anweisung verwaltet automatisch das Öffnen und Schließen von Dateien und stellt sicher, dass die Datei nach Abschluss ihrer Suite ordnungsgemäß geschlossen wird, selbst wenn eine Ausnahme auftritt.

So funktioniert das Try/Except. Nun könnte es zu Verwirrung mit if/else kommen. Wann sollten Sie try/exclusive und wann if/else verwenden?

Was ist der Unterschied zwischen try/exclusive und if/else? Verwenden Sie if/else, wenn Sie Bedingungen überprüfen möchten, die Sie vorhersagen und behandeln können, bevor sie Fehler verursachen, und verwenden Sie try/exclusive, um Ausnahmen abzufangen und zu verwalten, die während der Codeausführung auftreten, insbesondere für Fehler, die Sie nicht leicht vorhersehen können.

Im folgenden Fall funktioniert if/else nicht ordnungsgemäß:

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.")

Hier ist eine bessere Lösung mit try/exclusive:

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.

Creating Custom Exceptions in Python

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 in Python

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:

Log Levels

1. DEBUG: Detailed information, typically of interest only when diagnosing problems. Used for debugging purposes during development.

2. INFO: Confirmation that things are working as expected. This is the level you would use for normal operations and informational messages.

3. 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.

4. 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.

5. 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.

Real-world Example: Logging in a Web 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.

Conclusion

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.

Das obige ist der detaillierte Inhalt vonFehlerbehandlung und Protokollierung in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!