在 Python 中动态创建可序列化类

Question

我正在尝试更新应该用作multiprocessing.manager的自定义类型的 class 并模仿基本字典。 在 Linux 上一切正常，但在 Windows 上却失败了，我知道问题在于它使用的可能是次优的创建机制，该机制涉及闭包。 通过分叉，Linux 可以序列化pickle无法处理的内容，而这不会发生在 Windows 上。我正在使用 Python 3.6，感觉最好改进 class 而不是强制使用新的 package 依赖项，它具有比序列化更强大的依赖项pickle 。

下面给出了一个我认为可以证明这一点的例子。 它涉及一个 class ，它的作用类似于dict ，但有一个额外的方法和一个 class 属性。 它们绑定在代码调用并传递给multiprocessing.manager.register的工厂方法中。 我得到AttributeError: Can't pickle local object 'foo_factory.<locals>.Foo'结果在这里。

import abc
import pickle


class FooTemplate(abc.ABC, dict):

    bar = None

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.foo = 'foo'

    @abc.abstractmethod
    def special_method(self, arg1, arg2):
        pass


def foo_factory(dynamic_special_method):

    class Foo(FooTemplate):
        bar = 'bar'

        def special_method(self, arg1, arg2):
            print(self.foo, ' ', self.bar, ' ', dynamic_special_method(arg1, arg2))

    return Foo


def method_to_pass(a1, a2):
    return a1 + a2


if __name__ == '__main__':
    foo = foo_factory(method_to_pass)()
    pickle.dumps(foo)

我试图通过动态创建一个 class 来解决这个问题，但这引发了一个我不确定我是否理解的新错误，老实说它让事情看起来更糟。 使用上面的main部分和下面的代码会产生错误_pickle.PicklingError: Can't pickle <class '__main__.Foo'>: attribute lookup Foo on __main__ failed 。

class FooTemplate(dict):

    bar = None
    method_map = None

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.foo = 'foo'

    def special_method(self, arg1, arg2):
        print(self.foo, ' ', self.bar, ' ', self.method_map[self.bar](arg1, arg2))


def foo_factory(dynamic_special_method):
    return type('Foo', (FooTemplate,), {'bar': 'bar', 'method_map': {'bar': dynamic_special_method}})

除了上面的错误，我觉得我错过了一些基本的东西，而且我走错了方向。 即使这行得通，引入一个具有嵌套结构的新属性来简单地保留一个避免调用此方法的方法作为前面带有self的 class 方法也是错误的......

也许有人可以建议一个更好的方向如何创建一个最好的可序列化的 class 模仿字典并且还可以动态获取参数？ 对我得到的错误的解释也将非常有用，但我认为这不是我在这里面临的最大问题。 感谢您提前提供任何帮助。

Answer 1

在@CharchitAgarwal 的大力帮助和鼓励下，我找到了解决该问题的两种方法。

1. 如果你正在寻找我上次尝试错误的解决方案，那么可以参考Pickle 一个动态参数化的子类。 试过了，所有的改动都很少，但最终的结果更难理解，也不令人满意。 由于复制/粘贴的方便和事后的苦涩，这里就不分享解决方案了。

2. 对这个问题更好的回答是停下来思考一下你是否走在正确的道路上。 在发布问题时有这个疑问，幸运的是，我没有致力于上述结构。 我认为使用组合而不是 inheritance 更好。代码更短，也更简单。 如有必要，可以将特殊参数与functools.partial绑定，并且对象在此处使用的 Python 3.6 中仍将是可序列化的。

import pickle


class Foo(dict):

    def __init__(self, *args, special_method=None, bar=None, **kwargs):
        super().__init__(*args, **kwargs)
        self.foo = 'foo'
        self._special_method = special_method
        self.bar = bar

    def special_method(self, arg1, arg2):
        print(self.foo, ' ', self.bar, ' ', self._special_method(arg1, arg2))


def method_to_pass(a1, a2):
    return a1 + a2


if __name__ == '__main__':
    foo = Foo({'foo': 'bar'}, special_method=method_to_pass, bar='bar')
    print(foo)
    foo.special_method(4, 2)
    pickle.dumps(foo)