Jeder Programmierer wird beim Schreiben von Code für die Entwicklung einer Anwendung Fehler vorliegen. Das Debugging wird vom Coder verwendet, um die Fehler der Anwendung zu lösen. Die Protokollierungsfunktion erleichtert den Debugging -Prozess, indem die Ausgabe von Fehler-, Warn- und Informationsnachrichten in einer Datei gespeichert wird. Diese Nachrichten helfen den Codierern, die Ereignisse zu verfolgen, den Grund für die unerwünschte Ausgabe zu verstehen und den Code ordnungsgemäß zu ändern, um eine fehlerfreie Anwendung zu erstellen. Python verfügt. Django ist ein beliebtes Python-Framework, das das Python-integrierte Protokollierungsmodul zum Debugging-Zweck verwendet. Wie das Python -Protokollierungsmodul in der Django -Anwendung für Debugging -Zwecke verwendet werden kann, wird in diesem Tutorial erläutert.

Verschiedene Teile der Django -Protokollierung

Die Django -Protokollierung enthält vier Arten von Konfigurationen, die unten erläutert werden.

1. Django Logger
Der Logger zeichnet die Ereignisse auf, die bei Ausführung der Anwendung und die Protokollierung aufgerufen werden. Die Protokolleinträge werden in einer Datei gespeichert, indem sie in verschiedenen Protokollebenen kategorisiert werden. Jede Protokollebene gibt die Schwere der Ereignisse an. Die Zwecke dieser Protokollebenen werden nachstehend erwähnt:

1. DEBUGGEN
   Es bietet Systeminformationen auf niedrigem Niveau zum Debuggen.

2. DIE INFO
   Es liefert allgemeine Informationen.

3. FEHLER
   Es enthält Informationen über das Hauptproblem der Anwendung.

4. WARNUNG
   Es enthält Informationen über das geringfügige Problem der Anwendung.

5. KRITISCH
   Es enthält Informationen über das kritische Problem der Anwendung.

2. Django -Handler
Die Hauptaufgabe des Handlers besteht darin, die in der Protokolldatei gespeicherten Protokollinformationen zu übertragen. Das Protokollierungsmodul enthält viele Arten von Handlern und mehrere davon können für denselben Logger definiert werden.

3. Django -Formatierer
Es wird verwendet, um die Protokolldaten zu formatieren. Die Daten des Handlers können nicht direkt an die Protokolldatei gesendet werden, und die Handlerdaten müssen vor dem Senden durch die Verwendung des Formaters konvertiert werden. Das Formatierer wandelt die Protokolldatensätze in die Zeichenfolge um. Das Format der Daten hängt von der Geschäftslogik des Handlers ab.

4. Django -Filter
Es wird verwendet, um die Protokollnachrichten zu filtern. Es ist unnötig, alle Protokollnachrichten in die Protokolldatei zu speichern. Für verschiedene Nachrichten können verschiedene Handler verwendet werden, und die erforderlichen Protokollnachrichten können mit den erforderlichen Filtern gefiltert werden.

Voraussetzungen

Bevor Sie das Skript dieses Tutorials üben, müssen Sie die folgenden Aufgaben ausführen:

1. Installieren Sie die Django Version 3+ auf Ubuntu 20+ (vorzugsweise)
2. Erstellen Sie ein Django -Projekt
3. Führen Sie den Django -Server aus, um zu überprüfen, ob der Server ordnungsgemäß funktioniert oder nicht.

Richten Sie eine Django -App ein

1. Führen Sie den folgenden Befehl aus, um eine Django -App mit dem Namen zu erstellen logApp.

$ python3 verwalten.PY startApp logApp

2. Führen Sie den folgenden Befehl aus, um den Benutzer zum Zugriff auf die Django -Datenbank zu erstellen. Wenn Sie den Benutzer zuvor erstellt haben, müssen Sie den Befehl nicht ausführen.

$ python3 verwalten.Py erzeugt

3. Fügen Sie den App -Namen in die hinzu Installed_app Teil der py Datei.

Installed_apps = [
…
'logApp'
]

Legen Sie die Protokollierungsinformationen in Einstellungen ein.py

Öffne das Einstellungen.py Datei aus dem Django -Projektordner und fügen Sie den folgenden Inhalt hinzu, um die Protokollierungsinformationen zu definieren. Die Eigenschaften der Handler Und Holzfäller sind hier eingestellt. Gemäß den Protokollierungseigenschaftswerten, DEBUGGEN Level -Protokollierungsinformationen werden in einer Protokolldatei mit dem Namen gespeichert Djangoapp.Protokoll Wenn die Django -App ausgeführt wird.

# Django -Protokollierungsinformationen
Logging =
# Definieren Sie die Protokollierungsversion
'Version 1,
# Die vorhandenen Holzfäller aktivieren
'Disable_EXISTING_LOGGERS': FALSE,
# Definieren Sie die Handler
'Handler':
'Datei':
'Level': 'Debug' ',
'Klasse': 'Protokollierung.DateiHandler ',
'Dateiname': 'Djangoapp.Protokoll',
,
'Konsole':
'Klasse': 'Protokollierung.Streamhandler ',
,
,
# Definieren Sie die Holzfäller
'Loggers':
'Django':
'Handler': ['Datei'],
'Level': 'Debug' ',
'Propagate': wahr,
,
,

Öffne das Djangoapp.Protokoll Datei zum Überprüfen der Protokolleinträge werden in der Datei gespeichert oder nicht.

Legen Sie die Protokollierungsinformationen in Ansichten ein.py

Protokollierungsinformationen können auch mit der Ansichtsdatei definiert werden. Öffne das Ansichten.py Datei aus der logApp Ordner und ersetzen Sie den Inhalt durch das folgende Skript. In diesem Skript, Formatter, Handler, Und Holzfäller Teile der Django -Protokollierung sind in der definiert Konfiguration.dictconfig () Methode. DEBUGGEN Level -Protokollierungsinformationen werden in einer Protokolldatei mit dem Namen gespeichert Djangoapp.Protokoll und wird in der Konsole gedruckt, wenn die Django -App ausgeführt wird. Index() Funktion wird verwendet, um einen einfachen Schlagzeilentext an den Browser und die zu senden display_log () Die Funktion wird definiert, um einen einfachen Text im Terminal und einen Schlagzeilentext an den Browser zu senden.

Ansichten.py

# Importieren Sie das Protokollierungsmodul
Protokollierung importieren
# HTTPResponse importieren, um Daten an den Browser zu senden
von django.http import httPesponse
# Definieren Sie die Protokollierungskonfigurationen
Protokollierung.Konfiguration.dictconfig (
# Definieren Sie die Protokollierungsversion
'Version 1,
# Die vorhandenen Holzfäller aktivieren
'Disable_EXISTING_LOGGERS': FALSE,
# Definieren Sie die Formatierungen
'Formatter':
'Konsole':
'Format': '%(Nachricht) S'
,
'Datei':
'Format': '%(Nachricht) S'
,
# Definieren Sie die Handler
'Handler':
'Konsole':
'Klasse': 'Protokollierung.Streamhandler ',
"Formatierer": "Konsole"
,
'Datei':
'Level': 'Debug' ',
'Klasse': 'Protokollierung.DateiHandler ',
"Formatierer": "Datei",
'Dateiname': 'Djangoapp.Protokoll'

,
# Definieren Sie die Holzfäller
'Loggers':
'Django':
'Level': 'Debug' ',
'Handler': ['Datei', 'Konsole'],



)
# Erstellen Sie das Logger -Objekt
logger = Protokollierung.getLogger ('__ name__')
# Definieren Sie die Funktion für die Indexseite
Def Index (Anfrage):
Rückgabe httPesponse ("

Dies ist eine Django -Anwendung

"))
# Definieren Sie die Funktion für die Protokollseite
Def display_log (Anfrage):
# Senden Sie den Test!! Meldung auf Standard ausführen
Logger.Fehler ("Testen von Django log ...")
Rückgabe httPesponse ("

Django -Protokollierungsnachricht

"))

Ändern Sie den Inhalt der URLs.py Datei mit dem folgenden Skript. Im Skript wird der leere Pfad (") Pfad definiert, um das aufzurufen Index() Funktion der Ansichten und der 'Protokoll/'Pfad wird verwendet, um das aufzurufen display_log () Funktion der Ansichten.

URLs.py

von django.URLS -Importweg
Aus LogApp -Importansichten
urlpatterns = [
Pfad (", Ansichten.Index),
Pfad ('log/', Ansichten.Display_log)
]

Führen Sie die folgende URL aus, um die Indexseite anzuzeigen.

http: // localhost: 8000

Führen Sie die folgende URL aus, um die Methode display_log () aufzurufen, mit der eine Textnachricht im Browser und eine Textnachricht im Terminal angezeigt werden. Protokolleinträge werden in der beigefügt Djangoapp.Protokoll Datei.

Abschluss

Zwei Möglichkeiten zur Verwendung von Python -Protokollierung in der Django -Anwendung, um die Protokollierungsinformationen auf Debug -Level aufrechtzuerhalten, werden in diesem Tutorial angezeigt. Das grundlegende Konzept in Bezug.