כיצד להשתמש ביומן ב-Python 3

הקדמה

מודול ה־logging הוא חלק מספרית הפייתון התקנית ומספק מעקב לאירועים שקורים בזמן הרצת התוכנה. ניתן להוסיף קריאות ל־logging לקוד שלך כדי לציין אילו אירועים התרחשו.

מודול ה־logging מאפשר הקלדה לשני מטרות: הלוגינג הדיאגנוסטי שמספר אירועים הקשורים לפעולת היישום, וגם הלוגינג האודיטיבי שמקליט את אירועי העסקאות של המשתמש לצורך ניתוח. השימוש בו נפוץ בעיקר לרישום אירועים לקובץ.

דרישות מוקדמות

עליך להיות מותקן פייתון 3 ולהגדיר סביבת פיתוח במחשב או בשרת שלך. אם אין לך סביבת פיתוח מוגדרת, תוכל לעיין במדריכי ההתקנה וההגדרה עבור סביבת פיתוח מקומית או עבור סביבת פיתוח על השרת שלך המתאימה למערכת ההפעלה שלך (אובונטו, CentOS, Debian וכו').

למה להשתמש במודול logging

המודול logging שומר רשומה של האירועים שקורים בתוך תוכנית, מאפשר לראות את הפלט הקשור לכל אחד מהאירועים שקורים במהלך ריצת התוכנה.

עשוי שתהיה מוכר יותר עם בדיקה שהאירועים מתרחשים על ידי שימוש בהצהרת print() בקוד שלך. ההצהרה print() מספקת דרך בסיסית להתמודד עם באגים בקוד שלך. בעוד הטבעת ההצהרות print() בכל הקוד יכולות לעקוב אחרי זרימת הביצוע והמצב הנוכחי של התוכנה שלך, הפתרון הזה מוכיח עצמו כפחות נתמך משימוש במודול logging מספר סיבות:

• קשה להבדיל בין פלט לאיתור באגים לבין פלט רגיל של התוכנית מכיוון שהשניים מעורבבים
• בשימוש בהצהרות print() הפזורות בקוד, אין דרך יעילה לנטרל את אלו שמספקות פלט איתור באגים
• קשה להסיר את כל ההצהרות print() כשסיימת את האיתור באגים
• אין רשומת לוג המכילה מידע דיאגנוסטי זמין מראש

זהו רעיון טוב לפתח את הקצב להשתמש במודול logging בקוד שלך מאחר וזה מתאים יותר ליישומים שגדלים מעבר לתסריטים פיתונים קטנים ומספק גישה מתמידה לאיתור באגים.

מאחר ויומני הרישום יכולים להראות לך את ההתנהגות והשגיאות לאורך זמן, הם יכולים גם לתת לך תמונה כללית יותר של מה שקורה בתהליך הפיתוח של היישום שלך.

הדפסת הודעות ניפוי שגיאות למסוף

אם אתה רגיל להשתמש בהצהרת print() כדי לראות מה קורה בתוכנית, יתכן שאתה משתמש בתוכנית שמגדירה מחלקה ויוצרת אובייקטים שיוצרים משהו כמו זה:

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()

הקוד לעיל מכיל את השיטה __init__ כדי להגדיר את name ו־price של אובייקט ממחלקת Pizza. לאחר מכן ישנן שתי שיטות, אחת בשם make() ליצירת פיצות, ואחת בשם eat() לאכילת פיצות. שתי השיטות אלו מקבלות את הפרמטר quantity, שמאתחל ב־1.

עכשיו בואו נריץ את התוכנית:

python pizza.py

נקבל את הפלט הבא:

Output
Pizza 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)

בזמן שהצהובת print() מאפשרת לנו לראות שהקוד פועל, אנו יכולים להשתמש במודול logging לכך במקום.

בואו נסיר או נציין הערה על הצהובות print() בכל אורך הקוד, ונוסיף import logging לראש הקובץ:

import logging


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

למודול logging יש רמת ברירת מחדל של WARNING, שהיא רמה מעל DEBUG. מכיוון שאנו מתכוונים להשתמש במודול logging למטרות דיבוג בדוגמה זו, אנו צריכים לשנות את ההגדרות כך שרמת logging.DEBUG תחזיר מידע לקונסול עבורנו. אנו יכולים לעשות זאת על ידי הוספת השורה הבאה מתחת להצהובת שייבא:

import logging

logging.basicConfig(level=logging.DEBUG)


class Pizza():
...

רמת זו של logging.DEBUG מתייחסת לערך שלם קבוע שאנו מתייחסים אליו בקוד למעלה כדי להגדיר את הסף. רמת DEBUG היא 10.

כעת, נחליף את כל הצהובות print() בצהובות logging.debug(). להבדיל מlogging.DEBUG שהיא קבועה, logging.debug() היא שיטת המודול logging. כשאנו עובדים עם שיטה זו, אנו יכולים להשתמש באותו מחרוזת שנשלחה לprint(), כמצויין בהמשך:

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()

בנקודה זו, כאשר אנו מפעילים את התוכנית עם הפקודה python pizza.py, נקבל את הפלט הבא:

Output
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)

ההודעות בקובץ הלוג יש רמת חומרה DEBUG, כמו גם המילה root מוטמעת בהם, המתייחסת לרמת הרכיב שלך בפייתון. המודול logging יכול להיות בשימוש עם מודולים במינייה של לוגרים שיש להם שמות שונים, כך שתוכל להשתמש בלוגר שונה לכל אחד מהמודולים שלך.

לדוגמה, תוכל להגדיר לוגרים שווים ללוגרים שונים שיש להם שמות שונים ופלט שונה:

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

logger1.debug("Module 1 debugger")
logger2.debug("Module 2 debugger")

Output
DEBUG:module_1:Module 1 debugger
DEBUG:module_2:Module 2 debugger

עכשיו שיש לנו הבנה כיצד להשתמש במודול logging כדי להדפיס הודעות למסוף, בוא נמשיך להשתמש במודול logging כדי להדפיס הודעות לקובץ.

הדפסת הודעות לקובץ

המטרה העיקרית של מודול logging היא ליילוג הודעות לקובץ במקום למסוף. שמירה על קובץ של הודעות מספקת לך מידע לאורך זמן שתוכל להתייעץ ולכמת כך שתוכל לראות אילו שינויים יש לבצע בקוד שלך.

כדי להתחיל להילוג לקובץ, נוכל לשנות את השיטה logging.basicConfig() כדי לכלול פרמטר filename. במקרה זה, נקרא לקובץ test.log:

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("artichoke", 15)
pizza_01.make()
pizza_01.eat()

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

הקוד לעיל זהה למה שהיה בקטע הקוד הקודם, רק שעכשיו הוספנו את שם הקובץ ללוג להדפסה. לאחר הרצת הקוד עם הפקודה python pizza.py, צריך להיות לנו קובץ חדש בתיקייתנו בשם test.log.

בואו נפתח את קובץ test.log עם nano (או עם עורך הטקסט שתבחרו):

nano 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)

זה דומה לפלט הקונסול שנתקלנו בו בסעיף הקודם, רק שכעת הוא נמצא בקובץ test.log

בואו נסגור את הקובץ עם CTRL + x ונחזור לקובץ pizza.py כדי שנוכל לשנות את הקוד.

נשאיר את רוב הקוד זהה, אך נשנה את הפרמטרים בשני מופעי הפיצה, pizza_01 ו-pizza_02:

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_01 = Pizza("Sicilian", 18)
pizza_01.make(5)
pizza_01.eat(4)

# שינוי הפרמטרים של אובייקט pizza_02
pizza_02 = Pizza("quattro formaggi", 16)
pizza_02.make(2)
pizza_02.eat(2)

עם השינויים הללו, בואו נריץ את התוכנית שוב עם פקודת python pizza.py.

כאשר התוכנית תסתיים לרוץ, ניתן לפתוח שוב את קובץ ה-log שלנו, test.log, עם nano:

nano 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)
DEBUG: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)

על אף שהמידע הזה מועיל בוודאות, אנו יכולים לשפר את היומן על ידי הוספת מאפייני LogRecord נוספים. בעיקר, נרצה להוסיף חותמת זמן שניתן לקרוא באופן אנושי שאומרת לנו מתי נוצר ה-LogRecord.

נוכל להוסיף את התכונה הזו לפרמטר בשם format, ולהתייחס אליה כפי שמוצג בטבלה עם המחרוזת %(asctime)s. בנוסף, כדי לשמור על שם רמת השגיאה DEBUG, נצטרך לכלול את המחרוזת %(levelname)s, וכדי לשמור על ההודעה שאנו מבקשים מהלוגר להדפיס נכליל %(message)s. כל אחת מהתכונות הללו תהיה מופרדת בסימן colon, כפי שמוצג בקוד המוסף:

import logging

logging.basicConfig(
    filename="test.log",
    level=logging.DEBUG,
    format="%(asctime)s:%(levelname)s:%(message)s"
    )


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)

כאשר אנו מפעילים את הקוד למעלה עם התכונות המוספות עם הפקודה python pizza.py, נקבל שורות חדשות המתווספות לקובץ ה- test.log שלנו שכוללות את הגלגול הזמן הנקרא בנוסף לשם רמת השגיאה DEBUG וההודעות המשוייכות שמועברות אל הלוגר כמחרוזות.

DEBUG: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)
2021-08-19 23:31:34,484:DEBUG:Pizza created: Sicilian ($18)
2021-08-19 23:31:34,484:DEBUG:Made 5 Sicilian pizza(s)
2021-08-19 23:31:34,484:DEBUG:Ate 4 pizza(s)
2021-08-19 23:31:34,484:DEBUG:Pizza created: quattro formaggi ($16)
2021-08-19 23:31:34,484:DEBUG:Made 2 quattro formaggi pizza(s)
2021-08-19 23:31:34,484:DEBUG:Ate 2 pizza(s)

לפי הצורך שלך, עשוי להיות שתרצה להשתמש בתכונות נוספות של רשומת לוג בקוד שלך כדי להבטיח שהלוגים של קבצי התוכנית שלך יהיו רלוונטיים עבורך.

לוגים של דיבאג והודעות אחרות לקבצים נפרדים מאפשרים לך להבין את התוכנית שלך בפיתוח של פייתון לאורך זמן, ומעניקים לך את ההזדמנות לאתר ולשנות את הקוד שלך באופן המבוסס על העבודה ההיסטורית שהושקעה בתוכנית, כמו גם על האירועים והעסקאות שקורות.

טבלת רמות הלוג

כמפתח, אתה יכול להקצות רמת חשיבות לאירוע שמתפס בלוגר על ידי הוספת רמת חומרה. רמות החומרה מוצגות בטבלה למטה.

רמות הלוגינג הן בעצם מספרים שלמים (קבוע), והם כלם בצעדי 10, התחלה עם NOTSET שמאתחל את הלוגר לערך המספרי 0.

אתה יכול גם להגדיר רמות משלך יחסית לרמות המוגדרות מראש. אם אתה מגדיר רמה עם אותו ערך מספרי, תחליף את השם המשויך לערך זה.

הטבלה הבאה מציגה את שמות הרמות השונים, הערך המספרי שלהם, איזה פונקציה ניתן להשתמש בה כדי לקרוא לרמה, ולמה משמשת הרמה הזו.

מודול ה־logging מגדיר את הרמה המוגדרת מראש ברמת WARNING, לכן WARNING, ERROR ו־CRITICAL יירשמו ברירת מחדל. בדוגמה למעלה, שינינו את ההגדרה כדי לכלול את רמת ה־DEBUG עם הקוד הבא:

logging.basicConfig(level=logging.DEBUG)

ניתן לקרוא עוד על הפקודות ועל עבודה עם הדבוגר מתוך תיעוד ה־logging הרשמי.

מסקנה

ניפוי תקלות הוא שלב חשוב בכל פרויקט פיתוח תוכנה. המודול logging הוא חלק מספריית הפייתון הסטנדרטית, מספק מעקב אחר אירועים שמתרחשים בעת פעולת התוכנה, ויכול להוציא את האירועים הללו לקובץ יומן נפרד כדי לאפשר לך לעקוב אחר מה שקורה בזמן ריצת הקוד שלך. זה נותן לך את ההזדמנות לנפות תקלות בקוד שלך על בסיס הבנת האירועים השונים שמתרחשים מריצת התוכנית שלך לאורך זמן.