Apakah kaedah penyahpepijatan dalam Python?

Melog adalah satu kemestian

Jika anda menulis aplikasi anda tanpa beberapa jenis persediaan pengelogan, anda akan menyesal. Tanpa sebarang log dalam aplikasi, sukar untuk menyelesaikan sebarang ralat. Nasib baik, dalam Python, menyediakan pembalak asas adalah sangat mudah:

import logging
logging.basicConfig(
    filename='application.log',
    level=logging.WARNING,
    format= '[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s',
    datefmt='%H:%M:%S'
)

logging.error("Some serious error occurred.")
logging.warning('Function you are using is deprecated.')

Itu sahaja yang anda perlukan untuk mula menulis log anda pada fail, yang akan kelihatan seperti ini (anda boleh menggunakan logging.getLoggerClass().root.handlers[0].baseFilename Cari laluan fail) :

[12:52:35] {<stdin>:1} ERROR - Some serious error occurred.
[12:52:35] {<stdin>:1} WARNING - Function you are using is deprecated.

Persediaan ini nampaknya cukup baik (dan biasanya begitu), tetapi log yang dikonfigurasikan dengan baik, diformat dengan baik dan boleh dibaca boleh menjadikan hidup anda lebih mudah. Satu cara untuk menambah baik dan melanjutkan konfigurasi anda ialah menggunakan fail .ini atau .yaml yang dibaca oleh pembalak. Sebagai contoh, anda boleh melakukan perkara berikut dalam konfigurasi:

version: 1
disable_existing_loggers: true

formatters:
  standard:
    format: "[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s"
    datefmt: '%H:%M:%S'

handlers:
  console:  # handler which will log into stdout
    class: logging.StreamHandler
    level: DEBUG
    formatter: standard  # Use formatter defined above
    stream: ext://sys.stdout
  file:  # handler which will log into file
    class: logging.handlers.RotatingFileHandler
    level: WARNING
    formatter: standard  # Use formatter defined above
    filename: /tmp/warnings.log
    maxBytes: 10485760 # 10MB
    backupCount: 10
    encoding: utf8

root:  # Loggers are organized in hierarchy - this is the root logger config
  level: ERROR
  handlers: [console, file]  # Attaches both handler defined above

loggers:  # Defines descendants of root logger
  mymodule:  # Logger for "mymodule"
    level: INFO
    handlers: [file]  # Will only use "file" handler defined above
    propagate: no  # Will not propagate logs to "root" logger

Memiliki konfigurasi ekstensif seperti ini dalam kod python akan menjadi sukar untuk dinavigasi, diedit dan diselenggara. Menyimpan kandungan dalam fail YAML memudahkan untuk menyediakan dan menala berbilang pembalak dengan tetapan yang sangat khusus seperti yang di atas.

Jika anda tertanya-tanya dari mana datangnya semua medan konfigurasi ini, ini didokumenkan dalam dokumentasi rasmi dan kebanyakannya hanyalah argumen kata kunci, seperti yang ditunjukkan dalam contoh pertama.

Jadi sekarang kita mempunyai konfigurasi dalam fail, bermakna kita perlu memuatkannya entah bagaimana. Cara paling mudah ialah menggunakan fail YAML:

import yaml
from logging import config

with open("config.yaml", 'rt') as f:
    config_data = yaml.safe_load(f.read())
    config.dictConfig(config_data)

Python logger sebenarnya tidak menyokong fail YAML secara langsung, tetapi ia menyokong konfigurasi kamus, yang boleh dibuat dengan mudah daripada YAML menggunakan yaml.safe_load . Jika anda lebih suka menggunakan fail .ini lama, maka saya hanya ingin menunjukkan bahawa menurut dokumentasi rasmi, menggunakan konfigurasi kamus adalah pendekatan yang disyorkan untuk aplikasi baharu. Untuk lebih banyak contoh, lihat manual pengelogan rasmi.

Penghias log

Melanjutkan dengan teknik pengelogan sebelumnya, anda mungkin menghadapi situasi di mana anda perlu log beberapa panggilan fungsi ralat. Daripada mengubah suai badan fungsi tersebut, anda boleh menggunakan penghias pembalakan, yang akan log setiap panggilan fungsi dengan tahap log tertentu dan mesej pilihan. Mari lihat penghias:

from functools import wraps, partial
import logging

def attach_wrapper(obj, func=None):  # Helper function that attaches function as attribute of an object
    if func is None:
        return partial(attach_wrapper, obj)
    setattr(obj, func.__name__, func)
    return func

def log(level, message):  # Actual decorator
    def decorate(func):
        logger = logging.getLogger(func.__module__)  # Setup logger
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s')
        handler = logging.StreamHandler()
        handler.setFormatter(formatter)
        logger.addHandler(handler)
        log_message = f"{func.__name__} - {message}"

        @wraps(func)
        def wrapper(*args, **kwargs):  # Logs the message and before executing the decorated function
            logger.log(level, log_message)
            return func(*args, **kwargs)

        @attach_wrapper(wrapper)  # Attaches "set_level" to "wrapper" as attribute
        def set_level(new_level):  # Function that allows us to set log level
            nonlocal level
            level = new_level

        @attach_wrapper(wrapper)  # Attaches "set_message" to "wrapper" as attribute
        def set_message(new_message):  # Function that allows us to set message
            nonlocal log_message
            log_message = f"{func.__name__} - {new_message}"

        return wrapper
    return decorate

# Example Usage
@log(logging.WARN, "example-param")
def somefunc(args):
    return args

somefunc("some args")

somefunc.set_level(logging.CRITICAL)  # Change log level by accessing internal decorator function
somefunc.set_message("new-message")  # Change log message by accessing internal decorator function
somefunc("some args")

Tidak perlu dikatakan, ini mungkin mengambil sedikit masa untuk membungkus kepala anda (anda mungkin hanya menyalin-tampal dan menggunakannya). Idea di sini ialah fungsi log menerima hujah dan memberikannya kepada fungsi wrapper dalaman. Kemudian, jadikan parameter ini boleh laras dengan menambahkan fungsi aksesori yang dilampirkan pada penghias. Bagi penghias functools.wraps - jika kita tidak menggunakannya di sini, nama fungsi ( func.__name__) akan ditimpa dengan nama penghias. Tetapi ini menjadi masalah kerana kami ingin mencetak nama. Ini boleh diselesaikan dengan functools.wraps menyalin nama fungsi, docstring dan senarai argumen ke fungsi penghias.

Apa pun, berikut ialah output kod di atas. Agak kemas, kan?

2020-05-01 14:42:10,289 - __main__ - WARNING - somefunc - example-param
2020-05-01 14:42:10,289 - __main__ - CRITICAL - somefunc - new-message

__repr__Log yang lebih mudah dibaca

Penambahbaikan mudah pada kod untuk memudahkan nyahpepijat ialah menambahkan kaedah __repr__ pada kelas. Jika anda tidak biasa dengan kaedah ini, semua yang dilakukan ialah mengembalikan perwakilan rentetan contoh kelas. Amalan terbaik dengan kaedah __repr__ ialah mengeluarkan teks yang boleh digunakan untuk mencipta semula tika. Contohnya:

class Circle:
    def __init__(self, x, y, radius):
        self.x = x
        self.y = y
        self.radius = radius

    def __repr__(self):
        return f"Rectangle({self.x}, {self.y}, {self.radius})"

...
c = Circle(100, 80, 30)
repr(c)
# Circle(100, 80, 30)

Jika objek tidak diingini atau mustahil untuk diwakili seperti yang ditunjukkan di atas, maka alternatif yang baik ialah menggunakan perwakilan <...>, seperti <_io.TextIOWrapper name=&#39;somefile.txt&#39; mode=&#39;w&#39; encoding=&#39;UTF-8&#39;>.

Selain __repr__, adalah idea yang baik untuk melaksanakan kaedah __str__, yang digunakan secara lalai apabila memanggil print(instance). Menggunakan kedua-dua kaedah ini, anda boleh mendapatkan banyak maklumat hanya dengan mencetak pembolehubah.

__missing__Kaedah Kamus Dunder

Jika anda perlu melaksanakan kelas kamus tersuai atas sebarang sebab, maka apabila anda cuba mengakses beberapa kunci yang sebenarnya tidak wujud, anda mungkin mendapat ralat disebabkan olehKeyErrorTerdapat beberapa pepijat. Untuk mengelak daripada melihat sekeliling dalam kod anda untuk kehilangan kunci, anda boleh melaksanakan kaedah __missing__ khas yang akan dipanggil setiap kali KeyError dinaikkan.

class MyDict(dict):
    def __missing__(self, key):
        message = f'{key} not present in the dictionary!'
        logging.warning(message)
        return message  # Or raise some error instead

Pelaksanaan di atas sangat mudah dan hanya mengembalikan dan log mesej dengan kunci yang hilang, tetapi anda juga boleh log maklumat berharga lain untuk memberi anda maklumat tentang ralat yang berlaku dalam kod anda untuk lebih konteks.

调试崩溃的应用程序

如果你的应用程序在你有机会看到其中发生了什么之前崩溃，你可能会发现这个技巧非常有用。

-i使用参数-i ( python3 -i app.py)运行应用程序会导致它在程序退出后立即启动交互式 shell。此时你可以检查变量和函数。

如果这还不够好，可以使用更大的hammer-pdb-Python调试器。pdb有相当多的特性，可以保证文章的独立性。但这里是一个例子和最重要的部分概要。让我们先看看我们的小崩溃脚本：

# crashing_app.py
SOME_VAR = 42

class SomeError(Exception):
    pass

def func():
    raise SomeError("Something went wrong...")

func()

现在，如果我们使用-i参数运行它，我们就有机会调试它：

# Run crashing application
~ $ python3 -i crashing_app.py
Traceback (most recent call last):
  File "crashing_app.py", line 9, in <module>
    func()
  File "crashing_app.py", line 7, in func
    raise SomeError("Something went wrong...")
__main__.SomeError: Something went wrong...
>>> # We are interactive shell
>>> import pdb
>>> pdb.pm()  # start Post-Mortem debugger
> .../crashing_app.py(7)func()
-> raise SomeError("Something went wrong...")
(Pdb) # Now we are in debugger and can poke around and run some commands:
(Pdb) p SOME_VAR  # Print value of variable
42
(Pdb) l  # List surrounding code we are working with
  2
  3   class SomeError(Exception):
  4       pass
  5
  6   def func():
  7  ->     raise SomeError("Something went wrong...")
  8
  9   func()
[EOF]
(Pdb)  # Continue debugging... set breakpoints, step through the code, etc.

上面的调试会话非常简单地展示了如何使用pdb。程序终止后，我们进入交互式调试会话。首先，我们导入pdb并启动调试器。此时，我们可以使用所有pdb命令。作为上面的示例，我们使用p命令打印变量，使用l命令打印列表代码。大多数情况下，你可能希望设置断点，你可以使用b LINE_NO来设置断点，并运行程序，直到达到断点（c），然后继续使用s单步执行函数，也可以使用w打印堆栈轨迹。有关命令的完整列表，你可以转到官方pdb文档。

检查堆栈轨迹

例如，假设你的代码是在远程服务器上运行的Flask或Django应用程序，你无法在其中获得交互式调试会话。在这种情况下，你可以使用traceback和sys包来了解代码中的错误：

import traceback
import sys

def func():
    try:
        raise SomeError("Something went wrong...")
    except:
        traceback.print_exc(file=sys.stderr)

运行时，上面的代码将打印引发的最后一个异常。除了打印例外，你还可以使用traceback包打印堆栈轨迹（traceback.print_stack()）或提取原始堆栈帧，对其进行格式化并进一步检查（traceback.format_list(traceback.extract_stack())）。

在调试期间重新加载模块

有时，你可能正在调试或试验交互式shell中的某些函数，并对其进行频繁更改。为了使运行/测试和修改的循环更容易，你可以运行importlib.reload(module)以避免每次更改后重新启动交互会话：

>>> import func from module
>>> func()
"This is result..."

# Make some changes to "func"
>>> func()
"This is result..."  # Outdated result
>>> from importlib import reload; reload(module)  # Reload "module" after changes made to "func"
>>> func()
"New result..."

这个技巧更多的是关于效率而不是调试。能够跳过一些不必要的步骤，使你的工作流程更快、更高效，这总是很好的。通常，不时地重新加载模块是一个好主意，因为它可以帮助你避免调试同时已经修改过多次的代码。

Atas ialah kandungan terperinci Apakah kaedah penyahpepijatan dalam Python?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!