Jurnal yazmaq: logging modulu

Niyə `print` kifayət deyil: səviyyələr, `basicConfig` və formatlar, logger, handler və formatter, `getLogger(__name__)` ilə logger iyerarxiyası, fayla yazmaq və `RotatingFileHandler`, `logger.exception`, `dictConfig` ilə konfiqurasiya və jurnala nə yazmamaq lazımdır.

  • İrəli
  • 22 dəq
  • 12 sual
  • 66 dərsdən 33-cüsü

Bu dərsdə öyrənəcəksən

  • Mesaj üçün düzgün səviyyə seçmək və səviyyə süzgəcinin necə işlədiyini izah etmək
  • Logger, handler və formatter-i birləşdirmək: konsol və fayl üçün müxtəlif səviyyələr
  • İstisnaları logger.exception ilə yazmaq və jurnal fayllarını növbələmək
  • Tətbiqin jurnalını bir yerdə, dictConfig ilə qurmaq

Hesabat skripti hər gecə saat 3-də serverdə işləyir. Bir səhər hesabat yoxdur. Nə baş verib? print ilə yazılan mesajlar heç kimin baxmadığı ekrana gedib və itib. Əgər skript jurnal (log) yazsaydı, faylda belə sətir olardı: 2026-10-02 03:00:05 ERROR report: database is locked. logging modulu Python-un standart jurnal sistemidir; «Avtomatlaşdırma skriptləri» dərsində onunla ilk dəfə tanış oldun, indi onu bütün imkanları ilə öyrənəcəyik.

  • Səviyyələr: əhəmiyyətsiz mesajları kodu dəyişmədən söndürmək olar.
  • Kontekst: vaxt, modul, funksiya və sətir nömrəsi avtomatik əlavə olunur.
  • Təyinat yerləri: eyni mesaj ekrana, fayla, poçta və ya serverə gedə bilər.
  • Bir yerdən idarə: kitabxanalar jurnal yazır, onu necə göstərmək isə tətbiq qərar verir.

Səviyyələr

SəviyyəƏdədNə vaxt
DEBUG10proqramçı üçün təfərrüatlar: dəyişənlər, addımlar
INFO20normal gediş: «hesabat başladı», «118 fayl köçürüldü»
WARNING30qeyri-adi, amma iş davam edir
ERROR40əməliyyat alınmadı
CRITICAL50proqram işləməyə davam edə bilmir
record is shown ⇔ level(record) ≥ level(logger) and level(record) ≥ level(handler)

Burada

level(record)
mesajın səviyyəsi: log.info → 20
level(logger)
logger-in effektiv səviyyəsi (özününkü və ya ən yaxın valideyninki)
level(handler)
mesajı çıxaran handler-in səviyyəsi

Səviyyə həddi aşağı salındıqca daha çox mesaj görünür. Root logger-in susmaya görə səviyyəsi WARNING-dir, ona görə konfiqurasiyasız info görünmür.

Python
import logging
import sys

logging.basicConfig(stream=sys.stdout, format='%(levelname)-8s| %(message)s', force=True)
log = logging.getLogger('demo')

for level in (logging.DEBUG, logging.INFO, logging.WARNING):
    log.setLevel(level)
    print(f'--- logger level {logging.getLevelName(level)} ({level})')
    log.debug('details for developers')
    log.info('normal progress')
    log.warning('something unusual')
Gözlənilən nəticə
--- logger level DEBUG (10)
DEBUG   | details for developers
INFO    | normal progress
WARNING | something unusual
--- logger level INFO (20)
INFO    | normal progress
WARNING | something unusual
--- logger level WARNING (30)
WARNING | something unusual
Brauzerdə çıxış görünsün deyə stream=sys.stdout yazırıq (susmaya görə jurnal stderr-ə gedir), force=True isə əvvəlki işə salmalardan qalan konfiqurasiyanı əvəz edir.

Mesajı f-sətirlə yox, %s yer tutucuları və ayrıca arqumentlərlə yaz: log.info('copied %d files', n). Mətn yalnız mesaj həqiqətən çıxarılanda qurulur, jurnal analiz alətləri isə eyni şablonlu mesajları qruplaşdıra bilir:

Python
import logging
import sys

logging.basicConfig(stream=sys.stdout, format='%(levelname)s %(message)s', force=True)
log = logging.getLogger('lazy')
log.setLevel(logging.INFO)


class Report:
    def __str__(self):
        print('  (building a long text...)')
        return 'big report'


log.debug('data: %s', Report())        # below INFO: the text is never built
log.debug(f'data: {Report()}')         # the f-string is built anyway
log.info('data: %s', Report())         # shown, so it is built once
Gözlənilən nəticə
  (building a long text...)
  (building a long text...)
INFO data: big report
Birinci debug mətni heç qurmadı, f-sətir isə mesaj atılsa da qurdu. Böyük obyektlərdə və tez-tez çağırılan kodda bu, nəzərəçarpan fərqdir.

Davamını oxumaq üçün pulsuz qeydiyyatdan keç

Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.

basicConfig və formatlar

logging.basicConfig(...) ən sadə quraşdırmadır: root logger-ə bir handler və formatter əlavə edir. O, yalnız bir dəfə işləyir — root-un artıq handler-i varsa, sonrakı çağırışlar heç nə etmir (əgər force=True deyilsə). Ona görə onu proqramın girişində, if __name__ == '__main__': blokunda çağır. Format sətrində %(ad)s şəklində sahələr olur:

SahəNə yazır
%(asctime)svaxt (formatı datefmt ilə)
%(levelname)ssəviyyənin adı
%(name)slogger-in adı
%(module)s, %(funcName)s, %(lineno)dmodul, funksiya, sətir nömrəsi
%(message)smesajın özü
Python
import logging

logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s %(levelname)s [%(name)s] %(funcName)s:%(lineno)d %(message)s',
    datefmt='%Y-%m-%d %H:%M:%S',
)
log = logging.getLogger('shop')


def checkout(total):
    log.info('checkout total=%.2f', total)


checkout(42.5)

Gözlənilən nəticə

2026-10-03 17:38:15 INFO [shop] checkout:12 checkout total=42.50
Burada stream verilməyib, ona görə jurnal stderr-ə gedir. Vaxt işə saldığın anı göstərəcək, sətir nömrəsi 12 isə log.info sətridir.

Logger, handler, formatter

Logger, handler və formatterTərif

Logger — kodun mesaj göndərdiyi adlı obyekt (logging.getLogger('shop.orders')); eyni ad həmişə eyni obyekti qaytarır. Handler mesajı təyinat yerinə aparır: StreamHandler — konsol, FileHandler — fayl, RotatingFileHandler — növbələnən fayllar. Formatter qeydi mətn sətrinə çevirir. Hər handler-in öz səviyyəsi və formatter-i ola bilər.

log.info('order 17')Logger 'shop.orders'INFO ≥ logger-in səviyyəsi?StreamHandlersəviyyə: WARNINGFileHandlersəviyyə: DEBUGFormatter→ ekranFormatter→ app.log faylısonra qeyd valideynlərə ötürülür:shop → root (propagate)

Logger adları nöqtələrlə iyerarxiya qurur: shop.orders shop-un uşağıdır, shop isə root-un. Logger-in öz səviyyəsi yoxdursa (NOTSET), ən yaxın valideynin səviyyəsini götürür. Qeyd əvvəlcə öz handler-lərinə, sonra (propagate = True olduqca) valideynlərin handler-lərinə gedir — valideynlərin səviyyəsi bu zaman yenidən yoxlanılmır. Ona görə hər modulda log = logging.getLogger(__name__) yazılır: logger-in adı modulun adı olur (shop.orders), iyerarxiya isə paketlərin quruluşunu təkrarlayır.

Python
import logging
import sys

logging.basicConfig(stream=sys.stdout, level=logging.WARNING,
                    format='%(name)-14s %(levelname)-7s %(message)s', force=True)
logging.getLogger('shop').setLevel(logging.INFO)

orders = logging.getLogger('shop.orders')
payments = logging.getLogger('shop.payments')
print(orders.parent.name, orders.getEffectiveLevel(), payments.getEffectiveLevel())

orders.info('order 17 created')
payments.debug('card check details')
logging.getLogger('emails').info('newsletter sent')
logging.getLogger('emails').warning('mailbox full')
Gözlənilən nəticə
shop 20 20
shop.orders    INFO    order 17 created
emails         WARNING mailbox full
Root-un səviyyəsi WARNING-dir, amma shop.orders-in INFO mesajı root-un handler-i ilə çap olundu: səviyyə yalnız mesajın yarandığı logger-də (effektiv səviyyə 20) yoxlanılır. emails-in səviyyəsi root-dan gəlir (30), ona görə onun info-su atıldı.

İndi handler-ləri əl ilə quraq: konsola yalnız xəbərdarlıqlar, fayla isə hər şey getsin. propagate = False mesajın root-a da çatıb ikinci dəfə çap olunmasının qarşısını alır:

Python
import logging
import sys

log = logging.getLogger('nightly')
log.setLevel(logging.DEBUG)
log.propagate = False
log.handlers.clear()                 # so that running the code again adds no duplicates

console = logging.StreamHandler(sys.stdout)
console.setLevel(logging.WARNING)
console.setFormatter(logging.Formatter('CONSOLE %(levelname)s: %(message)s'))

file = logging.FileHandler('nightly.log', mode='w', encoding='utf-8')
file.setLevel(logging.DEBUG)
file.setFormatter(logging.Formatter('%(levelname)-7s %(name)s %(message)s'))

log.addHandler(console)
log.addHandler(file)
log.debug('found 120 files')
log.info('copied 118 files')
log.warning('2 files skipped: permission denied')
file.close()

print('--- nightly.log:')
print(open('nightly.log', encoding='utf-8').read(), end='')
Gözlənilən nəticə
CONSOLE WARNING: 2 files skipped: permission denied
--- nightly.log:
DEBUG   nightly found 120 files
INFO    nightly copied 118 files
WARNING nightly 2 files skipped: permission denied

İstisnalar və jurnal faylları

except blokunun içində log.exception('...') mesajı ERROR səviyyəsində yazır və ona tam traceback-i əlavə edir — xətanın harada baş verdiyini sonra jurnaldan görmək olur. Başqa səviyyələrdə eyni şeyi exc_info=True edir: log.warning('...', exc_info=True). Proqram istisnanı tutub işini davam etdirir («Xətaların idarə olunması: try və except» dərsinə bax):

Python
import logging

logging.basicConfig(level=logging.INFO, format='%(levelname)s %(name)s: %(message)s')
log = logging.getLogger('orders')


def average(total, count):
    return total / count


try:
    average(120, 0)
except ZeroDivisionError:
    log.exception('could not compute the average for order %d', 17)
log.info('the program keeps running')

Gözlənilən nəticə

ERROR orders: could not compute the average for order 17
Traceback (most recent call last):
  File "orders.py", line 12, in <module>
    average(120, 0)
    ~~~~~~~^^^^^^^^
  File "orders.py", line 8, in average
    return total / count
           ~~~~~~^~~~~~~
ZeroDivisionError: division by zero
INFO orders: the program keeps running
File "..." sətirlərində faylın yolu onun harada saxlandığından asılıdır; brauzerdə bu ad <exec> olur.

Daim işləyən proqramın jurnal faylı diski doldura bilər. logging.handlers.RotatingFileHandler fayl maxBytes həddinə çatanda onu app.log.1 adlandırır (köhnələr .2, .3 olur) və yeni fayl açır; backupCount neçə köhnə faylın saxlanacağını göstərir. TimedRotatingFileHandler isə faylları vaxta görə, məsələn hər gecə dəyişir.

Python
import logging
import os
from logging.handlers import RotatingFileHandler

log = logging.getLogger('sensor')
log.setLevel(logging.INFO)
log.propagate = False
log.handlers.clear()
handler = RotatingFileHandler('sensor.log', maxBytes=300, backupCount=2, encoding='utf-8')
handler.setFormatter(logging.Formatter('%(levelname)s %(message)s'))
log.addHandler(handler)

for i in range(1, 41):
    log.info('reading %02d: temperature %.1f', i, 20 + i / 10)
handler.close()

print(sorted(name for name in os.listdir() if name.startswith('sensor.log')))
with open('sensor.log', encoding='utf-8') as f:
    print(f.readlines()[-1].strip())
Gözlənilən nəticə
['sensor.log', 'sensor.log.1', 'sensor.log.2']
INFO reading 40: temperature 24.0
40 sətir 300 baytlıq fayllara sığmadı: ən yeni qeydlər sensor.log-dadır, köhnələrin ancaq iki faylı saxlanılıb, daha köhnələr silinib.

dictConfig ilə konfiqurasiya: mini layihə

Böyük tətbiqdə jurnal ayarları kodun içinə səpələnmir: bütün formatter, handler və logger-lər bir lüğətdə təsvir olunur və proqramın girişində logging.config.dictConfig(...) ilə tətbiq edilir. Lüğəti JSON və ya YAML faylından da oxumaq olar — səviyyəni dəyişmək üçün kodu dəyişmək lazım gəlmir. 'disable_existing_loggers': False mütləq yaz: əks halda konfiqurasiyadan əvvəl yaradılmış logger-lər (məsələn, import zamanı) susdurulur. Mini layihə sifarişləri emal edir: konsola INFO, fayla DEBUG və daha çox məlumatlı format gedir:

Python
import logging
import logging.config

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'short': {'format': '%(levelname)-7s %(name)s: %(message)s'},
        'full': {'format': '%(levelname)s|%(name)s|%(funcName)s|%(message)s'},
    },
    'handlers': {
        'console': {'class': 'logging.StreamHandler', 'stream': 'ext://sys.stdout',
                    'level': 'INFO', 'formatter': 'short'},
        'file': {'class': 'logging.FileHandler', 'filename': 'store.log', 'mode': 'w',
                 'encoding': 'utf-8', 'level': 'DEBUG', 'formatter': 'full'},
    },
    'loggers': {'store': {'level': 'DEBUG', 'handlers': ['console', 'file'], 'propagate': False}},
}
logging.config.dictConfig(LOGGING)
log = logging.getLogger('store.orders')


def process(order):
    log.debug('processing %s', order)
    if order['qty'] <= 0:
        log.warning('order %s skipped: qty=%s', order['id'], order['qty'])
        return 0
    total = order['qty'] * order['price']
    log.info('order %s: %.2f AZN', order['id'], total)
    return total


orders = [{'id': 1, 'qty': 2, 'price': 4.5}, {'id': 2, 'qty': 0, 'price': 9.9},
          {'id': 3, 'qty': 1, 'price': 15.0}]
log.info('revenue %.2f AZN', sum(process(o) for o in orders))
print(open('store.log', encoding='utf-8').readline(), end='')
Gözlənilən nəticə
INFO    store.orders: order 1: 9.00 AZN
WARNING store.orders: order 2 skipped: qty=0
INFO    store.orders: order 3: 15.00 AZN
INFO    store.orders: revenue 24.00 AZN
DEBUG|store.orders|process|processing {'id': 1, 'qty': 2, 'price': 4.5}
Konsolda DEBUG yoxdur, faylın birinci sətri isə məhz DEBUG qeydidir və funksiyanın adını da göstərir. store.orders logger-inin öz handler-i yoxdur — qeydlər valideyn store-un handler-lərinə çatır.

Tapşırıq

Jurnalı elə qur ki, yalnız WARNING və daha yüksək mesajlar LEVEL: message formatında sys.stdout-a çıxsın. Mesaj yazan sətirləri dəyişmə.

Tapşırıq · Python
import logging
import sys

# configure logging here: stdout, level WARNING, format "LEVEL: message"

log = logging.getLogger('quiz')
log.debug('loading questions')
log.info('12 questions loaded')
log.warning('question 7 has no answer')
log.error('cannot save the results')
Gözlənilən nəticə
WARNING: question 7 has no answer
ERROR: cannot save the results

Tapşırıq

safe_divide(a, b) uğurda INFO səviyyəsində 10 / 4 = 2.5 yazıb nəticəni qaytarsın, b 0 olanda isə WARNING səviyyəsində cannot divide 3 by zero yazıb None qaytarsın. Mesajları %s yer tutucuları ilə qur.

Tapşırıq · Python
import logging
import sys

logging.basicConfig(stream=sys.stdout, level=logging.INFO,
                    format='%(levelname)s %(name)s: %(message)s', force=True)
log = logging.getLogger('calc')


def safe_divide(a, b):
    # on success: log INFO "10 / 4 = 2.5" and return the result
    # if b is 0: log WARNING "cannot divide 3 by zero" and return None
    return a / b


print([safe_divide(10, 4), safe_divide(3, 0)])
Gözlənilən nəticə
INFO calc: 10 / 4 = 2.5
WARNING calc: cannot divide 3 by zero
[2.5, None]

Yadda saxla

  • Səviyyələr: DEBUG 10 < INFO 20 < WARNING 30 < ERROR 40 < CRITICAL 50; root-un susmaya görə səviyyəsi WARNING-dir.
  • Hər modulda logging.getLogger(__name__); adlar nöqtə ilə iyerarxiya qurur, qeydlər valideynlərin handler-lərinə ötürülür.
  • Handler təyinat yerini və öz səviyyəsini, formatter isə sətrin görünüşünü təyin edir.
  • log.exception except içində ERROR + traceback yazır; RotatingFileHandler faylların ölçüsünü məhdudlaşdırır.
  • Konfiqurasiya bir dəfə, proqramın girişində: basicConfig və ya dictConfig (disable_existing_loggers: False); parol və şəxsi məlumat yazma.
Dərsdə səhv və ya qeyri-dəqiqlik gördün?

Özünü yoxla

12 sual. Hər düzgün cavab XP qazandırır.

Sual 1 / 12

Sual 1 / 12. Səviyyələrin artan sırası hansıdır?