programming python

Làm thế nào để bạn đếm đến 100 trong python?

Trong chương trình này, vòng lặp while được lặp đi lặp lại cho đến khi biểu thức kiểm tra

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

23 được đánh giá là 0 [sai]

Sau lần lặp đầu tiên,

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

24 sẽ được chia cho 10 và giá trị của nó sẽ là 345. Sau đó,

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

25 được tăng lên 1

Sau lần lặp thứ hai, giá trị của

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

24 sẽ là 34 và

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

25 được tăng lên 2

Sau lần lặp thứ ba, giá trị của

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

24 sẽ là 3 và

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

25 được tăng lên 3

Sau lần lặp thứ tư, giá trị của

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

24 sẽ là 0 và

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

25 được tăng lên 4

Sau đó, biểu thức kiểm tra được đánh giá là sai và vòng lặp kết thúc

ví dụ 2. Sử dụng các phương thức sẵn có

num = 123456
print[len[str[num]]]

đầu ra

Trong ví dụ trên, trước tiên chúng ta chuyển đổi giá trị số nguyên thành chuỗi bằng cách sử dụng

Number of digits: 4

3. Sau đó, chúng tôi tìm thấy độ dài của chuỗi bằng cách sử dụng

Number of digits: 4

Chương trình python này cũng thực hiện nhiệm vụ tương tự nhưng trong chương trình này, chúng tôi in từ 1 đến 100 mà không cần vòng lặp. Để giải quyết vấn đề này, chúng ta có thể sử dụng kỹ thuật đệ quy

Một phương thức chứa lời gọi đến chính nó được gọi là phương thức đệ quy. Một kỹ thuật xác định phương thức đệ quy được gọi là đệ quy. Phương pháp đệ quy cho phép chúng ta chia vấn đề phức tạp thành các trường hợp đơn giản giống hệt nhau để có thể xử lý dễ dàng. Đây cũng là một kỹ thuật lập trình máy tính nổi tiếng. phân chia và chinh phục

# Python program to print numbers from 1 to 100

def print_num[n]:
    if n > 0:
        print_num[n - 1]
        print[n, end = ' ']

print['Numbers from 1 to 100:']
print_num[100]

đầu ra. -

Số từ 1 đến 100.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

Nhận ghi chú để làm cho quá trình học tập của bạn dễ dàng. Chúng được thiết kế đặc biệt cho những người mới bắt đầu muốn học viết mã thông qua các từ, chương trình và ví dụ đơn giản. Bạn có thể sử dụng nó làm tài liệu tham khảo và cho mục đích sửa đổi

ghi chú có sẵn. - Python, Java, C/C++, DSA, SQL, HTML CSS JavaScript, v.v…

Nếu bạn thích bài đăng này, hãy chia sẻ nó với bạn bè của bạn. Bạn có muốn chia sẻ thêm thông tin về chủ đề đã thảo luận ở trên hay bạn có thấy điều gì không đúng không? . Cảm ơn bạn

Nhiều cuộc gọi đến

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

02 trả về một tham chiếu đến cùng một đối tượng logger. Điều này đúng không chỉ trong cùng một mô-đun mà còn trên các mô-đun miễn là nó nằm trong cùng một quy trình thông dịch Python. Nó đúng với các tham chiếu đến cùng một đối tượng; . Đây là một mô-đun chính

import logging
import auxiliary_module

# create logger with 'spam_application'
logger = logging.getLogger['spam_application']
logger.setLevel[logging.DEBUG]
# create file handler which logs even debug messages
fh = logging.FileHandler['spam.log']
fh.setLevel[logging.DEBUG]
# create console handler with a higher log level
ch = logging.StreamHandler[]
ch.setLevel[logging.ERROR]
# create formatter and add it to the handlers
formatter = logging.Formatter['%[asctime]s - %[name]s - %[levelname]s - %[message]s']
fh.setFormatter[formatter]
ch.setFormatter[formatter]
# add the handlers to the logger
logger.addHandler[fh]
logger.addHandler[ch]

logger.info['creating an instance of auxiliary_module.Auxiliary']
a = auxiliary_module.Auxiliary[]
logger.info['created an instance of auxiliary_module.Auxiliary']
logger.info['calling auxiliary_module.Auxiliary.do_something']
a.do_something[]
logger.info['finished auxiliary_module.Auxiliary.do_something']
logger.info['calling auxiliary_module.some_function[]']
auxiliary_module.some_function[]
logger.info['done with auxiliary_module.some_function[]']

Đây là mô-đun phụ trợ

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Đầu ra trông như thế này

________số 8

Ghi nhật ký từ nhiều luồng¶

Ghi nhật ký từ nhiều luồng không yêu cầu nỗ lực đặc biệt. Ví dụ sau hiển thị ghi nhật ký từ luồng chính [ban đầu] và luồng khác

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Khi chạy, tập lệnh sẽ in một cái gì đó như sau

Điều này cho thấy đầu ra ghi nhật ký xen kẽ như người ta có thể mong đợi. Tất nhiên, cách tiếp cận này hoạt động cho nhiều chủ đề hơn được hiển thị ở đây

Nhiều trình xử lý và trình định dạng¶

Logger là các đối tượng Python đơn giản. Phương pháp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

03 không có hạn ngạch tối thiểu hoặc tối đa cho số lượng trình xử lý mà bạn có thể thêm. Đôi khi, một ứng dụng sẽ có lợi khi ghi tất cả các thông báo ở mọi mức độ nghiêm trọng vào một tệp văn bản đồng thời ghi các lỗi trở lên vào bảng điều khiển. Để thiết lập điều này, chỉ cần định cấu hình trình xử lý thích hợp. Các cuộc gọi đăng nhập trong mã ứng dụng sẽ không thay đổi. Đây là một sửa đổi nhỏ đối với ví dụ cấu hình dựa trên mô-đun đơn giản trước đó

Lưu ý rằng mã 'ứng dụng' không quan tâm đến nhiều trình xử lý. Tất cả những gì đã thay đổi là việc bổ sung và cấu hình một trình xử lý mới có tên fh

Khả năng tạo trình xử lý mới với bộ lọc mức độ nghiêm trọng cao hơn hoặc thấp hơn có thể rất hữu ích khi viết và thử nghiệm ứng dụng. Thay vì sử dụng nhiều câu lệnh

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

04 để gỡ lỗi, hãy sử dụng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

05. Không giống như các báo cáo in mà bạn sẽ phải xóa hoặc nhận xét sau này, trình ghi nhật ký. các câu lệnh gỡ lỗi có thể vẫn còn nguyên vẹn trong mã nguồn và không hoạt động cho đến khi bạn cần lại chúng. Vào thời điểm đó, thay đổi duy nhất cần thực hiện là sửa đổi mức độ nghiêm trọng của trình ghi nhật ký và/hoặc trình xử lý để gỡ lỗi

Đăng nhập vào nhiều đích¶

Giả sử bạn muốn đăng nhập vào bảng điều khiển và tệp với các định dạng thông báo khác nhau và trong các trường hợp khác nhau. Giả sử bạn muốn ghi các thư có mức GỠ LỖI trở lên vào tệp và các thư đó ở mức INFO trở lên vào bảng điều khiển. Chúng ta cũng giả sử rằng tệp phải chứa dấu thời gian, nhưng thông báo trên bảng điều khiển thì không. Đây là cách bạn có thể đạt được điều này

Khi bạn chạy cái này, trên bảng điều khiển, bạn sẽ thấy

và trong tệp bạn sẽ thấy một cái gì đó giống như

Như bạn có thể thấy, thông báo GỠ LỖI chỉ hiển thị trong tệp. Các tin nhắn khác được gửi đến cả hai đích

Ví dụ này sử dụng bảng điều khiển và trình xử lý tệp, nhưng bạn có thể sử dụng bất kỳ số lượng và tổ hợp trình xử lý nào bạn chọn

Lưu ý rằng lựa chọn tên tệp nhật ký ở trên

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

06 ngụ ý việc sử dụng một vị trí tiêu chuẩn cho các tệp tạm thời trên hệ thống POSIX. Trên Windows, bạn có thể cần chọn một tên thư mục khác cho nhật ký - chỉ cần đảm bảo rằng thư mục đó tồn tại và bạn có quyền tạo và cập nhật các tệp trong đó

Xử lý tùy chỉnh các cấp¶

Đôi khi, bạn có thể muốn thực hiện điều gì đó hơi khác so với cách xử lý tiêu chuẩn của các cấp trong trình xử lý, trong đó tất cả các cấp trên ngưỡng đều được xử lý bởi một trình xử lý. Để làm điều này, bạn cần sử dụng các bộ lọc. Hãy xem xét một tình huống mà bạn muốn sắp xếp mọi thứ như sau

Gửi tin nhắn có mức độ nghiêm trọng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

07 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

08 đến

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Gửi tin nhắn có mức độ nghiêm trọng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

10 trở lên tới

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Gửi tin nhắn có mức độ nghiêm trọng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

12 trở lên tới tệp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Giả sử bạn định cấu hình ghi nhật ký bằng JSON sau đây

Number of digits: 4

Cấu hình này thực hiện gần như những gì chúng ta muốn, ngoại trừ việc

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

09 sẽ hiển thị các thông báo có mức độ nghiêm trọng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

10 trở lên cũng như các thông báo

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

07 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

08. Để ngăn chặn điều này, chúng tôi có thể thiết lập bộ lọc loại trừ các thư đó và thêm nó vào trình xử lý có liên quan. Điều này có thể được định cấu hình bằng cách thêm phần

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

18 song song với

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

19 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

và thay đổi phần trên trình xử lý

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

21 để thêm nó

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Bộ lọc chỉ là một chức năng, vì vậy chúng ta có thể định nghĩa

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

22 [một chức năng xuất xưởng] như sau

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Điều này chuyển đổi đối số chuỗi được truyền vào thành một mức số và trả về một hàm chỉ trả về

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

23 nếu mức của bản ghi được truyền vào bằng hoặc thấp hơn mức đã chỉ định. Lưu ý rằng trong ví dụ này, tôi đã xác định

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

22 trong tập lệnh thử nghiệm

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

25 mà tôi chạy từ dòng lệnh, vì vậy mô-đun của nó sẽ là

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

26 - do đó,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

27 trong cấu hình bộ lọc. Bạn sẽ cần thay đổi điều đó nếu bạn xác định nó trong một mô-đun khác

Với bộ lọc được thêm vào, chúng tôi có thể chạy

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

25, đầy đủ là

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Và sau khi chạy nó như thế này

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Chúng ta có thể thấy kết quả như mong đợi

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Ví dụ máy chủ cấu hình¶

Dưới đây là một ví dụ về mô-đun sử dụng máy chủ cấu hình ghi nhật ký

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Và đây là một tập lệnh lấy tên tệp và gửi tệp đó đến máy chủ, được đặt trước đúng độ dài được mã hóa nhị phân, làm cấu hình ghi nhật ký mới

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Xử lý các trình xử lý chặn¶

Đôi khi, bạn phải yêu cầu trình xử lý ghi nhật ký của mình thực hiện công việc của họ mà không chặn luồng mà bạn đang ghi nhật ký. Điều này phổ biến trong các ứng dụng web, mặc dù tất nhiên nó cũng xảy ra trong các tình huống khác

Một thủ phạm phổ biến thể hiện hành vi chậm chạp là

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

29. việc gửi email có thể mất nhiều thời gian, vì một số lý do ngoài tầm kiểm soát của nhà phát triển [ví dụ: cơ sở hạ tầng mạng hoặc thư hoạt động kém]. Nhưng hầu hết mọi trình xử lý dựa trên mạng đều có thể chặn. Ngay cả một hoạt động của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

30 cũng có thể thực hiện một truy vấn DNS ngầm, quá chậm [và truy vấn này có thể nằm sâu trong mã thư viện ổ cắm, bên dưới lớp Python và nằm ngoài tầm kiểm soát của bạn]

Một giải pháp là sử dụng cách tiếp cận hai phần. Đối với phần đầu tiên, chỉ đính kèm một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

31 vào những bộ ghi nhật ký được truy cập từ các luồng quan trọng về hiệu suất. Họ chỉ cần ghi vào hàng đợi của mình, hàng đợi này có thể được định cỡ theo dung lượng đủ lớn hoặc được khởi tạo mà không có giới hạn trên đối với kích thước của họ. Việc ghi vào hàng đợi thường sẽ được chấp nhận nhanh chóng, mặc dù bạn có thể cần phải nắm bắt ngoại lệ

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

32 để đề phòng trong mã của mình. Nếu bạn là nhà phát triển thư viện có các luồng quan trọng về hiệu suất trong mã của họ, hãy đảm bảo ghi lại điều này [cùng với đề xuất chỉ đính kèm

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

33 vào trình ghi nhật ký của bạn] vì lợi ích của các nhà phát triển khác, những người sẽ sử dụng mã của bạn

Phần thứ hai của giải pháp là

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

34, được thiết kế để đối trọng với

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

31. Một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

34 rất đơn giản. nó đã vượt qua một hàng đợi và một số trình xử lý, đồng thời kích hoạt một luồng nội bộ lắng nghe hàng đợi của nó đối với LogRecords được gửi từ

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

33 [hoặc bất kỳ nguồn nào khác của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

38, đối với vấn đề đó].

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

38 được xóa khỏi hàng đợi và được chuyển đến trình xử lý để xử lý

Ưu điểm của việc có một lớp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

34 riêng biệt là bạn có thể sử dụng cùng một thể hiện để phục vụ nhiều

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

33. Điều này thân thiện với tài nguyên hơn so với việc có các phiên bản luồng của các lớp trình xử lý hiện có, sẽ chiếm một luồng cho mỗi trình xử lý mà không có lợi ích cụ thể nào

Sau đây là một ví dụ về việc sử dụng hai lớp này [bỏ qua phần nhập]

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

mà, khi chạy, sẽ tạo ra

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Ghi chú

Mặc dù cuộc thảo luận trước đó không nói cụ thể về mã không đồng bộ mà là về trình xử lý ghi nhật ký chậm, cần lưu ý rằng khi ghi nhật ký từ mã không đồng bộ, mạng và thậm chí cả trình xử lý tệp có thể dẫn đến sự cố [chặn vòng lặp sự kiện] do một số thao tác ghi nhật ký bị lỗi . Có thể tốt nhất, nếu bất kỳ mã không đồng bộ nào được sử dụng trong một ứng dụng, sử dụng phương pháp trên để ghi nhật ký, sao cho bất kỳ mã chặn nào chỉ chạy trong luồng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Đã thay đổi trong phiên bản 3. 5. Trước Python 3. 5,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

34 luôn chuyển mọi thông báo nhận được từ hàng đợi tới mọi trình xử lý mà nó được khởi tạo với. [Điều này là do người ta cho rằng tất cả quá trình lọc mức đã được thực hiện ở phía bên kia, nơi hàng đợi được lấp đầy. ] từ 3. 5 trở đi, hành vi này có thể được thay đổi bằng cách chuyển đối số từ khóa

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

45 tới hàm tạo của người nghe. Khi điều này được thực hiện, người nghe sẽ so sánh cấp độ của từng thông báo với cấp độ của trình xử lý và chỉ chuyển một thông báo tới một trình xử lý nếu điều đó phù hợp để làm như vậy.

Gửi và nhận các sự kiện ghi nhật ký qua mạng¶

Giả sử bạn muốn gửi các sự kiện ghi nhật ký qua mạng và xử lý chúng ở đầu nhận. Một cách đơn giản để thực hiện việc này là đính kèm một phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

30 vào bộ ghi gốc ở đầu gửi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Ở đầu nhận, bạn có thể thiết lập bộ thu bằng mô-đun

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

47. Đây là một ví dụ làm việc cơ bản

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Đầu tiên chạy máy chủ, sau đó là máy khách. Về phía máy khách, không có gì được in trên bảng điều khiển;

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Lưu ý rằng có một số vấn đề bảo mật với dưa chua trong một số tình huống. Nếu những điều này ảnh hưởng đến bạn, bạn có thể sử dụng sơ đồ tuần tự hóa thay thế bằng cách ghi đè phương thức

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

48 và triển khai giải pháp thay thế của bạn ở đó, cũng như điều chỉnh tập lệnh trên để sử dụng tuần tự hóa thay thế của bạn

Chạy trình lắng nghe ổ ghi nhật ký trong sản xuất¶

Để chạy trình lắng nghe ghi nhật ký trong sản xuất, bạn có thể cần sử dụng công cụ quản lý quy trình, chẳng hạn như Người giám sát. Đây là Gist cung cấp các tệp cơ bản để chạy chức năng trên bằng Trình giám sát. Nó bao gồm các tập tin sau

Tập tin

Mục đích

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Một tập lệnh Bash để chuẩn bị môi trường cho thử nghiệm

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Tệp cấu hình Trình giám sát, có các mục dành cho trình nghe và ứng dụng web đa quy trình

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Tập lệnh Bash để đảm bảo rằng Trình giám sát đang chạy với cấu hình trên

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Chương trình nghe ổ cắm nhận các sự kiện nhật ký và ghi chúng vào một tệp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Một ứng dụng web đơn giản thực hiện ghi nhật ký qua ổ cắm được kết nối với trình nghe

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Tệp cấu hình JSON cho ứng dụng web

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Một tập lệnh Python để thực hiện ứng dụng web

Ứng dụng web sử dụng Gunicorn, một máy chủ ứng dụng web phổ biến khởi động nhiều quy trình công nhân để xử lý các yêu cầu. Thiết lập ví dụ này cho thấy cách các công nhân có thể ghi vào cùng một tệp nhật ký mà không xung đột với nhau - tất cả đều đi qua trình nghe ổ cắm

Để kiểm tra các tệp này, hãy làm như sau trong môi trường POSIX

Tải xuống Gist dưới dạng kho lưu trữ ZIP bằng nút Tải xuống ZIP .
Giải nén các tệp trên từ kho lưu trữ vào thư mục đầu

Trong thư mục đầu, hãy chạy

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

56 để chuẩn bị mọi thứ. Điều này tạo ra một thư mục con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

57 để chứa các tệp nhật ký và liên quan đến Người giám sát, và một thư mục con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

58 để chứa một môi trường ảo trong đó

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

59,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

60 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

61 được cài đặt

Chạy

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

62 để đảm bảo rằng Người giám sát đang chạy với cấu hình trên

Chạy

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

63 để chạy ứng dụng web, điều này sẽ dẫn đến các bản ghi được ghi vào nhật ký

Kiểm tra các tệp nhật ký trong thư mục con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

57. Bạn sẽ thấy các dòng nhật ký gần đây nhất trong các tệp khớp với mẫu

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

65. Chúng sẽ không theo bất kỳ thứ tự cụ thể nào, vì chúng đã được xử lý đồng thời bởi các worker process khác nhau theo cách không xác định

Bạn có thể tắt trình nghe và ứng dụng web bằng cách chạy

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Bạn có thể cần chỉnh sửa các tệp cấu hình trong trường hợp không chắc là các cổng được định cấu hình xung đột với thứ gì đó khác trong môi trường thử nghiệm của bạn

Thêm thông tin theo ngữ cảnh vào đầu ra ghi nhật ký của bạn¶

Đôi khi bạn muốn đầu ra ghi nhật ký chứa thông tin theo ngữ cảnh ngoài các tham số được truyền cho lệnh gọi ghi nhật ký. Ví dụ, trong một ứng dụng nối mạng, có thể mong muốn ghi lại thông tin cụ thể của máy khách trong nhật ký [e. g. tên người dùng hoặc địa chỉ IP của khách hàng từ xa]. Mặc dù bạn có thể sử dụng tham số bổ sung để đạt được điều này, nhưng không phải lúc nào cũng thuận tiện để truyền thông tin theo cách này. Mặc dù việc tạo các phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 trên cơ sở mỗi kết nối có thể rất hấp dẫn, nhưng đây không phải là ý tưởng hay vì những phiên bản này không được thu gom rác. Mặc dù đây không phải là vấn đề trong thực tế, khi số lượng phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 phụ thuộc vào mức độ chi tiết mà bạn muốn sử dụng để ghi nhật ký ứng dụng, có thể khó quản lý nếu số lượng phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 trở nên không giới hạn

Sử dụng LoggerAdapters để truyền đạt thông tin theo ngữ cảnh¶

Một cách dễ dàng để bạn có thể chuyển thông tin theo ngữ cảnh để xuất ra cùng với thông tin sự kiện ghi nhật ký là sử dụng lớp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70. Lớp này được thiết kế trông giống như một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67, vì vậy bạn có thể gọi

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

72,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

73,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

74, ________ 575, ________ 576, ________ 577 và ________ 578. Các phương thức này có cùng chữ ký như các đối tác của chúng trong

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67, vì vậy bạn có thể sử dụng hai loại phiên bản thay thế cho nhau

Khi bạn tạo một phiên bản của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70, bạn chuyển cho nó một phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 và một đối tượng giống như dict chứa thông tin theo ngữ cảnh của bạn. Khi bạn gọi một trong các phương thức ghi nhật ký trên một phiên bản của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70, nó sẽ ủy quyền cuộc gọi cho phiên bản cơ bản của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 được truyền cho hàm tạo của nó và sắp xếp để chuyển thông tin theo ngữ cảnh trong cuộc gọi được ủy quyền. Đây là một đoạn trích từ mã của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Phương pháp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

85 của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70 là nơi thông tin theo ngữ cảnh được thêm vào đầu ra ghi nhật ký. Nó đã chuyển các đối số thông báo và từ khóa của lệnh gọi ghi nhật ký, đồng thời chuyển lại các phiên bản đã sửa đổi [có khả năng] của những đối số này để sử dụng trong lệnh gọi tới trình ghi nhật ký bên dưới. Việc triển khai mặc định của phương thức này để lại thông báo, nhưng chèn một khóa 'phụ' vào đối số từ khóa có giá trị là đối tượng giống như dict được truyền cho hàm tạo. Tất nhiên, nếu bạn đã chuyển đối số từ khóa 'phụ' trong lệnh gọi bộ điều hợp, nó sẽ bị ghi đè âm thầm

Ưu điểm của việc sử dụng 'thêm' là các giá trị trong đối tượng giống dict được hợp nhất vào __dict__ của phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87, cho phép bạn sử dụng các chuỗi tùy chỉnh với các phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88 biết về các khóa của đối tượng giống dict. Nếu bạn cần một phương pháp khác, e. g. nếu bạn muốn thêm hoặc nối thêm thông tin theo ngữ cảnh vào chuỗi tin nhắn, bạn chỉ cần phân lớp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70 và ghi đè lên

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

85 để thực hiện những gì bạn cần. Đây là một ví dụ đơn giản

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

mà bạn có thể sử dụng như thế này

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Sau đó, mọi sự kiện mà bạn đăng nhập vào bộ điều hợp sẽ có giá trị

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

91 được thêm vào trước thông báo tường trình

Sử dụng các đối tượng không phải là dicts để truyền thông tin theo ngữ cảnh¶

Bạn không cần chuyển một lệnh thực sự cho một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70 - bạn có thể chuyển một thể hiện của một lớp thực hiện

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

93 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

94 để nó trông giống như một lệnh ghi nhật ký. Điều này sẽ hữu ích nếu bạn muốn tạo các giá trị một cách linh hoạt [trong khi các giá trị trong một lệnh sẽ không đổi]

Sử dụng Bộ lọc để truyền đạt thông tin theo ngữ cảnh¶

Bạn cũng có thể thêm thông tin theo ngữ cảnh vào đầu ra nhật ký bằng cách sử dụng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 do người dùng xác định. Các phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 được phép sửa đổi

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

38 được truyền cho chúng, bao gồm thêm các thuộc tính bổ sung mà sau đó có thể xuất ra bằng cách sử dụng một chuỗi định dạng phù hợp hoặc nếu cần một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88 tùy chỉnh

Ví dụ: trong một ứng dụng web, yêu cầu đang được xử lý [hoặc ít nhất, các phần thú vị của nó] có thể được lưu trữ trong một biến threadlocal [

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

99], sau đó được truy cập từ một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 để thêm thông tin từ yêu cầu - giả sử . Trong trường hợp đó, có thể sử dụng cùng một chuỗi định dạng để có kết quả tương tự như được hiển thị ở trên. Đây là một kịch bản ví dụ

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

mà, khi chạy, tạo ra một cái gì đó giống như

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

03¶

Kể từ Python 3. 7, mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

03 đã cung cấp bộ lưu trữ ngữ cảnh cục bộ hoạt động cho cả nhu cầu xử lý

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

05 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

42. Do đó, loại lưu trữ này có thể thích hợp hơn cho luồng cục bộ. Ví dụ sau đây cho thấy cách, trong môi trường đa luồng, nhật ký có thể điền thông tin theo ngữ cảnh, chẳng hạn như các thuộc tính yêu cầu được xử lý bởi các ứng dụng web

Với mục đích minh họa, giả sử rằng bạn có các ứng dụng web khác nhau, mỗi ứng dụng độc lập với nhau nhưng chạy trong cùng một quy trình Python và sử dụng một thư viện chung cho chúng. Làm cách nào để mỗi ứng dụng này có nhật ký riêng, trong đó tất cả thông báo ghi nhật ký từ thư viện [và mã xử lý yêu cầu khác] được chuyển hướng đến tệp nhật ký của ứng dụng thích hợp, đồng thời đưa vào nhật ký thông tin theo ngữ cảnh bổ sung như IP máy khách, phương thức yêu cầu HTTP

Giả sử rằng thư viện có thể được mô phỏng bằng đoạn mã sau

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Chúng ta có thể mô phỏng nhiều ứng dụng web bằng hai lớp đơn giản,

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

07 và

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

08. Chúng mô phỏng cách thức hoạt động của các ứng dụng web theo luồng thực - mỗi yêu cầu được xử lý bởi một luồng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Nếu bạn chạy phần trên, bạn sẽ thấy rằng khoảng một nửa số yêu cầu được chuyển vào

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

09 và phần còn lại vào

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

10 và tất cả các yêu cầu được ghi vào

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

13. Mỗi nhật ký dành riêng cho ứng dụng web sẽ chỉ chứa các mục nhập nhật ký cho ứng dụng web đó và thông tin yêu cầu sẽ được hiển thị nhất quán trong nhật ký [i. e. thông tin trong mỗi yêu cầu giả sẽ luôn xuất hiện cùng nhau trong một dòng nhật ký]. Điều này được minh họa bằng đầu ra shell sau

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Truyền đạt thông tin theo ngữ cảnh trong trình xử lý¶

Mỗi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

12 có chuỗi bộ lọc riêng. Nếu bạn muốn thêm thông tin theo ngữ cảnh vào một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 mà không làm rò rỉ thông tin đó cho các trình xử lý khác, bạn có thể sử dụng bộ lọc trả về một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 mới thay vì sửa đổi nó tại chỗ, như thể hiện trong tập lệnh sau

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Ghi nhật ký vào một tệp từ nhiều quy trình¶

Mặc dù việc ghi nhật ký là an toàn theo luồng và việc ghi nhật ký vào một tệp từ nhiều luồng trong một quy trình được hỗ trợ, nhưng việc đăng nhập vào một tệp từ nhiều quy trình không được hỗ trợ vì không có cách tiêu chuẩn nào để tuần tự hóa quyền truy cập vào . Nếu bạn cần đăng nhập vào một tệp từ nhiều quy trình, một cách để thực hiện việc này là yêu cầu tất cả các quy trình đăng nhập vào một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

30 và có một quy trình riêng triển khai máy chủ ổ cắm đọc từ ổ cắm và ghi vào tệp. [Nếu muốn, bạn có thể dành riêng một luồng trong một trong các quy trình hiện có để thực hiện chức năng này. ] Phần này ghi lại phương pháp này chi tiết hơn và bao gồm bộ thu ổ cắm đang hoạt động có thể được sử dụng làm điểm bắt đầu để bạn điều chỉnh trong các ứng dụng của riêng mình.

Bạn cũng có thể viết trình xử lý của riêng mình sử dụng lớp

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

16 từ mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

17 để tuần tự hóa quyền truy cập vào tệp từ các quy trình của bạn. Hiện tại

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

18 và các lớp con không sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

17, mặc dù chúng có thể làm như vậy trong tương lai. Lưu ý rằng hiện tại, mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

17 không cung cấp chức năng khóa hoạt động trên tất cả các nền tảng [xem https. // lỗi. con trăn. org/issue3770]

Ngoài ra, bạn có thể sử dụng một

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

21 và một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

31 để gửi tất cả các sự kiện ghi nhật ký tới một trong các quy trình trong ứng dụng đa quy trình của bạn. Kịch bản ví dụ sau minh họa cách bạn có thể thực hiện việc này; . Mặc dù ví dụ này chỉ minh họa một cách thực hiện [ví dụ: bạn có thể muốn sử dụng một chuỗi trình nghe thay vì một quy trình trình nghe riêng biệt – việc triển khai sẽ tương tự] nhưng nó cho phép các cấu hình ghi nhật ký hoàn toàn khác nhau cho trình nghe và các quy trình khác

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Một biến thể của tập lệnh trên giúp ghi nhật ký trong quy trình chính, trong một chuỗi riêng biệt

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Biến thể này cho thấy cách bạn có thể. g. áp dụng cấu hình cho các logger cụ thể - e. g. bộ ghi nhật ký

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

23 có một trình xử lý đặc biệt lưu trữ tất cả các sự kiện trong hệ thống con

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

23 trong một tệp

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

25. Điều này sẽ được sử dụng bởi máy ghi nhật ký trong quy trình chính [mặc dù các sự kiện ghi nhật ký được tạo trong quy trình worker] để hướng các thông báo đến các đích thích hợp

Sử dụng đồng thời. tương lai. ProcessPoolExecutor¶

Nếu bạn muốn sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

26 để bắt đầu worker process của mình, bạn cần tạo hàng đợi hơi khác một chút. Thay vì

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

bạn nên sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

và sau đó bạn có thể thay thế việc tạo công nhân từ cái này

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

về điều này [hãy nhớ nhập

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

27 lần đầu tiên]

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Triển khai các ứng dụng Web bằng Gunicorn và uWSGI¶

Khi triển khai các ứng dụng Web bằng Gunicorn hoặc uWSGI [hoặc tương tự], nhiều worker process được tạo để xử lý các yêu cầu của máy khách. Trong những môi trường như vậy, tránh tạo trực tiếp các trình xử lý dựa trên tệp trong ứng dụng web của bạn. Thay vào đó, hãy sử dụng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

30 để ghi nhật ký từ ứng dụng web tới trình nghe trong một quy trình riêng biệt. Điều này có thể được thiết lập bằng cách sử dụng một công cụ quản lý quy trình, chẳng hạn như Người giám sát - xem Chạy trình nghe ổ cắm ghi nhật ký trong sản xuất để biết thêm chi tiết

Sử dụng xoay tệp¶

Đôi khi bạn muốn để một tệp nhật ký phát triển đến một kích thước nhất định, sau đó mở một tệp mới và đăng nhập vào đó. Bạn có thể muốn giữ một số lượng nhất định các tệp này và khi nhiều tệp đó đã được tạo, hãy xoay các tệp sao cho cả số lượng tệp và kích thước của tệp đều bị giới hạn. Đối với kiểu sử dụng này, gói ghi nhật ký cung cấp một

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Kết quả phải là 6 tệp riêng biệt, mỗi tệp có một phần lịch sử nhật ký cho ứng dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Tệp mới nhất luôn là

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

30 và mỗi khi đạt đến giới hạn kích thước, tệp sẽ được đổi tên bằng hậu tố

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

31. Mỗi tệp sao lưu hiện có được đổi tên để tăng hậu tố [

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

31 trở thành

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

33, v.v. ] và tệp

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

34 bị xóa

Rõ ràng ví dụ này đặt độ dài nhật ký quá nhỏ như một ví dụ cực đoan. Bạn sẽ muốn đặt maxBytes thành một giá trị phù hợp

Sử dụng các kiểu định dạng thay thế¶

Khi ghi nhật ký được thêm vào thư viện chuẩn Python, cách duy nhất để định dạng thư có nội dung thay đổi là sử dụng phương thức %-formatting. Kể từ đó, Python đã đạt được hai cách tiếp cận định dạng mới.

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

35 [được thêm vào Python 2. 4] và

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

36 [được thêm vào Python 2. 6]

Ghi nhật ký [kể từ ngày 3. 2] cung cấp hỗ trợ cải tiến cho hai kiểu định dạng bổ sung này. Lớp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88 đã được cải tiến để có thêm một tham số từ khóa tùy chọn có tên là

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

38. Giá trị này mặc định là

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

39, nhưng các giá trị có thể khác là

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

40 và

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

41, tương ứng với hai kiểu định dạng khác. Khả năng tương thích ngược được duy trì theo mặc định [như bạn mong đợi], nhưng bằng cách chỉ định rõ ràng một tham số kiểu, bạn có khả năng chỉ định các chuỗi định dạng hoạt động với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

36 hoặc

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

35. Đây là một phiên giao diện điều khiển ví dụ để hiển thị các khả năng

Lưu ý rằng định dạng của thông báo ghi nhật ký cho đầu ra cuối cùng của nhật ký là hoàn toàn độc lập với cách xây dựng một thông báo ghi nhật ký riêng lẻ. Điều đó vẫn có thể sử dụng định dạng%, như được hiển thị ở đây

Ghi nhật ký cuộc gọi [

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

44,

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

45, v.v. ] chỉ nhận các tham số vị trí cho chính thông báo ghi nhật ký thực tế, với các tham số từ khóa chỉ được sử dụng để xác định các tùy chọn về cách xử lý cuộc gọi ghi nhật ký thực tế [e. g. tham số từ khóa

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

46 để cho biết rằng thông tin truy nguyên phải được ghi lại hoặc tham số từ khóa

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

47 để cho biết thông tin theo ngữ cảnh bổ sung sẽ được thêm vào nhật ký]. Vì vậy, bạn không thể trực tiếp thực hiện các cuộc gọi ghi nhật ký bằng cách sử dụng cú pháp

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

36 hoặc

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

35, bởi vì bên trong gói ghi nhật ký sử dụng %-formatting để hợp nhất chuỗi định dạng và các đối số biến. Sẽ không có thay đổi này trong khi vẫn duy trì khả năng tương thích ngược, vì tất cả lệnh gọi ghi nhật ký hiện có trong mã hiện tại sẽ sử dụng chuỗi %-format

Tuy nhiên, có một cách mà bạn có thể sử dụng định dạng {}- và $- để xây dựng các thông điệp nhật ký riêng lẻ của mình. Hãy nhớ lại rằng đối với một thông báo, bạn có thể sử dụng một đối tượng tùy ý làm chuỗi định dạng thông báo và gói ghi nhật ký sẽ gọi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

50 trên đối tượng đó để lấy chuỗi định dạng thực tế. Hãy xem xét hai lớp sau

Một trong hai cách này có thể được sử dụng thay cho chuỗi định dạng, để cho phép định dạng {}- hoặc $-được sử dụng để tạo phần “thông báo” thực tế xuất hiện trong đầu ra nhật ký được định dạng thay cho “%[message]s” . Sẽ hơi khó sử dụng khi sử dụng tên lớp bất cứ khi nào bạn muốn ghi nhật ký nội dung nào đó, nhưng sẽ khá hợp lý nếu bạn sử dụng bí danh như __ [dấu gạch dưới kép — đừng nhầm với _, dấu gạch dưới đơn được sử dụng làm từ đồng nghĩa/bí danh cho

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Các lớp trên không có trong Python, mặc dù chúng đủ dễ để sao chép và dán vào mã của riêng bạn. Chúng có thể được sử dụng như sau [giả sử rằng chúng được khai báo trong một mô-đun có tên là

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

52]

Mặc dù các ví dụ trên sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

53 để hiển thị cách thức hoạt động của định dạng, nhưng tất nhiên bạn sẽ sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

44 hoặc tương tự để ghi nhật ký thực sự bằng cách sử dụng phương pháp này

Một điều cần lưu ý là bạn không phải trả tiền phạt hiệu suất đáng kể với phương pháp này. định dạng thực tế không xảy ra khi bạn thực hiện cuộc gọi ghi nhật ký, nhưng khi [và nếu] thông báo đã ghi thực sự sắp được trình xử lý xuất thành nhật ký. Vì vậy, điều hơi bất thường duy nhất có thể khiến bạn vấp ngã là các dấu ngoặc đơn bao quanh chuỗi định dạng và các đối số, không chỉ chuỗi định dạng. Đó là bởi vì ký hiệu __ chỉ là đường cú pháp cho lệnh gọi hàm tạo tới một trong các lớp XXXMessage

Nếu muốn, bạn có thể sử dụng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

70 để đạt được hiệu ứng tương tự như trên, như trong ví dụ sau

Đoạn script trên sẽ ghi thông báo

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

56 khi chạy với Python 3. 2 hoặc muộn hơn

Tùy chỉnh

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87¶

Mỗi sự kiện ghi nhật ký được đại diện bởi một phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87. Khi một sự kiện được ghi lại và không được lọc ra theo cấp độ của trình ghi nhật ký, một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 được tạo, điền thông tin về sự kiện và sau đó được chuyển đến trình xử lý cho trình ghi nhật ký đó [và tổ tiên của nó, cho đến và bao gồm cả trình ghi nhật ký tiếp tục lan truyền lên . Trước Python 3. 2, chỉ có hai nơi thực hiện sáng tạo này

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

60, được gọi trong quy trình ghi nhật ký sự kiện thông thường. Điều này đã gọi trực tiếp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 để tạo một thể hiện

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

62, được gọi với một từ điển chứa các thuộc tính sẽ được thêm vào LogRecord. Điều này thường được gọi khi một từ điển phù hợp đã được nhận qua mạng [e. g. ở dạng dưa chua thông qua

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

30 hoặc ở dạng JSON thông qua

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

64]

Điều này thường có nghĩa là nếu bạn cần làm bất cứ điều gì đặc biệt với một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87, bạn phải thực hiện một trong những điều sau

Tạo lớp con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 của riêng bạn, ghi đè lớp

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

60 và đặt nó bằng cách sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

68 trước khi bất kỳ trình ghi nhật ký nào mà bạn quan tâm được khởi tạo

Thêm một

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 vào bộ ghi hoặc trình xử lý, thực hiện thao tác đặc biệt cần thiết mà bạn cần khi phương thức

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

70 của nó được gọi

Cách tiếp cận đầu tiên sẽ hơi khó sử dụng trong trường hợp [giả sử] một số thư viện khác nhau muốn làm những việc khác nhau. Mỗi người sẽ cố gắng thiết lập phân lớp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

67 của riêng mình và phân lớp nào thực hiện việc này cuối cùng sẽ giành chiến thắng

Cách tiếp cận thứ hai hoạt động khá tốt trong nhiều trường hợp, nhưng không cho phép bạn. g. sử dụng một lớp con chuyên biệt của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87. Các nhà phát triển thư viện có thể đặt bộ lọc phù hợp trên bộ ghi nhật ký của họ, nhưng họ sẽ phải nhớ làm điều này mỗi khi giới thiệu một bộ ghi mới [họ sẽ làm điều này đơn giản bằng cách thêm các gói hoặc mô-đun mới và thực hiện

ở cấp độ mô-đun]. Nó có lẽ là một trong quá nhiều điều để suy nghĩ về. Các nhà phát triển cũng có thể thêm bộ lọc vào một

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

73 được gắn vào trình ghi nhật ký cấp cao nhất của họ, nhưng điều này sẽ không được gọi nếu một nhà phát triển ứng dụng đính kèm một trình xử lý vào một trình ghi thư viện cấp thấp hơn — vì vậy đầu ra từ trình xử lý đó sẽ không phản ánh ý định của

Trong Trăn 3. 2 trở lên, việc tạo

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 được thực hiện thông qua một nhà máy mà bạn có thể chỉ định. Nhà máy chỉ là một cái có thể gọi được mà bạn có thể đặt với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

75 và thẩm vấn với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

76. Nhà máy được gọi với cùng chữ ký với hàm tạo

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87, vì

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 là cài đặt mặc định cho nhà máy

Cách tiếp cận này cho phép một nhà máy tùy chỉnh kiểm soát tất cả các khía cạnh của việc tạo LogRecord. Ví dụ: bạn có thể trả về một lớp con hoặc chỉ cần thêm một số thuộc tính bổ sung vào bản ghi sau khi được tạo bằng cách sử dụng mẫu tương tự như sau

Mẫu này cho phép các thư viện khác nhau xâu chuỗi các nhà máy lại với nhau và miễn là chúng không ghi đè lên các thuộc tính của nhau hoặc vô tình ghi đè lên các thuộc tính được cung cấp theo tiêu chuẩn, thì sẽ không có gì bất ngờ. Tuy nhiên, cần lưu ý rằng mỗi liên kết trong chuỗi sẽ thêm chi phí thời gian chạy cho tất cả các hoạt động ghi nhật ký và kỹ thuật này chỉ nên được sử dụng khi việc sử dụng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 không mang lại kết quả mong muốn

Phân lớp QueueHandler - một ví dụ về ZeroMQ¶

Bạn có thể sử dụng lớp con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

31 để gửi tin nhắn đến các loại hàng đợi khác, ví dụ như ổ cắm 'xuất bản' của ZeroMQ. Trong ví dụ bên dưới, ổ cắm được tạo riêng và được chuyển đến trình xử lý [dưới dạng 'hàng đợi' của nó]

Tất nhiên, có nhiều cách khác để tổ chức việc này, ví dụ như chuyển dữ liệu mà trình xử lý cần để tạo ổ cắm

Phân lớp QueueListener - một ví dụ về ZeroMQ¶

Bạn cũng có thể phân lớp

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

34 để nhận tin nhắn từ các loại hàng đợi khác, ví dụ như ổ cắm 'đăng ký' của ZeroMQ. Đây là một ví dụ

Xem thêm

Mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Tham chiếu API cho mô-đun ghi nhật ký

Mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

API cấu hình cho mô-đun ghi nhật ký

Mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Trình xử lý hữu ích đi kèm với mô-đun ghi nhật ký

Hướng dẫn đăng nhập cơ bản

Hướng dẫn ghi nhật ký nâng cao hơn

Ví dụ về cấu hình dựa trên từ điển¶

Dưới đây là một ví dụ về từ điển cấu hình ghi nhật ký - được lấy từ tài liệu về dự án Django. Từ điển này được chuyển đến

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85 để cấu hình có hiệu lực

Để biết thêm thông tin về cấu hình này, bạn có thể xem phần liên quan của tài liệu Django

Sử dụng công cụ quay vòng và trình đặt tên để tùy chỉnh quá trình xoay vòng nhật ký¶

Một ví dụ về cách bạn có thể xác định trình đặt tên và công cụ quay vòng được đưa ra trong đoạn mã sau, đoạn mã này cho thấy quá trình nén tệp nhật ký dựa trên zlib

Đây không phải là "sự thật". gz, vì chúng là dữ liệu nén đơn thuần, không có "bộ chứa" như bạn tìm thấy trong tệp gzip thực tế. Đoạn trích này chỉ nhằm mục đích minh họa

Một ví dụ đa xử lý phức tạp hơn¶

Ví dụ hoạt động sau đây cho thấy cách ghi nhật ký có thể được sử dụng với đa xử lý bằng tệp cấu hình. Các cấu hình khá đơn giản, nhưng dùng để minh họa cách các cấu hình phức tạp hơn có thể được triển khai trong một kịch bản đa xử lý thực tế

Trong ví dụ, quy trình chính sinh ra quy trình nghe và một số quy trình worker. Mỗi quy trình chính, người nghe và công nhân có ba cấu hình riêng biệt [tất cả công nhân đều chia sẻ cùng một cấu hình]. Chúng ta có thể thấy quá trình ghi nhật ký trong quy trình chính, cách công nhân đăng nhập vào QueueHandler và cách trình nghe triển khai QueueListener và cấu hình ghi nhật ký phức tạp hơn, đồng thời sắp xếp để gửi các sự kiện nhận được qua hàng đợi tới trình xử lý được chỉ định trong cấu hình. Lưu ý rằng các cấu hình này hoàn toàn mang tính minh họa, nhưng bạn sẽ có thể điều chỉnh ví dụ này theo tình huống của riêng mình

Đây là tập lệnh - các tài liệu và nhận xét hy vọng sẽ giải thích cách thức hoạt động của nó

Chèn BOM vào thư được gửi tới SysLogHandler¶

RFC 5424 yêu cầu một thông báo Unicode được gửi tới daemon nhật ký hệ thống dưới dạng một tập hợp các byte có cấu trúc sau. một thành phần ASCII thuần túy tùy chọn, theo sau là Dấu thứ tự byte [BOM] UTF-8, theo sau là Unicode được mã hóa bằng UTF-8. [Xem phần có liên quan của thông số kỹ thuật. ]

Trong Trăn 3. 1, mã đã được thêm vào

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

86 để chèn BOM vào tin nhắn, nhưng thật không may, nó đã được triển khai không chính xác, với BOM xuất hiện ở đầu tin nhắn và do đó không cho phép bất kỳ thành phần ASCII thuần túy nào xuất hiện trước nó

Vì hành vi này bị hỏng, mã chèn BOM không chính xác đang bị xóa khỏi Python 3. 2. 4 trở lên. Tuy nhiên, nó không được thay thế và nếu bạn muốn tạo các thông báo tuân thủ RFC 5424 bao gồm BOM, một chuỗi ASCII thuần túy tùy chọn trước nó và Unicode tùy ý sau nó, được mã hóa bằng UTF-8, thì bạn cần thực hiện

Đính kèm một phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88 với phiên bản

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

86 của bạn, với một chuỗi định dạng chẳng hạn như

Điểm mã Unicode U+FEFF, khi được mã hóa bằng UTF-8, sẽ được mã hóa dưới dạng BOM UTF-8 – chuỗi byte

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Thay thế phần ASCII bằng bất kỳ trình giữ chỗ nào bạn thích, nhưng đảm bảo rằng dữ liệu xuất hiện trong đó sau khi thay thế luôn là ASCII [theo cách đó, nó sẽ không thay đổi sau khi mã hóa UTF-8]
Thay thế phần Unicode bằng bất kỳ trình giữ chỗ nào bạn thích;

Tin nhắn được định dạng sẽ được mã hóa bằng mã hóa UTF-8 bởi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

86. Nếu tuân theo các quy tắc trên, bạn sẽ có thể tạo các thông báo tuân thủ RFC 5424. Nếu bạn không làm như vậy, việc ghi nhật ký có thể không bị khiếu nại, nhưng các thông báo của bạn sẽ không tuân thủ RFC 5424 và trình nền nhật ký hệ thống của bạn có thể bị khiếu nại

Triển khai ghi nhật ký có cấu trúc¶

Mặc dù hầu hết các thông báo ghi nhật ký đều dành cho con người đọc và do đó không dễ dàng phân tích cú pháp bằng máy, nhưng có thể có những trường hợp bạn muốn xuất thông báo ở định dạng có cấu trúc mà chương trình có thể phân tích cú pháp [không cần các biểu thức chính quy phức tạp để phân tích cú pháp . Điều này rất đơn giản để đạt được bằng cách sử dụng gói ghi nhật ký. Có một số cách để đạt được điều này, nhưng sau đây là một cách tiếp cận đơn giản sử dụng JSON để tuần tự hóa sự kiện theo cách có thể phân tích bằng máy

Nếu đoạn script trên được chạy, nó sẽ in

Lưu ý rằng thứ tự của các mục có thể khác nhau tùy theo phiên bản Python được sử dụng

Nếu cần xử lý chuyên biệt hơn, bạn có thể sử dụng bộ mã hóa JSON tùy chỉnh, như trong ví dụ hoàn chỉnh sau

Khi đoạn script trên được chạy, nó sẽ in

Lưu ý rằng thứ tự của các mục có thể khác nhau tùy theo phiên bản Python được sử dụng

Tùy chỉnh trình xử lý với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85¶

Đôi khi bạn muốn tùy chỉnh trình xử lý ghi nhật ký theo những cách cụ thể và nếu bạn sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85, bạn có thể thực hiện việc này mà không cần phân lớp con. Ví dụ, hãy xem xét rằng bạn có thể muốn đặt quyền sở hữu tệp nhật ký. Trên POSIX, điều này được thực hiện dễ dàng bằng cách sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

93, nhưng trình xử lý tệp trong stdlib không cung cấp hỗ trợ tích hợp. Bạn có thể tùy chỉnh việc tạo trình xử lý bằng một chức năng đơn giản, chẳng hạn như

Sau đó, bạn có thể chỉ định, trong cấu hình ghi nhật ký được chuyển đến

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85, rằng trình xử lý ghi nhật ký được tạo bằng cách gọi hàm này

Trong ví dụ này, tôi đang đặt quyền sở hữu bằng cách sử dụng người dùng và nhóm

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

95, chỉ nhằm mục đích minh họa. Đặt nó lại với nhau thành một kịch bản hoạt động,

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Để chạy cái này, có thể bạn sẽ cần chạy với tên

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Lưu ý rằng ví dụ này sử dụng Python 3. 3 vì đó là nơi mà

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

93 xuất hiện. Cách tiếp cận này sẽ hoạt động với bất kỳ phiên bản Python nào hỗ trợ

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85 - cụ thể là Python 2. 7, 3. 2 hoặc muộn hơn. Với trước 3. 3 phiên bản, bạn sẽ cần thực hiện thay đổi quyền sở hữu thực tế bằng cách sử dụng e. g.

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Trong thực tế, chức năng tạo trình xử lý có thể nằm trong một mô-đun tiện ích ở đâu đó trong dự án của bạn. Thay vì dòng trong cấu hình

bạn có thể sử dụng điện tử. g

trong đó

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

01 có thể được thay thế bằng tên thực của gói chứa chức năng. Trong kịch bản làm việc ở trên, sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

02 sẽ hoạt động. Ở đây, khả năng gọi được thực tế được giải quyết bởi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85 từ thông số kỹ thuật của

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Ví dụ này hy vọng cũng chỉ ra cách bạn có thể thực hiện các kiểu thay đổi tệp khác - e. g. đặt các bit quyền POSIX cụ thể - theo cách tương tự, sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Tất nhiên, cách tiếp cận cũng có thể được mở rộng cho các loại trình xử lý khác ngoài

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

18 - ví dụ: một trong các trình xử lý tệp quay hoặc một loại trình xử lý khác hoàn toàn

Sử dụng các kiểu định dạng cụ thể xuyên suốt ứng dụng của bạn¶

Trong Trăn 3. 2,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88 đã đạt được tham số từ khóa

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

38, trong khi mặc định là

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

09 để tương thích ngược, cho phép thông số kỹ thuật của

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

10 hoặc

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

11 hỗ trợ các phương pháp định dạng được hỗ trợ bởi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

36 và

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

35. Lưu ý rằng điều này chi phối định dạng của thông báo ghi nhật ký cho đầu ra cuối cùng thành nhật ký và hoàn toàn trực giao với cách tạo thông báo ghi nhật ký riêng lẻ

Ghi nhật ký cuộc gọi [

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

72,

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

73, v.v. ] chỉ nhận các tham số vị trí cho chính thông báo ghi nhật ký thực tế, với các tham số từ khóa chỉ được sử dụng để xác định các tùy chọn về cách xử lý lệnh gọi ghi nhật ký [e. g. tham số từ khóa

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

46 để cho biết rằng thông tin truy nguyên phải được ghi lại hoặc tham số từ khóa

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

47 để cho biết thông tin theo ngữ cảnh bổ sung sẽ được thêm vào nhật ký]. Vì vậy, bạn không thể trực tiếp thực hiện các cuộc gọi ghi nhật ký bằng cú pháp

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

36 hoặc

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

35, bởi vì bên trong gói ghi nhật ký sử dụng %-formatting để hợp nhất chuỗi định dạng và các đối số biến. Sẽ không thay đổi điều này trong khi vẫn duy trì khả năng tương thích ngược, vì tất cả lệnh gọi ghi nhật ký hiện có trong mã hiện tại sẽ sử dụng chuỗi %-format

Đã có đề xuất liên kết các kiểu định dạng với các trình ghi nhật ký cụ thể, nhưng cách tiếp cận đó cũng gặp phải các vấn đề về tương thích ngược vì bất kỳ mã hiện có nào cũng có thể sử dụng một tên trình ghi cụ thể và sử dụng %-formatting

Để ghi nhật ký hoạt động tương tác giữa bất kỳ thư viện bên thứ ba nào và mã của bạn, các quyết định về định dạng cần phải được đưa ra ở cấp độ lệnh gọi ghi nhật ký riêng lẻ. Điều này mở ra một số cách để có thể cung cấp các kiểu định dạng thay thế

Sử dụng các nhà máy LogRecord¶

Trong Trăn 3. 2, cùng với các thay đổi của

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88 được đề cập ở trên, gói ghi nhật ký có khả năng cho phép người dùng đặt các lớp con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 của riêng họ, sử dụng hàm

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

75. Bạn có thể sử dụng điều này để đặt lớp con của riêng bạn là

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87, lớp này thực hiện Điều đúng đắn bằng cách ghi đè phương thức

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

24. Việc triển khai lớp cơ sở của phương pháp này là nơi xảy ra định dạng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

25 và là nơi bạn có thể thay thế định dạng thay thế của mình; . Cũng nên cẩn thận khi gọi

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

26, giống như việc triển khai cơ sở

Tham khảo tài liệu tham khảo trên

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

75 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

87 để biết thêm thông tin

Sử dụng các đối tượng tin nhắn tùy chỉnh¶

There is another, perhaps simpler way that you can use {}- and $- formatting to construct your individual log messages. Bạn có thể nhớ lại [từ Sử dụng các đối tượng tùy ý làm thông báo ] rằng khi ghi nhật ký, bạn có thể sử dụng một đối tượng tùy ý làm chuỗi định dạng thông báo và gói ghi nhật ký sẽ . Hãy xem xét hai lớp sau.

Either of these can be used in place of a format string, to allow {}- or $-formatting to be used to build the actual “message” part which appears in the formatted log output in place of “%[message]s” or “{message}” or “$message”. If you find it a little unwieldy to use the class names whenever you want to log something, you can make it more palatable if you use an alias such as

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

30 or

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

31 for the message [or perhaps

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

32, if you are using

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

31 for localization]

Ví dụ về cách tiếp cận này được đưa ra dưới đây. Đầu tiên, định dạng với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Thứ hai, định dạng với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Một điều cần lưu ý là bạn không phải trả tiền phạt hiệu suất đáng kể với phương pháp này. the actual formatting happens not when you make the logging call, but when [and if] the logged message is actually about to be output to a log by a handler. Vì vậy, điều hơi bất thường duy nhất có thể khiến bạn vấp ngã là các dấu ngoặc đơn bao quanh chuỗi định dạng và các đối số, không chỉ chuỗi định dạng. That’s because the __ notation is just syntax sugar for a constructor call to one of the

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

36 classes shown above

Định cấu hình bộ lọc với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85¶

Bạn có thể định cấu hình bộ lọc bằng cách sử dụng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85, mặc dù thoạt nhìn có thể không rõ cách thực hiện [do đó có công thức này]. Vì

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 là lớp bộ lọc duy nhất có trong thư viện tiêu chuẩn và không có khả năng đáp ứng nhiều yêu cầu [nó chỉ có ở đó dưới dạng lớp cơ sở], nên thông thường bạn sẽ cần xác định lớp con

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95 của riêng mình bằng phương thức

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

70 bị ghi đè. Để thực hiện việc này, hãy chỉ định khóa

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

42 trong từ điển cấu hình cho bộ lọc, chỉ định một khả năng gọi được sẽ được sử dụng để tạo bộ lọc [một lớp là rõ ràng nhất, nhưng bạn có thể cung cấp bất kỳ khả năng gọi nào trả về một phiên bản

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

95]. Đây là một ví dụ hoàn chỉnh

Ví dụ này cho thấy cách bạn có thể chuyển dữ liệu cấu hình tới đối tượng có thể gọi được để xây dựng thể hiện, ở dạng tham số từ khóa. Khi chạy, đoạn script trên sẽ in

cho biết bộ lọc đang hoạt động như đã định cấu hình

Một vài điểm bổ sung cần lưu ý

If you can’t refer to the callable directly in the configuration [e. g. nếu nó nằm trong một mô-đun khác và bạn không thể nhập nó trực tiếp vào vị trí của từ điển cấu hình], bạn có thể sử dụng biểu mẫu

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

44 như được mô tả trong Truy cập đối tượng bên ngoài. For example, you could have used the text

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

45 instead of

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

46 in the above example.

Cũng như đối với bộ lọc, kỹ thuật này cũng có thể được sử dụng để định cấu hình trình xử lý và trình định dạng tùy chỉnh. Xem Đối tượng do người dùng xác định để biết thêm thông tin về cách hỗ trợ ghi nhật ký bằng cách sử dụng các đối tượng do người dùng xác định trong cấu hình của nó và xem công thức sách dạy nấu ăn khác Customizing handlers with dictConfig[] above.

Customized exception formatting¶

Có thể đôi khi bạn muốn thực hiện định dạng ngoại lệ được tùy chỉnh - vì lợi ích của đối số, giả sử bạn muốn chính xác một dòng cho mỗi sự kiện đã ghi, ngay cả khi có thông tin ngoại lệ. Bạn có thể làm điều này với một lớp trình định dạng tùy chỉnh, như trong ví dụ sau

Khi chạy, điều này tạo ra một tệp có chính xác hai dòng

Mặc dù cách xử lý trên là đơn giản, nhưng nó chỉ ra cách thông tin ngoại lệ có thể được định dạng theo ý thích của bạn. Mô-đun

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

47 có thể hữu ích cho các nhu cầu chuyên biệt hơn

Thông báo ghi nhật ký nói¶

Có thể có những trường hợp mong muốn hiển thị thông báo ghi nhật ký ở định dạng âm thanh thay vì hiển thị. Điều này rất dễ thực hiện nếu bạn có sẵn chức năng chuyển văn bản thành giọng nói [TTS] trong hệ thống của mình, ngay cả khi chức năng này không có liên kết Python. Hầu hết các hệ thống TTS đều có chương trình dòng lệnh mà bạn có thể chạy và chương trình này có thể được gọi từ trình xử lý bằng cách sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

48. Ở đây, giả định rằng các chương trình dòng lệnh TTS sẽ không mong muốn tương tác với người dùng hoặc mất nhiều thời gian để hoàn thành và tần suất của các thông báo được ghi sẽ không cao đến mức khiến người dùng bị ngập trong các thông báo và có thể chấp nhận được . Dưới đây là một ví dụ ngắn cho thấy cách tiếp cận, giả định rằng gói TTS

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

49 có sẵn

Khi chạy, tập lệnh này sẽ nói “Xin chào” và sau đó là “Tạm biệt” bằng giọng nữ

Tất nhiên, cách tiếp cận trên có thể được điều chỉnh cho các hệ thống TTS khác và thậm chí cả các hệ thống khác có thể xử lý tin nhắn thông qua các chương trình bên ngoài chạy từ một dòng lệnh

Lưu vào bộ nhớ đệm các thông báo ghi nhật ký và xuất chúng theo điều kiện¶

Có thể có những tình huống mà bạn muốn ghi các tin nhắn trong một khu vực tạm thời và chỉ xuất chúng nếu một điều kiện nào đó xảy ra. Ví dụ: bạn có thể muốn bắt đầu ghi nhật ký các sự kiện gỡ lỗi trong một chức năng và nếu chức năng đó hoàn thành mà không có lỗi, bạn không muốn làm lộn xộn nhật ký với thông tin gỡ lỗi đã thu thập, nhưng nếu có lỗi, bạn muốn toàn bộ quá trình gỡ lỗi

Dưới đây là một ví dụ cho thấy cách bạn có thể thực hiện việc này bằng cách sử dụng trình trang trí cho các chức năng của mình mà bạn muốn ghi nhật ký hoạt động theo cách này. Nó sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

50, cho phép lưu vào bộ đệm các sự kiện đã ghi cho đến khi một số điều kiện xảy ra, tại thời điểm đó, các sự kiện được lưu vào bộ đệm là

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

51 - được chuyển đến trình xử lý khác [trình xử lý

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

52] để xử lý. Theo mặc định,

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

53 bị xóa khi bộ đệm của nó bị đầy hoặc một sự kiện có mức lớn hơn hoặc bằng một ngưỡng đã chỉ định được nhìn thấy. You can use this recipe with a more specialised subclass of

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

53 if you want custom flushing behavior

Tập lệnh ví dụ có một chức năng đơn giản,

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

23, chỉ quay vòng qua tất cả các cấp độ ghi nhật ký, viết thư cho

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

11 để cho biết nó sắp đăng nhập ở cấp độ nào, sau đó thực sự ghi lại một thông báo ở cấp độ đó. You can pass a parameter to

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

23 which, if true, will log at ERROR and CRITICAL levels - otherwise, it only logs at DEBUG, INFO and WARNING levels

The script just arranges to decorate

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

23 with a decorator which will do the conditional logging that’s required. The decorator takes a logger as a parameter and attaches a memory handler for the duration of the call to the decorated function. The decorator can be additionally parameterised using a target handler, a level at which flushing should occur, and a capacity for the buffer [number of records buffered]. Các giá trị này mặc định là

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

59 tương ứng ghi vào

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

11,

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

61 và

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

Đây là kịch bản

Khi tập lệnh này được chạy, đầu ra sau sẽ được quan sát

Như bạn có thể thấy, đầu ra ghi nhật ký thực tế chỉ xảy ra khi một sự kiện được ghi lại có mức độ nghiêm trọng là LỖI trở lên, nhưng trong trường hợp đó, bất kỳ sự kiện nào trước đó ở mức độ nghiêm trọng thấp hơn cũng được ghi lại

Tất nhiên bạn có thể sử dụng các phương tiện trang trí thông thường

Gửi thông báo ghi nhật ký tới email, với bộ nhớ đệm¶

Để minh họa cách bạn có thể gửi thông điệp bản ghi qua email, để một số lượng thông báo được gửi cho mỗi email, bạn có thể phân lớp

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

63. Trong ví dụ sau, bạn có thể điều chỉnh cho phù hợp với nhu cầu cụ thể của mình, một khai thác thử nghiệm đơn giản được cung cấp cho phép bạn chạy tập lệnh với các đối số dòng lệnh chỉ định những gì bạn thường cần để gửi mọi thứ qua SMTP. [Chạy tập lệnh đã tải xuống với đối số

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

64 để xem các đối số bắt buộc và tùy chọn. ]

Nếu bạn chạy tập lệnh này và máy chủ SMTP của bạn được thiết lập chính xác, bạn sẽ thấy rằng nó sẽ gửi 11 email đến người nhận mà bạn chỉ định. Mười email đầu tiên, mỗi email sẽ có mười thông báo tường trình và email thứ mười một sẽ có hai thông báo. That makes up 102 messages as specified in the script

Định dạng thời gian sử dụng UTC [GMT] thông qua cấu hình¶

Đôi khi bạn muốn định dạng thời gian bằng UTC, điều này có thể được thực hiện bằng cách sử dụng một lớp chẳng hạn như

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

65, được hiển thị bên dưới

và sau đó bạn có thể sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

65 trong mã của mình thay vì

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

88. Nếu bạn muốn làm điều đó thông qua cấu hình, bạn có thể sử dụng API

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

85 với cách tiếp cận được minh họa bằng ví dụ hoàn chỉnh sau

Khi tập lệnh này được chạy, nó sẽ in một cái gì đó như

hiển thị cách định dạng thời gian theo cả giờ địa phương và UTC, một cho mỗi trình xử lý

Using a context manager for selective logging¶

Đôi khi sẽ hữu ích khi tạm thời thay đổi cấu hình ghi nhật ký và hoàn nguyên lại sau khi thực hiện điều gì đó. Đối với điều này, trình quản lý bối cảnh là cách rõ ràng nhất để lưu và khôi phục bối cảnh ghi nhật ký. Here is a simple example of such a context manager, which allows you to optionally change the logging level and add a logging handler purely in the scope of the context manager

Nếu bạn chỉ định một giá trị cấp độ, thì cấp độ của trình ghi nhật ký sẽ được đặt thành giá trị đó trong phạm vi của khối with được bao phủ bởi trình quản lý ngữ cảnh. Nếu bạn chỉ định một trình xử lý, nó sẽ được thêm vào bộ ghi nhật ký khi vào khối và bị xóa khi thoát khỏi khối. Bạn cũng có thể yêu cầu người quản lý đóng trình xử lý cho bạn khi thoát khỏi khối - bạn có thể làm điều này nếu bạn không cần trình xử lý nữa

Để minh họa cách nó hoạt động, chúng ta có thể thêm đoạn mã sau vào phần trên

Ban đầu, chúng tôi đặt cấp độ của thiết bị ghi là

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

07, vì vậy thông báo #1 xuất hiện và thông báo #2 thì không. Sau đó, chúng tôi tạm thời thay đổi mức thành

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

12 trong khối

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

71 tiếp theo và do đó, thông báo số 3 xuất hiện. Sau khi thoát khỏi khối, cấp độ của bộ ghi nhật ký được khôi phục thành

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

07 và do đó, thông báo #4 không xuất hiện. Trong khối

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

71 tiếp theo, chúng tôi đặt lại mức thành

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

12 nhưng cũng thêm một trình xử lý ghi vào

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

09. Do đó, thông báo #5 xuất hiện hai lần trên bảng điều khiển [một lần qua

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

76 và một lần qua

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

21]. Sau khi hoàn thành câu lệnh

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

71, trạng thái vẫn như trước nên thông báo #6 xuất hiện [giống thông báo #1] trong khi thông báo #7 thì không [giống thông báo #2]

Nếu chúng tôi chạy tập lệnh kết quả, kết quả như sau

Nếu chúng tôi chạy lại nó, nhưng chuyển

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

76 sang

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

80, chúng tôi sẽ thấy thông báo sau, đây là thông báo duy nhất được viết cho

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Một lần nữa, nhưng thay đổi đường dẫn

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

21 đến

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

80, chúng tôi nhận được

Trong trường hợp này, thông báo #5 được in tới

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

21 không xuất hiện như mong đợi

Tất nhiên, cách tiếp cận được mô tả ở đây có thể được khái quát hóa, ví dụ: tạm thời đính kèm các bộ lọc ghi nhật ký. Lưu ý rằng đoạn mã trên hoạt động trong Python 2 cũng như Python 3

Mẫu khởi động ứng dụng CLI¶

Đây là một ví dụ cho thấy cách bạn có thể

Sử dụng cấp độ ghi nhật ký dựa trên đối số dòng lệnh
Gửi tới nhiều tiểu ban trong các tệp riêng biệt, tất cả ghi nhật ký ở cùng một cấp theo cách nhất quán
Sử dụng cấu hình đơn giản, tối thiểu

Giả sử chúng ta có một ứng dụng dòng lệnh có nhiệm vụ dừng, bắt đầu hoặc khởi động lại một số dịch vụ. Điều này có thể được tổ chức cho mục đích minh họa dưới dạng tệp

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

85 là tập lệnh chính cho ứng dụng, với các lệnh riêng lẻ được triển khai trong

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

86,

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

87 và

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

88. Giả sử thêm rằng chúng ta muốn kiểm soát mức độ chi tiết của ứng dụng thông qua đối số dòng lệnh, mặc định là

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

89. Đây là một cách mà

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

85 có thể được viết

Và các lệnh

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

91,

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

92 và

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

93 có thể được triển khai trong các mô-đun riêng biệt, như vậy để bắt đầu

và do đó để dừng lại

và tương tự để khởi động lại

If we run this application with the default log level, we get output like this

Từ đầu tiên là cấp độ ghi nhật ký và từ thứ hai là tên mô-đun hoặc gói của nơi ghi sự kiện

If we change the logging level, then we can change the information sent to the log. Ví dụ, nếu chúng ta muốn biết thêm thông tin

And if we want less

Number of digits: 4

In this case, the commands don’t print anything to the console, since nothing at

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

08 level or above is logged by them

GUI Qt để ghi nhật ký¶

Một câu hỏi thỉnh thoảng xuất hiện là về cách đăng nhập vào ứng dụng GUI. Khung Qt là khung giao diện người dùng đa nền tảng phổ biến với các liên kết Python sử dụng thư viện PySide2 hoặc PyQt5

The following example shows how to log to a Qt GUI. Điều này giới thiệu một lớp

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

95 đơn giản, có thể gọi được, đây sẽ là một vị trí trong luồng chính cập nhật GUI. Một worker thread cũng được tạo ra để chỉ ra cách bạn có thể đăng nhập vào GUI từ chính giao diện người dùng [thông qua một nút để ghi thủ công] cũng như một worker thread đang hoạt động trong nền [ở đây, chỉ ghi các thông báo ở mức ngẫu nhiên với

Chuỗi worker được triển khai bằng cách sử dụng lớp

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

96 của Qt thay vì mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

05, vì có những trường hợp người ta phải sử dụng

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

96, giúp tích hợp tốt hơn với các thành phần

import logging
import threading
import time

def worker[arg]:
    while not arg['stop']:
        logging.debug['Hi from myfunc']
        time.sleep[0.5]

def main[]:
    logging.basicConfig[level=logging.DEBUG, format='%[relativeCreated]6d %[threadName]s %[message]s']
    info = {'stop': False}
    thread = threading.Thread[target=worker, args=[info,]]
    thread.start[]
    while True:
        try:
            logging.debug['Hello from main']
            time.sleep[0.75]
        except KeyboardInterrupt:
            info['stop'] = True
            break
    thread.join[]

if __name__ == '__main__':
    main[]

99 khác

Mã phải hoạt động với các bản phát hành gần đây của

000 hoặc

001. You should be able to adapt the approach to earlier versions of Qt. Vui lòng tham khảo các nhận xét trong đoạn mã để biết thêm thông tin chi tiết

Number of digits: 4

Ghi nhật ký hệ thống với hỗ trợ RFC5424¶

Mặc dù RFC 5424 có từ năm 2009, nhưng hầu hết các máy chủ nhật ký hệ thống đều được định cấu hình mặc định để sử dụng RFC 3164 cũ hơn, xuất hiện từ năm 2001. Khi

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

82 được thêm vào Python vào năm 2003, nó đã hỗ trợ giao thức trước đó [và duy nhất hiện có] vào thời điểm đó. Kể từ khi RFC5424 ra mắt, vì nó chưa được triển khai rộng rãi trong các máy chủ nhật ký hệ thống nên chức năng

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

86 chưa được cập nhật

RFC 5424 contains some useful features such as support for structured data, and if you need to be able to log to a syslog server with support for it, you can do so with a subclassed handler which looks something like this

Number of digits: 4

Bạn cần phải làm quen với RFC 5424 để hiểu đầy đủ đoạn mã trên và có thể bạn có các nhu cầu hơi khác [e. g. để biết cách bạn chuyển dữ liệu cấu trúc vào nhật ký]. Tuy nhiên, những điều trên phải phù hợp với nhu cầu cụ thể của bạn. Với trình xử lý ở trên, bạn sẽ chuyển dữ liệu có cấu trúc bằng cách sử dụng thứ gì đó như thế này

Number of digits: 4

Cách coi bộ ghi như một luồng đầu ra¶

Đôi khi, bạn cần giao tiếp với API của bên thứ ba, dự kiến sẽ ghi vào một đối tượng giống như tệp, nhưng bạn muốn hướng đầu ra của API tới một trình ghi nhật ký. Bạn có thể thực hiện việc này bằng cách sử dụng lớp bao bọc trình ghi nhật ký bằng API giống như tệp. Đây là một kịch bản ngắn minh họa một lớp học như vậy

Number of digits: 4

Khi tập lệnh này được chạy, nó sẽ in

Number of digits: 4

Bạn cũng có thể sử dụng

004 để chuyển hướng

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

09 và

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

11 bằng cách làm điều gì đó như thế này

Number of digits: 4

Bạn nên làm điều này sau khi định cấu hình ghi nhật ký cho nhu cầu của mình. Trong ví dụ trên, lệnh gọi

007 thực hiện điều này [sử dụng giá trị

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

11 trước khi nó bị ghi đè bởi phiên bản

004]. Sau đó, bạn sẽ nhận được loại kết quả này

Number of digits: 4

Tất nhiên, các ví dụ trên hiển thị đầu ra theo định dạng được sử dụng bởi

007, nhưng bạn có thể sử dụng một trình định dạng khác khi định cấu hình ghi nhật ký

Lưu ý rằng với sơ đồ trên, bạn phần nào chịu sự đệm và chuỗi các cuộc gọi ghi mà bạn đang chặn. Ví dụ với định nghĩa của

004 ở trên, nếu bạn có đoạn

Number of digits: 4

sau đó chạy tập lệnh dẫn đến

Number of digits: 4

Như bạn có thể thấy, đầu ra này không lý tưởng. Đó là bởi vì mã cơ bản ghi vào

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

11 tạo ra nhiều lần ghi, mỗi lần ghi lại dẫn đến một dòng ghi riêng biệt [ví dụ: ba dòng cuối cùng ở trên]. Để giải quyết vấn đề này, bạn cần đệm mọi thứ và chỉ xuất các dòng nhật ký khi nhìn thấy các dòng mới. Hãy sử dụng một triển khai tốt hơn của

004

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Điều này chỉ lưu trữ nội dung cho đến khi nhìn thấy một dòng mới, sau đó ghi lại các dòng hoàn chỉnh. Với phương pháp này, bạn sẽ có được đầu ra tốt hơn

import logging

# create logger
module_logger = logging.getLogger['spam_application.auxiliary']

class Auxiliary:
    def __init__[self]:
        self.logger = logging.getLogger['spam_application.auxiliary.Auxiliary']
        self.logger.info['creating an instance of Auxiliary']

    def do_something[self]:
        self.logger.info['doing something']
        a = 1 + 1
        self.logger.info['done doing something']

def some_function[]:
    module_logger.info['received a call to "some_function"']

Các mẫu cần tránh¶

Mặc dù các phần trước đã mô tả các cách thực hiện những việc mà bạn có thể cần thực hiện hoặc xử lý, nhưng cần đề cập đến một số kiểu sử dụng không hữu ích và do đó nên tránh sử dụng trong hầu hết các trường hợp. Các phần sau đây không theo thứ tự cụ thể

Mở cùng một tệp nhật ký nhiều lần¶

Trên Windows, thông thường bạn sẽ không thể mở cùng một tệp nhiều lần vì điều này sẽ dẫn đến lỗi “file is in use by another process”. Tuy nhiên, trên nền tảng POSIX, bạn sẽ không gặp bất kỳ lỗi nào nếu mở cùng một tệp nhiều lần. Điều này có thể được thực hiện một cách tình cờ, ví dụ bởi

Thêm một trình xử lý tệp nhiều lần tham chiếu cùng một tệp [e. g. do lỗi sao chép/dán/quên thay đổi]
Mở hai tệp trông khác nhau, vì chúng có tên khác nhau, nhưng giống nhau vì tệp này là liên kết tượng trưng với tệp kia

Chuyển đổi một quy trình, theo đó cả cha và con đều có tham chiếu đến cùng một tệp. Ví dụ, điều này có thể thông qua việc sử dụng mô-đun

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

Việc mở một tệp nhiều lần có vẻ như luôn hoạt động, nhưng có thể dẫn đến một số vấn đề trong thực tế

Đầu ra ghi nhật ký có thể bị cắt xén vì nhiều luồng hoặc quy trình cố gắng ghi vào cùng một tệp. Mặc dù ghi nhật ký bảo vệ chống lại việc sử dụng đồng thời cùng một phiên bản trình xử lý bởi nhiều luồng, nhưng không có biện pháp bảo vệ nào như vậy nếu việc ghi đồng thời được thực hiện bởi hai luồng khác nhau bằng cách sử dụng hai phiên bản trình xử lý khác nhau trỏ đến cùng một tệp
Một nỗ lực để xóa một tập tin [e. g. trong khi xoay tệp] không thành công, vì có một tham chiếu khác trỏ đến nó. Điều này có thể dẫn đến nhầm lẫn và lãng phí thời gian gỡ lỗi - các mục nhật ký kết thúc ở những nơi không mong muốn hoặc bị mất hoàn toàn. Hoặc một tệp được cho là đã được di chuyển vẫn ở nguyên vị trí và tăng kích thước một cách bất ngờ mặc dù tính năng xoay dựa trên kích thước được cho là đã được đặt đúng chỗ

Sử dụng các kỹ thuật được nêu trong Đăng nhập vào một tệp từ nhiều quy trình để khắc phục các sự cố như vậy.

Sử dụng logger làm thuộc tính trong một lớp hoặc chuyển chúng dưới dạng tham số¶

Mặc dù có thể có những trường hợp bất thường mà bạn sẽ cần thực hiện việc này, nhưng nói chung không có ích gì vì các trình ghi nhật ký là những người độc thân. Mã luôn có thể truy cập một phiên bản trình ghi cụ thể theo tên bằng cách sử dụng

015, vì vậy việc chuyển các phiên bản xung quanh và giữ chúng dưới dạng thuộc tính phiên bản là vô nghĩa. Lưu ý rằng trong các ngôn ngữ khác như Java và C#, logger thường là thuộc tính lớp tĩnh. Tuy nhiên, mẫu này không có ý nghĩa trong Python, nơi mô-đun [chứ không phải lớp] là đơn vị phân tách phần mềm

Thêm trình xử lý khác với

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

73 vào trình ghi nhật ký trong thư viện¶

Định cấu hình ghi nhật ký bằng cách thêm trình xử lý, trình định dạng và bộ lọc là trách nhiệm của nhà phát triển ứng dụng, không phải nhà phát triển thư viện. Nếu bạn đang duy trì một thư viện, hãy đảm bảo rằng bạn không thêm trình xử lý vào bất kỳ trình ghi nhật ký nào ngoài phiên bản

2005-03-23 23:47:11,663 - spam_application - INFO -
   creating an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,665 - spam_application.auxiliary.Auxiliary - INFO -
   creating an instance of Auxiliary
2005-03-23 23:47:11,665 - spam_application - INFO -
   created an instance of auxiliary_module.Auxiliary
2005-03-23 23:47:11,668 - spam_application - INFO -
   calling auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,668 - spam_application.auxiliary.Auxiliary - INFO -
   doing something
2005-03-23 23:47:11,669 - spam_application.auxiliary.Auxiliary - INFO -
   done doing something
2005-03-23 23:47:11,670 - spam_application - INFO -
   finished auxiliary_module.Auxiliary.do_something
2005-03-23 23:47:11,671 - spam_application - INFO -
   calling auxiliary_module.some_function[]
2005-03-23 23:47:11,672 - spam_application.auxiliary - INFO -
   received a call to 'some_function'
2005-03-23 23:47:11,673 - spam_application - INFO -
   done with auxiliary_module.some_function[]

ví dụ 2. Sử dụng các phương thức sẵn có

Ghi nhật ký từ nhiều luồng¶

Nhiều trình xử lý và trình định dạng¶

Đăng nhập vào nhiều đích¶

Xử lý tùy chỉnh các cấp¶

Ví dụ máy chủ cấu hình¶

Xử lý các trình xử lý chặn¶

Gửi và nhận các sự kiện ghi nhật ký qua mạng¶

Chạy trình lắng nghe ổ ghi nhật ký trong sản xuất¶

Thêm thông tin theo ngữ cảnh vào đầu ra ghi nhật ký của bạn¶

Sử dụng LoggerAdapters để truyền đạt thông tin theo ngữ cảnh¶

Sử dụng các đối tượng không phải là dicts để truyền thông tin theo ngữ cảnh¶

Sử dụng Bộ lọc để truyền đạt thông tin theo ngữ cảnh¶

Truyền đạt thông tin theo ngữ cảnh trong trình xử lý¶

Ghi nhật ký vào một tệp từ nhiều quy trình¶

Sử dụng đồng thời. tương lai. ProcessPoolExecutor¶

Triển khai các ứng dụng Web bằng Gunicorn và uWSGI¶

Sử dụng xoay tệp¶

Sử dụng các kiểu định dạng thay thế¶

Phân lớp QueueHandler - một ví dụ về ZeroMQ¶

Phân lớp QueueListener - một ví dụ về ZeroMQ¶

Ví dụ về cấu hình dựa trên từ điển¶

Sử dụng công cụ quay vòng và trình đặt tên để tùy chỉnh quá trình xoay vòng nhật ký¶

Một ví dụ đa xử lý phức tạp hơn¶

Chèn BOM vào thư được gửi tới SysLogHandler¶

Triển khai ghi nhật ký có cấu trúc¶

Sử dụng các kiểu định dạng cụ thể xuyên suốt ứng dụng của bạn¶

Sử dụng các nhà máy LogRecord¶

Sử dụng các đối tượng tin nhắn tùy chỉnh¶

Customized exception formatting¶

Thông báo ghi nhật ký nói¶

Lưu vào bộ nhớ đệm các thông báo ghi nhật ký và xuất chúng theo điều kiện¶

Gửi thông báo ghi nhật ký tới email, với bộ nhớ đệm¶

Định dạng thời gian sử dụng UTC [GMT] thông qua cấu hình¶

Using a context manager for selective logging¶

Mẫu khởi động ứng dụng CLI¶

GUI Qt để ghi nhật ký¶

Ghi nhật ký hệ thống với hỗ trợ RFC5424¶

Cách coi bộ ghi như một luồng đầu ra¶

Các mẫu cần tránh¶

Mở cùng một tệp nhật ký nhiều lần¶

Sử dụng logger làm thuộc tính trong một lớp hoặc chuyển chúng dưới dạng tham số¶

Bài Viết Liên Quan

Toplist mới

Bài mới nhất

Chủ Đề