TOC

Verwendung der Protokollierung in Python 3

Einführung

Das "+ logging +" - Modul ist Teil der Standard-Python-Bibliothek und bietet die Verfolgung von Ereignissen, die während der Ausführung der Software auftreten. Sie können Ihrem Code Protokollierungsaufrufe hinzufügen, um anzuzeigen, welche Ereignisse aufgetreten sind.

Das "+ logging +" - Modul ermöglicht sowohl die Diagnoseprotokollierung, mit der Ereignisse im Zusammenhang mit dem Betrieb einer Anwendung aufgezeichnet werden, als auch die Überwachungsprotokollierung, mit der die Ereignisse der Transaktionen eines Benutzers zur Analyse aufgezeichnet werden. Es wird insbesondere zum Aufzeichnen von Ereignissen in einer Datei verwendet.

Warum das + logging + Modul verwenden?

Das + logging + - Modul zeichnet die Ereignisse auf, die in einem Programm auftreten, und ermöglicht die Anzeige von Ausgaben, die sich auf alle Ereignisse beziehen, die während der Laufzeit einer Software auftreten.

Sie sind möglicherweise besser mit dem Überprüfen von Ereignissen vertraut, indem Sie die Anweisung + print () + im gesamten Code verwenden. Die Anweisung + print () + enthält eine grundlegende Methode zum Debuggen Ihres Codes, um Probleme zu beheben. Während das Einbetten von + print () + - Anweisungen in den Code den Ausführungsfluss und den aktuellen Status Ihres Programms verfolgen kann, ist diese Lösung aus einigen Gründen weniger wartbar als die Verwendung des Moduls + logging +:

  • Es wird schwierig, zwischen Debugging-Ausgabe und normaler Programmausgabe zu unterscheiden, da beide gemischt sind

  • Wenn Sie im Code verteilte Anweisungen + print () + verwenden, gibt es keine einfache Möglichkeit, die Anweisungen zu deaktivieren, die Debugging-Ausgaben liefern

  • Es wird schwierig, alle "+ print () +" - Anweisungen zu entfernen, wenn Sie mit dem Debuggen fertig sind

  • Es gibt keinen Protokolldatensatz, der leicht verfügbare Diagnoseinformationen enthält

Es ist eine gute Idee, sich daran zu gewöhnen, das "+ logging +" - Modul in Ihrem Code zu verwenden, da dies besser für Anwendungen geeignet ist, die über einfache Python-Skripte hinausgehen und einen nachhaltigen Ansatz für das Debuggen bieten.

Da Protokolle Ihnen Verhalten und Fehler im Laufe der Zeit anzeigen können, können sie Ihnen auch ein besseres Gesamtbild darüber geben, was in Ihrem Anwendungsentwicklungsprozess vor sich geht.

Drucken von Debug-Meldungen an die Konsole

Wenn Sie es gewohnt sind, mit der Anweisung + print () + zu sehen, was in einem Programm geschieht, können Sie ein Programm sehen, das https://www.digitalocean.com/community/tutorials/how-to -konstruiere-Klassen-und-definiere-Objekte-in-Python-3 [definiere eine Klasse] und instanziiere Objekte, die ungefähr so ​​aussehen:

pizza.py

class Pizza():
   def __init__(self, name, price):
       self.name = name
       self.price = price
       print("Pizza created: {} (${})".format(self.name, self.price))

   def make(self, quantity=1):
       print("Made {} {} pizza(s)".format(quantity, self.name))

   def eat(self, quantity=1):
       print("Ate {} pizza(s)".format(quantity, self.name))

pizza_01 = Pizza("artichoke", 15)
pizza_01.make()
pizza_01.eat()

pizza_02 = Pizza("margherita", 12)
pizza_02.make(2)
pizza_02.eat()

Der obige Code hat eine "+ init " -Methode, um den " name" und den "+ price" eines Objekts der "+ Pizza" -Klasse zu definieren. Es gibt dann zwei Methoden, eine mit dem Namen "+ make () ", um Pizzen zuzubereiten, und eine mit dem Namen " eat () ", um Pizzen zuzubereiten. Diese beiden Methoden nehmen den Parameter " Menge " auf, der bei " 1 +" initialisiert wird.

Führen Sie nun das Programm aus:

python pizza.py

Wir erhalten folgende Ausgabe:

OutputPizza created: artichoke ($15)
Made 1 artichoke pizza(s)
Ate 1 pizza(s)
Pizza created: margherita ($12)
Made 2 margherita pizza(s)
Ate 1 pizza(s)

Während die Anweisung + print () + uns zeigt, dass der Code funktioniert, können wir stattdessen das Modul + logging + verwenden.

Entfernen oder kommentieren Sie die Anweisungen "+ print () " im gesamten Code und fügen " import logging +" am Anfang der Datei hinzu:

pizza.py

class Pizza():
   def __init__(self, name, value):
       self.name = name
       self.value = value
...

Das + logging + Modul hat eine default level von + WARNING + `, das ist ein Level über + DEBUG + `. Da wir in diesem Beispiel das "+ logging " - Modul zum Debuggen verwenden, müssen wir die Konfiguration so ändern, dass die Stufe " logging.DEBUG +" Informationen an die Konsole zurückgibt. Wir können das tun, indem wir die folgende Zeile unter der import statement einfügen:

pizza.py

import logging




class Pizza():
...

Diese Stufe von "+ logging.DEBUG " bezieht sich auf einen konstanten ganzzahligen Wert, auf den wir im obigen Code verweisen, um einen Schwellenwert festzulegen. Die Stufe von " DEBUG +" ist 10.

Jetzt werden wir stattdessen alle Anweisungen + print () + durch die Anweisungen + logging.debug () + ersetzen. Im Gegensatz zu "+ logging.DEBUG ", das eine Konstante ist, ist " logging.debug () " eine Methode des Moduls " logging ". Wenn Sie mit dieser Methode arbeiten, können Sie dieselbe https://www.digitalocean.com/community/tutorial_series/working-with-strings-in-python-3[string] verwenden, die an ` print () +` übergeben wurde , Wie nachfolgend dargestellt.

pizza.py

import logging

logging.basicConfig(level=logging.DEBUG)


class Pizza():
   def __init__(self, name, price):
       self.name = name
       self.price = price


   def make(self, quantity=1):


   def eat(self, quantity=1):


pizza_01 = Pizza("artichoke", 15)
pizza_01.make()
pizza_01.eat()

pizza_02 = Pizza("margherita", 12)
pizza_02.make(2)
pizza_02.eat()

Zu diesem Zeitpunkt erhalten wir, wenn wir das Programm mit dem Befehl "+ python pizza.py +" ausführen, die folgende Ausgabe:

OutputDEBUG:root:Pizza created: artichoke ($15)
DEBUG:root:Made 1 artichoke pizza(s)
DEBUG:root:Ate 1 pizza(s)
DEBUG:root:Pizza created: margherita ($12)
DEBUG:root:Made 2 margherita pizza(s)
DEBUG:root:Ate 1 pizza(s)

In den Protokollnachrichten ist der Schweregrad "+ DEBUG " sowie das Wort " root " eingebettet, das sich auf die Stufe Ihres Python-Moduls bezieht. Das " logging +" - Modul kann mit einer Hierarchie von Loggern verwendet werden, die unterschiedliche Namen haben, sodass Sie für jedes Ihrer Module einen anderen Logger verwenden können.

Sie können beispielsweise Protokollierer auf unterschiedliche Protokollierer mit unterschiedlichen Namen und unterschiedlicher Ausgabe festlegen:

logger1 = logging.getLogger("module_1")
logger2 = logging.getLogger("module_2")

logger1.debug("Module 1 debugger")
logger2.debug("Module 2 debugger")
OutputDEBUG:module_1:Module 1 debugger
DEBUG:module_2:Module 2 debugger

Nachdem wir uns mit der Verwendung des Moduls "+ Protokollieren " zum Drucken von Nachrichten auf der Konsole vertraut gemacht haben, können Sie nun das Modul " Protokollieren +" zum Drucken von Nachrichten in einer Datei verwenden.

Nachrichten in einer Datei protokollieren

Der Hauptzweck des Moduls "+ logging +" besteht darin, Nachrichten in einer Datei und nicht in einer Konsole zu protokollieren. Durch das Speichern einer Nachrichtendatei erhalten Sie im Laufe der Zeit Daten, die Sie abrufen und quantifizieren können, damit Sie sehen können, welche Änderungen an Ihrem Code vorgenommen werden müssen.

Um die Protokollierung in einer Datei zu starten, können Sie die Methode + logging.basicConfig () + so ändern, dass sie den Parameter + filename + enthält. In diesem Fall rufen wir den Dateinamen "+ test.log +" auf:

pizza.py

import logging

logging.basicConfig( level=logging.DEBUG)


class Pizza():
   def __init__(self, name, price):
       self.name = name
       self.price = price
       logging.debug("Pizza created: {} (${})".format(self.name, self.price))

   def make(self, quantity=1):
       logging.debug("Made {} {} pizza(s)".format(quantity, self.name))

   def eat(self, quantity=1):
       logging.debug("Ate {} pizza(s)".format(quantity, self.name))

pizza_01 = Pizza("artichoke", 15)
pizza_01.make()
pizza_01.eat()

pizza_02 = Pizza("margherita", 12)
pizza_02.make(2)
pizza_02.eat()

Der obige Code ist derselbe wie im vorherigen Abschnitt, außer dass wir jetzt den Dateinamen für das Protokoll hinzugefügt haben, in das gedruckt werden soll. Sobald wir den Code mit dem Befehl "+ python pizza.py " ausführen, sollten wir eine neue Datei mit dem Namen " test.log +" in unserem Verzeichnis haben.

Öffnen Sie die Datei "+ test.log +" mit nano (oder dem Texteditor Ihrer Wahl):

nano test.log

Wenn die Datei geöffnet wird, wird Folgendes angezeigt:

test.log

DEBUG:root:Pizza created: artichoke ($15)
DEBUG:root:Made 1 artichoke pizza(s)
DEBUG:root:Ate 1 pizza(s)
DEBUG:root:Pizza created: margherita ($12)
DEBUG:root:Made 2 margherita pizza(s)
DEBUG:root:Ate 1 pizza(s)

Dies ähnelt der Konsolenausgabe, die wir im vorherigen Abschnitt gefunden haben, nur dass sie sich jetzt in der Datei + test.log + befindet.

Schließen wir die Datei mit "+ CTRL " + " x " und kehren wir in die Datei " pizza.py +" zurück, damit wir den Code ändern können.

Wir werden den Code weitgehend unverändert lassen, aber die Parameter in den beiden Pizza-Instanzen "+ pizza_01 " und " pizza_02 +" ändern:

pizza.py

import logging

logging.basicConfig(filename="test.log", level=logging.DEBUG)


class Pizza():
   def __init__(self, name, price):
       self.name = name
       self.price = price
       logging.debug("Pizza created: {} (${})".format(self.name, self.price))

   def make(self, quantity=1):
       logging.debug("Made {} {} pizza(s)".format(quantity, self.name))

   def eat(self, quantity=1):
       logging.debug("Ate {} pizza(s)".format(quantity, self.name))

# Modify the parameters of the pizza_01 object
pizza_01 = Pizza()
pizza_01.make()
pizza_01.eat()

# Modify the parameters of the pizza_02 object
pizza_02 = Pizza()
pizza_02.make()
pizza_02.eat()

Führen Sie das Programm nach diesen Änderungen erneut mit dem Befehl "+ python pizza.py +" aus.

Sobald das Programm ausgeführt wurde, können wir Ihre "+ text.log" -Datei erneut mit nano öffnen:

nano test.log

Wenn wir uns die Datei ansehen, werden wir feststellen, dass mehrere neue Zeilen hinzugefügt wurden und dass die vorherigen Zeilen vom letzten Mal, als das Programm ausgeführt wurde, beibehalten wurden:

test.log

DEBUG:root:Pizza created: artichoke ($15)
DEBUG:root:Made 1 artichoke pizza(s)
DEBUG:root:Ate 1 pizza(s)
DEBUG:root:Pizza created: margherita ($12)
DEBUG:root:Made 2 margherita pizza(s)
DEBUG:root:Ate 1 pizza(s)

Obwohl diese Informationen sicherlich nützlich sind, können wir das Protokoll durch Hinzufügen zusätzlicher LogRecord-Attribute informativer gestalten. In erster Linie möchten wir einen für Menschen lesbaren Zeitstempel hinzufügen, der angibt, wann der LogRecord erstellt wurde.

Wir können dieses Attribut zu einem Parameter mit dem Namen "+ format " hinzufügen, indem wir es wie in der Tabelle gezeigt mit der Zeichenfolge "% (asctime) s " referenzieren. Um den Level-Namen " DEBUG " beizubehalten, müssen wir den String "% (Level-Name) s " einfügen und die String-Nachricht, die wir vom Logger zum Ausdrucken auffordern, mit "% ( message) s + `. Jedes dieser Attribute wird durch ein "+ Doppelpunkt +" getrennt, wie im folgenden Code gezeigt.

pizza.py

import logging

logging.basicConfig(
   filename="test.log",
   level=logging.DEBUG,

   )


class Pizza():
   def __init__(self, name, price):
       self.name = name
       self.price = price
       logging.debug("Pizza created: {} (${})".format(self.name, self.price))

   def make(self, quantity=1):
       logging.debug("Made {} {} pizza(s)".format(quantity, self.name))

   def eat(self, quantity=1):
       logging.debug("Ate {} pizza(s)".format(quantity, self.name))

pizza_01 = Pizza("Sicilian", 18)
pizza_01.make(5)
pizza_01.eat(4)

pizza_02 = Pizza("quattro formaggi", 16)
pizza_02.make(2)
pizza_02.eat(2)

Wenn wir den obigen Code mit den hinzugefügten Attributen mit dem Befehl "+ python pizza.py " ausführen, werden unserer Datei " test.log " neue Zeilen hinzugefügt, die zusätzlich zum Level den für Menschen lesbaren Zeitstempel enthalten Name von " DEBUG +" und die zugehörigen Nachrichten, die als Zeichenfolgen an den Logger übergeben werden.

OutputDEBUG:root:Pizza created: Sicilian ($18)
DEBUG:root:Made 5 Sicilian pizza(s)
DEBUG:root:Ate 4 pizza(s)
DEBUG:root:Pizza created: quattro formaggi ($16)
DEBUG:root:Made 2 quattro formaggi pizza(s)
DEBUG:root:Ate 2 pizza(s)

Abhängig von Ihren Anforderungen können Sie zusätzliche LogRecord-Attribute in Ihrem Code verwenden, um die Protokolle Ihrer Programmdateien zu erstellen relevant für Sie.

Wenn Sie Debugging- und andere Meldungen in separaten Dateien protokollieren, erhalten Sie ein ganzheitliches Verständnis Ihres Python-Programms im Laufe der Zeit. So haben Sie die Möglichkeit, Fehler in Ihrem Code auf eine Weise zu beheben und zu ändern, die von der in das Programm gesteckten historischen Arbeit sowie von der in das Programm gesteckten historischen Arbeit abhängig ist Ereignisse und Transaktionen, die auftreten.

Tabelle der Protokollierungsstufen

Als Entwickler können Sie dem Ereignis, das im Logger erfasst wird, einen Grad an Wichtigkeit zuweisen, indem Sie einen Schweregrad hinzufügen. Die Schweregrade sind in der folgenden Tabelle aufgeführt.

Protokollierungsstufen sind technisch ganze Zahlen (eine Konstante) und alle in Schritten von 10 beginnend mit "+ NOTSET +", wodurch der Protokollierer mit dem numerischen Wert 0 initialisiert wird.

Sie können auch eigene Ebenen in Bezug auf die vordefinierten Ebenen definieren. Wenn Sie eine Ebene mit demselben numerischen Wert definieren, überschreiben Sie den diesem Wert zugeordneten Namen.

Die folgende Tabelle zeigt die verschiedenen Ebenennamen, ihren numerischen Wert, welche Funktion Sie zum Aufrufen der Ebene verwenden können und wofür diese Ebene verwendet wird.

Level Numeric Value Function Used to

CRITICAL

50

logging.critical()

Show a serious error, the program may be unable to continue running

ERROR

40

logging.error()

Show a more serious problem

WARNING

30

logging.warning()

Indicate something unexpected happened, or could happen

INFO

20

logging.info()

Confirm that things are working as expected

DEBUG

10

logging.debug()

Diagnose problems, show detailed information

Das "+ Logging" -Modul legt die Standardstufe auf "+ WARNING " fest, daher werden " WARNING ", " ERROR " und " CRITICAL " standardmäßig protokolliert. Im obigen Beispiel haben wir die Konfiguration so geändert, dass die Stufe " DEBUG +" den folgenden Code enthält:

logging.basicConfig(level=logging.DEBUG)

Weitere Informationen zu den Befehlen und zum Arbeiten mit dem Debugger finden Sie in der offiziellen Dokumentation zu https://docs.python.org/3/library/logging.html[official + logging +.

Fazit

Das Debuggen ist ein wichtiger Schritt in jedem Softwareentwicklungsprojekt. Das + logging + - Modul ist Teil der Python-Standardbibliothek, bietet die Verfolgung von Ereignissen, die während der Ausführung der Software auftreten, und kann diese Ereignisse in einer separaten Protokolldatei ausgeben, damit Sie verfolgen können, was während der Ausführung Ihres Codes geschieht. Auf diese Weise haben Sie die Möglichkeit, Ihren Code anhand der verschiedenen Ereignisse zu debuggen, die beim Ausführen Ihres Programms im Laufe der Zeit auftreten.

Related