使用装饰器将字典插入 python 类

Question

我正在尝试设计一个可以接受类名（不是对象）的包装器，并将字典插入到类的每个实例中。下面是我在包装现有函数时如何实现这一点的 sn-p。

def insert_fn_into_class(cls):
    """Decorator function that consumes a function and inserts it into the cls class."""
    def decorator(func):
        @wraps(func)
        def wrapper(self, *args, **kwargs):
            return func(*args, **kwargs)
        setattr(cls, f'prefix_{func.__name__}', wrapper)

    return decorator

如何使用类似的模板来装饰字典并将其插入到 cls 类中。既然字典是不可调用的，那么如何设计这样的包装器呢？

更新

感谢您对此提出的建设性反馈。 一位 stack-overflow 用户正确地指出，我没有解释我为什么要这样做。所以这里是：

1. 我正在尝试构建一个框架，该框架本质上可以使用一堆用户定义的函数并扩展现有的类。所以我有一个类A，以及用户定义的函数f_1、f_2、...、f_n，我想将它们注入到A类中，这样这个类obj_a = A()的实例就可以调用这些函数，例如obj_a.f_1()。我已经设法使用类似于上面的代码 sn-p 的装饰器函数来实现这一点。
2. 现在，每个用户定义的函数都有一些重复的代码，如果我的基类A 的所有实例都可以访问用户定义的字典，我认为我可以删除这些代码。我实现这一目标的思考过程是尝试修改我现有的包装函数以将其添加到类中。但是，我知道字典不可调用，因此是个问题。

我希望这足够详细。

更新 2

看起来还有进一步阐述的余地。这是我之前描述的各种组件的外观示例。

module_a.py

class BaseClass():
    def __init__(self):
        ...

    def base_class_method(self):
        ...
    
    def run(self):
        getattr(self, 'prefix_user_fn_1')()

def extend(cls=BaseClass):
    def decorator(func):
        def wrapper(self, *args, **kwargs):
            return func(*args, **kwargs)
        setattr(cls, f'prefix_{func.__name__}', wrapper)
    return decorator

user_defined_functions.py

from module_a import BaseClass, extend

@extend()
def user_fn_1():
    dict_ = {'a':'b', 'c':'d'}
    ...

@extend()
def user_fn_2():
    dict_ = {'my':'dict', 'c':'d'}
    ...

main.py

from module_a import BaseClass

b = BaseClass()
b.run()

每个用户函数都包含一个常用字典的子集。为了利用这一点，我认为如果可以将其作为 BaseClass 动态注入的属性的一部分进行访问会很方便。

modified_user_defined_functions.py

# THIS WILL NOT WORK FOR OBVIOUS REASONS
from module_a import BaseClass, extend, common_config, insert_config_into_class

# @common_config ?? Is this even a good idea?
dict_ = {'my':'dict', 'a':'b', 'c':'d'}
insert_config_into_class(BaseClass, dict_)

@extend()
def user_fn_1(self):
    print(self.dict_)
    # do something with self.dict_
    ...

要合并这一点，我可能必须将BaseClass 上的运行方法更改为如下所示：

modified_module_a.py

...
class BaseClass():
    ...
    
    def run(self):
        getattr(self, 'prefix_user_fn_1')(self)

更新 3 - 潜在解决方案

def shared_config(data, cls=BaseClass):
    setattr(cls, 'SHARED_DICT', data)

这个解决方案有效，但在某种程度上回答了我的问题，我想我可以说，当一个简单的函数可能实现这一点时，我可能会通过为此编写一个装饰器来过度设计我的解决方案。

但是，原始问题的一个方面仍然存在 - 这是一个好方法吗？

Answer 1

你提问的方式给了我一个暗示，你不太明白 python 如何使用对象引用。

装饰器不适用于不可调用的对象，因此需要澄清

接受类名（不是对象）

不是很清楚。而且你想附加到类的东西没有区别——字典或函数，无论如何你只会操纵抽象引用。

除此之外，看看这个sn-p：

def patcher(cls):
    def wrapper(*args, **kwargs):
        instance = cls(*args, **kwargs)
        instance.payload = {'my': 'dict'}
         return instance
    return wrapper

@patcher
class A:
    pass

它是否满足您的需求？

Answer 2

我想我可以说我可能过度设计了我的解决方案

嗯，确实有点……FWIW the whole thing looks quite overcomplicated。

第一件事：如果你将你的 dict 定义为一个全局（模块）名称，那么该模块中的所有函数都可以直接访问它：

# simple.py

SHARED_DATA = {"foo": "bar", "answer": 42}

def func1():
    print SHARED_DATA["foo"]

def func2():
    print SHARED_DATA["bar"]

所以我并没有真正看到在从另一个模块导入的类中“注入”它的意义，只是为了从这些函数中访问它。

现在和你的装饰师一起：

def extend(cls=BaseClass):
    def decorator(func):
        def wrapper(self, *args, **kwargs):
            return func(*args, **kwargs)
        setattr(cls, f'prefix_{func.__name__}', wrapper)
    return decorator

如果目标是使函数成为类的属性但不将其转换为实例方法，则可以使用staticmethod

def extend(cls=BaseClass):
    def decorator(func):
        setattr(cls, f'prefix_{func.__name__}', staticmethod(func))
        return func
    return decorator

现在，如果您有其他（无法解释的）理由将SHARED_DICT 设为（BaseClass 或其他类的）类属性，您确实可以提供配置功能：

# module_a
def configure(cls, data):
    cls.SHARED_DATA = data


# less_simple.py

from module_a import BaseClass, configure

SHARED_DATA = {"foo": "bar", "answer": 42}
configure(BaseClass, SHARED_DATA)

def func1():
    print SHARED_DATA["foo"]

def func2():
    print SHARED_DATA["bar"]

但请注意，您仍然不需要通过 BaseClass 或 self 从模块的函数中访问此字典。

你可以当然将类或实例传递给你使用定义的函数，但在这里，不需要一个奇怪的装置 - 要么将它们设为类方法，要么直接将它们设置为类，Python 将负责将类或实例作为第一个参数注入（这里是一个使它们成为实例方法的示例）：

# module_a
def configure(cls, data):
    cls.SHARED_DATA = data

def extend(cls=BaseClass):
    def decorator(func):
        setattr(cls, f'prefix_{func.__name__}', func)
        return func
    return decorator

# rube_goldberg.py

from module_a import BaseClass, configure, extend

SHARED_DATA = {"foo": "bar", "answer": 42}
configure(BaseClass, SHARED_DATA)

@extend
def func1(self):
    print SHARED_DATA["foo"]

@extend
def func2(self):
    print SHARED_DATA["bar"]

请注意，从装饰函数 POV 来看，这仍然完全没用 - 它们根本不需要 self 来访问 SHARED_DATA，但现在它们不能在没有 BaseClass 的情况下执行实例作为第一个参数，因此用户无法直接测试它们。

现在，您的问题中可能还有其他事情没有提及，但到目前为止，您似乎正在努力使简单的事情变得复杂；-)