Verabschieden Sie sich von Print(): Verwenden Sie das Protokollierungsmodul für effektives Debuggen

Bild vom Autor | DALLE-3 & Canva

Viele von uns beginnen ihre Programmierreise mit YouTube-Movies, und der Einfachheit halber verwenden sie oft print() Anweisungen zum Verfolgen von Fehlern. Das ist zwar in Ordnung, aber wenn Anfänger sich diese Gewohnheit aneignen, kann es problematisch werden. Obwohl diese Anweisungen für einfache Skripte funktionieren, wird dieser Ansatz mit zunehmender Codebasis sehr ineffizient. Daher werde ich Ihnen in diesem Artikel das integrierte Protokollierungsmodul von Python vorstellen, das dieses Downside löst. Wir werden sehen, was Protokollierung ist, wie sie sich von der print() Anweisungen und wir werden auch ein praktisches Beispiel behandeln, um die Funktionalität vollständig zu verstehen.

Warum das Protokollierungsmodul anstelle von Print() verwenden?

Wenn wir über das Debuggen sprechen, bietet das Python-Protokollierungsmodul viel detailliertere Informationen als einfache print() Anweisungen. Dazu gehören Zeitstempel, Modulnamen, Protokollebenen und Zeilennummern, in denen Fehler aufgetreten sind usw. Diese zusätzlichen Particulars helfen uns, das Verhalten unseres Codes besser zu verstehen. Die Informationen, die wir protokollieren möchten, hängen von den Anforderungen der Anwendung und den Vorlieben des Entwicklers ab. Bevor wir fortfahren, besprechen wir additionally die Protokollebenen und wie man sie einstellt.

Protokollierungsebenen

Mithilfe dieser Protokollebenen können Sie die Menge der Informationen steuern, die Sie sehen möchten. Jede Protokollebene hat einen numerischen Wert, der ihren Schweregrad angibt, wobei höhere Werte schwerwiegendere Ereignisse anzeigen. Wenn Sie beispielsweise Ihre Protokollebene auf WARNINGsagen Sie dem Protokollierungsmodul, dass es Ihnen nur Nachrichten anzeigen soll, die von WARNING Degree oder höher. Das bedeutet, dass Sie keine DEBUG, INFOoder andere weniger schwerwiegende Nachrichten. Auf diese Weise können Sie sich auf die wichtigen Ereignisse konzentrieren und den Lärm ignorieren

In der folgenden Tabelle ist im Element aufgeführt, was die einzelnen Protokollebenen darstellen:

Einrichten des Protokollierungsmoduls

Um das Protokollierungsmodul zu verwenden, müssen Sie einige Konfigurationsschritte ausführen. Dazu gehört das Erstellen eines Loggers, das Festlegen der Protokollierungsebene, das Erstellen eines Formatierers und das Definieren eines oder mehrerer Handler. Ein Handler entscheidet grundsätzlich, wohin Ihre Protokollnachrichten gesendet werden, z. B. an die Konsole oder an eine Datei. Beginnen wir mit einem einfachen Beispiel. Wir werden das Protokollierungsmodul so einrichten, dass es zwei Dinge tut: Erstens zeigt es Nachrichten auf der Konsole an und gibt uns nützliche Informationen (zumindest INFO Ebene). Zweitens werden detailliertere Nachrichten in einer Datei gespeichert (auf der DEBUG Niveau). Ich würde mich freuen, wenn Sie mitmachen könnten!

1. Festlegen des Protokolllevels

Die Standardstufe des Loggers ist eingestellt auf WARNING. In unserem Fall sind unsere beiden Handler so eingestellt: DEBUG Und INFO Ebenen. Um sicherzustellen, dass alle Nachrichten richtig verwaltet werden, müssen wir daher die Ebene des Loggers auf die niedrigste Ebene aller Handler setzen, was in diesem Fall DEBUG.

import logging

# Create a logger
logger = logging.getLogger(__name__)

# Set logger degree to DEBUG
logger.setLevel(logging.DEBUG)

2. Erstellen eines Formatierers

Sie können Ihre Protokollnachrichten mithilfe von Formatierern personalisieren. Diese Formatierer bestimmen, wie Ihre Protokollnachrichten aussehen. Hier richten wir den Formatierer so ein, dass er den Zeitstempel, die Protokollebene und den Nachrichteninhalt mit dem folgenden Befehl einschließt:

formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')

3. Handler erstellen

Wie bereits erwähnt, verwalten Handler, wohin Ihre Protokollnachrichten gesendet werden. Wir werden zwei Handler erstellen: einen Konsolenhandler zum Protokollieren von Nachrichten an die Konsole und einen Dateihandler zum Schreiben von Protokollnachrichten in eine Datei mit dem Namen „app.log“.

console_handler = logging.StreamHandler()
console_handler.setLevel(logging.INFO)
console_handler.setFormatter(formatter)

file_handler = logging.FileHandler('app.log')
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(formatter)

Beide Handler werden dann dem Logger hinzugefügt mit dem addHandler() Methode.

logger.addHandler(console_handler)
logger.addHandler(file_handler)

4. Testen des Protokollierungs-Setups

Nachdem unser Setup nun abgeschlossen ist, testen wir, ob es richtig funktioniert, bevor wir zum realen Beispiel übergehen. Wir können einige Nachrichten wie folgt protokollieren:

logger.debug('This can be a debug message')
logger.data('That is an data message')
logger.warning('This can be a warning message')
logger.error('That is an error message')
logger.important('This can be a important message')

Wenn Sie diesen Code ausführen, sollten Sie die Protokollmeldungen auf der Konsole sehen und sie in eine Datei mit dem Namen „app.log“ schreiben, etwa wie folgt:

Konsole

2024-05-18 11:51:44,187 - INFO - That is an data message
2024-05-18 11:51:44,187 - WARNING - This can be a warning message
2024-05-18 11:51:44,187 - ERROR - That is an error message
2024-05-18 11:51:44,187 - CRITICAL - This can be a important message

app.log

2024-05-18 11:51:44,187 - DEBUG - This can be a debug message
2024-05-18 11:51:44,187 - INFO - That is an data message
2024-05-18 11:51:44,187 - WARNING - This can be a warning message
2024-05-18 11:51:44,187 - ERROR - That is an error message
2024-05-18 11:51:44,187 - CRITICAL - This can be a important message

Protokollieren der Benutzeraktivität in einer Webanwendung

In diesem einfachen Beispiel erstellen wir eine einfache Webanwendung, die Benutzeraktivitäten mithilfe des Python-Protokollierungsmoduls protokolliert. Diese Anwendung verfügt über zwei Endpunkte: einen zum Protokollieren erfolgreicher Anmeldeversuche und einen anderen zum Dokumentieren fehlgeschlagener Anmeldeversuche (INFO für Erfolg und WARNING für Ausfälle).

1. Einrichten Ihrer Umgebung

Richten Sie vor dem Begin Ihre virtuelle Umgebung ein und installieren Sie Flask:

python -m venv myenv

# For Mac
supply myenv/bin/activate

#Set up flask
pip set up flask

2. Erstellen einer einfachen Flask-Anwendung

Wenn Sie eine POST-Anfrage an die /Anmeldung Endpunkt mit einem Benutzernamen- und Kennwortparameter, prüft der Server, ob die Anmeldeinformationen gültig sind. Wenn dies der Fall ist, zeichnet der Logger das Ereignis mithilfe von logger.data() auf, um einen erfolgreichen Anmeldeversuch anzuzeigen. Wenn die Anmeldeinformationen jedoch ungültig sind, zeichnet der Logger das Ereignis mithilfe von logger.error() als fehlgeschlagenen Anmeldeversuch auf.

#Making Imports
from flask import Flask, request
import logging
import os

# Initialize the Flask app
app = Flask(__name__)

# Configure logging
if not os.path.exists('logs'):
    os.makedirs('logs')
log_file="logs/app.log"
logging.basicConfig(filename=log_file, degree=logging.DEBUG, format="%(asctime)s - %(levelname)s - %(message)s")
log = logging.getLogger(__name__)


# Outline route and handler
@app.route('/login', strategies=('POST'))
def login():
    log.data('Acquired login request')
    username = request.kind('username')
    password = request.kind('password')
    if username == 'admin' and password == 'password':
        log.data('Login profitable')
        return 'Welcome, admin!'
    else:
        log.error('Invalid credentials')
        return 'Invalid username or password', 401

if __name__ == '__main__':
    app.run(debug=True)

3. Testen der Anwendung

Um die Anwendung zu testen, führen Sie das Python-Skript aus und greifen Sie auf die /Anmeldung Endpunkt mithilfe eines Webbrowsers oder eines Instruments wie curl. Beispiel:

Testfall 01

 curl -X POST -d "username=admin&password=password" http://localhost:5000/login

Ausgabe

Testfall 02

curl -X POST -d "username=admin&password=wrongpassword" http://localhost:5000/login

Ausgabe

Invalid username or password

app.log

2024-05-18 12:36:56,845 - INFO - Acquired login request
2024-05-18 12:36:56,846 - INFO - Login profitable
2024-05-18 12:36:56,847 - INFO - 127.0.0.1 - - (18/Might/2024 12:36:56) "POST /login HTTP/1.1" 200 -
2024-05-18 12:37:00,960 - INFO - Acquired login request
2024-05-18 12:37:00,960 - ERROR - Invalid credentials
2024-05-18 12:37:00,960 - INFO - 127.0.0.1 - - (18/Might/2024 12:37:00) "POST /login HTTP/1.1" 200 -

Einpacken

Und damit ist dieser Artikel abgeschlossen. Ich empfehle dringend, das Protokollieren zu einem Teil Ihrer Codierungsroutine zu machen. Dies ist eine großartige Möglichkeit, Ihren Code sauber zu halten und das Debuggen zu vereinfachen. Wenn Sie tiefer eintauchen möchten, können Sie die Python-Protokollierungsdokumentation für weitere Funktionen und fortgeschrittene Techniken. Und wenn Sie Ihre Python-Kenntnisse weiter verbessern möchten, lesen Sie gerne einige meiner anderen Artikel:

Kanwal Mehreen Kanwal ist Ingenieurin für maschinelles Lernen und technische Autorin mit einer tiefen Leidenschaft für Datenwissenschaft und die Schnittstelle zwischen KI und Medizin. Sie ist Mitautorin des E-Books „Maximizing Productiveness with ChatGPT“. Als Google Era Scholar 2022 für APAC setzt sie sich für Vielfalt und akademische Exzellenz ein. Sie ist außerdem als Teradata Variety in Tech Scholar, Mitacs Globalink Analysis Scholar und Harvard WeCode Scholar anerkannt. Kanwal ist eine leidenschaftliche Verfechterin des Wandels und hat FEMCodes gegründet, um Frauen in MINT-Fächern zu stärken.