Nhạy cảm với Python

Question

Có thể áp dụng mã từ mô-đun đã nhập vào mô-đun nhập vào không? Ví dụ, tôi có gỡ lỗi module, nơi được xác định một số trang trí để gỡ lỗi, ví dụ:

def debug_func(f): 
    def wrapper(*func_args, **func_kwargs): 
     print(f(*func_args, **func_kwargs)) 
    return wrapper 

ý tưởng là gì: Nó sẽ có ích nếu tôi có thể chỉ

import Debug 

và tất cả các chức năng từ mô-đun hiện tại sẽ được bọc bằng trang trí. Có thể không?

Answer 1

Trong Debug.py:

import functools 
from types import FunctionType 

def wrap_functions(module_dict): 
    for k, f in module_dict.items(): 
     if not isinstance(f, FunctionType): 
      continue 
     def get_wrapper(f): 
      def wrapper(*func_args, **func_kwargs): 
       print(f(*func_args, **func_kwargs)) 
      return functools.wraps(f)(wrapper) 
     module_dict[k] = get_wrapper(f) 

Tại đáy của module bạn đang có nhu cầu để gỡ lỗi:

import Debug 
Debug.wrap_functions(globals()) 

Cảm ơn (1) cho tất cả các bình luận đã cung cấp gợi ý.

Answer 2

Tôi nghĩ rằng cách pythonic làm việc đó sẽ có gỡ lỗi của bạn gọi các module sửa lỗi, như các công cụ chuẩn (pdb, unittest, ...) với một cuộc gọi như:

$ python -m Debug mymodule.py 

Với bạn Gỡ lỗi nhập/thực hiện mô-đun với bất kỳ trình trang trí nào bạn thích. Làm theo cách khác (nhập Debug) làm rối trật tự mô-đun được đánh giá, vì bạn đang cố gắng có mô-đun Debug tùy thuộc vào mô-đun nhập khẩu, điều này rất khó.

Ngoài đi qua các chức năng của mình một cách rõ ràng (thông qua globals(), một danh sách các chức năng ...) đối với một số Debug.mark_as_debug như Jim Garrison đề nghị, tôi nghĩ rằng nó sẽ có ý nghĩa hơn đối với tổ chức mã của bạn như vậy mà bạn có thể có của bạn Debug gọi của bạn mô-đun thay vì theo cách khác.

Answer 3

Làm cách nào để Debug biết mô-đun nào được nhập từ đó? Trả lời: Nó không thể. Làm thế nào để Debug biết chạy nhiều lần nếu nó được nhập vào nhiều hơn một mô-đun? Trả lời: Nó sẽ không; các mô-đun chỉ chạy một lần và sau đó được lưu vào bộ nhớ cache. Vì vậy, những gì bạn muốn làm không thể được thực hiện khá đơn giản như bạn muốn.

Tuy nhiên, bạn có thể thực hiện việc này bằng cách gọi hàm trong mô-đun debug sau khi nhập. Bạn có thể vượt qua __name__ từ mô-đun gọi để cung cấp tên của nó, sau đó có thể lấy tham chiếu đến chính mô-đun và sau đó là các biến cấp cao nhất được xác định trong đó, một số có thể hoạt động. Những trang này sau đó có thể được trang trí.

# debug.py 
import types, sys, functools 

# decorator to be applied to all top-level functions in a module 
def debug(fn): 
    @functools.wraps(fn) 
    def wrapper(*args, **kwargs): 
     print "calling", fn.__name__, "with args", *args, **kwargs 
     result = fn(*args, **kwargs) 
     print "returning from", fn.__name__, "with return value", result 
     return result 

# decorate all top-level functions in named module with a given decorator 
# (by default it is the above decorator but it could be a different one) 
# This makes these functions behave as though they had been written with 
# @debug above them. 
def set_debug(modname, debug=debug): 
    module = sys.modules[modname] 
    for name in dir(module): 
     if not name.startswith("_"): 
      thing = getattr(module, name) 
      if isinstance(thing, types.FunctionType): 
       setattr(module, name, debug(thing)) 

Bây giờ trong module gọi:

# main.py 
import debug 

def main(): 
    print "in main module" 

debug.set_debug(__name__) # install debugging decorator 

main() 

cách tiếp cận đi qua các không gian tên một cách rõ ràng (chứ không phải là tên module) Jim Garrison cũng là tốt và thực sự đơn giản hoá mọi thứ một chút; bạn có thể sử dụng nó để trang trí những thứ khác ngoài mô-đun. Tôi đã phá vỡ của tôi lên để bạn có thể vượt qua trong một trang trí khác nhau nếu bạn muốn.