如何在 python 中pickle动态创建的嵌套类？

Question

我有一个嵌套类：

class WidgetType(object):
    
    class FloatType(object):
        pass
    
    class TextType(object):
        pass

.. 和一个引用嵌套类类型（不是它的实例）的对象，如下所示

class ObjectToPickle(object):
     def __init__(self):
         self.type = WidgetType.TextType

尝试序列化 ObjectToPickle 类的实例会导致：

PicklingError：无法 pickle

有没有办法在 python 中 pickle 嵌套类？

Answer 1

我知道这是一个非常的老问题，但除了重新构建代码的明显且最有可能正确的答案之外，我从未明确见过该问题的令人满意的解决方案。

不幸的是，做这样的事情并不总是可行的，在这种情况下，作为最后的手段，可以pickle在另一个类中定义的类的实例。

__reduce__ 函数的 python 文档< /a> 表明您可以返回

一个可调用对象，将被调用以创建该对象的初始版本。元组的下一个元素将为该可调用提供参数。

因此，您所需要的只是一个可以返回适当类的实例的对象。这个类必须本身是可挑选的（因此，必须存在于__main__级别），并且可以像这样简单：

class _NestedClassGetter(object):
    """
    When called with the containing class as the first argument, 
    and the name of the nested class as the second argument,
    returns an instance of the nested class.
    """
    def __call__(self, containing_class, class_name):
        nested_class = getattr(containing_class, class_name)
        # return an instance of a nested_class. Some more intelligence could be
        # applied for class construction if necessary.
        return nested_class()

因此剩下的就是返回适当的参数在 FloatType 的 __reduce__ 方法中：

class WidgetType(object):

    class FloatType(object):
        def __reduce__(self):
            # return a class which can return this class when called with the 
            # appropriate tuple of arguments
            return (_NestedClassGetter(), (WidgetType, self.__class__.__name__, ))

结果是一个嵌套的类，但可以对实例进行 pickle（需要进一步的工作来转储/加载 __state__ 信息，但这是根据 __reduce__ 文档相对简单）。

同样的技术（稍微修改代码）可以应用于深度嵌套的类。

一个完整的例子：

import pickle


class ParentClass(object):

    class NestedClass(object):
        def __init__(self, var1):
            self.var1 = var1

        def __reduce__(self):
            state = self.__dict__.copy()
            return (_NestedClassGetter(), 
                    (ParentClass, self.__class__.__name__, ), 
                    state,
                    )


class _NestedClassGetter(object):
    """
    When called with the containing class as the first argument, 
    and the name of the nested class as the second argument,
    returns an instance of the nested class.
    """
    def __call__(self, containing_class, class_name):
        nested_class = getattr(containing_class, class_name)

        # make an instance of a simple object (this one will do), for which we can change the
        # __class__ later on.
        nested_instance = _NestedClassGetter()

        # set the class of the instance, the __init__ will never be called on the class
        # but the original state will be set later on by pickle.
        nested_instance.__class__ = nested_class
        return nested_instance



if __name__ == '__main__':

    orig = ParentClass.NestedClass(var1=['hello', 'world'])

    pickle.dump(orig, open('simple.pickle', 'w'))

    pickled = pickle.load(open('simple.pickle', 'r'))

    print type(pickled)
    print pickled.var1

我对此的最后一点是记住其他答案所说的：

如果您有能力这样做，请考虑重构您的代码以
首先避免嵌套类。

Answer 2

pickle 模块正在尝试从模块获取 TextType 类。但由于该类是嵌套的，因此它不起作用。 jasonjs 的建议会起作用。
以下是 pickle.py 中导致错误消息的行：

    try:
        __import__(module)
        mod = sys.modules[module]
        klass = getattr(mod, name)
    except (ImportError, KeyError, AttributeError):
        raise PicklingError(
            "Can't pickle %r: it's not found as %s.%s" %
            (obj, module, name))

klass = getattr(mod, name) 当然在嵌套类情况下不起作用。为了演示发生了什么，请尝试在酸洗实例之前添加这些行：

import sys
setattr(sys.modules[__name__], 'TextType', WidgetType.TextType)

此代码将 TextType 作为属性添加到模块中。酸洗效果应该很好。不过我不建议你使用这个 hack。

Answer 3

如果您使用 dill 而不是 pickle，它就可以工作。

>>> import dill
>>> 
>>> class WidgetType(object):
...   class FloatType(object):
...     pass
...   class TextType(object):
...     pass
... 
>>> class ObjectToPickle(object):
...   def __init__(self):
...     self.type = WidgetType.TextType
... 
>>> x = ObjectToPickle()
>>> 
>>> _x = dill.dumps(x)
>>> x_ = dill.loads(_x)
>>> x_
<__main__.ObjectToPickle object at 0x10b20a250>
>>> x_.type
<class '__main__.TextType'>

在这里获取莳萝：https://github.com/uqfoundation/dill

Answer 4

在 Sage (www.sagemath.org) 中，我们有很多这种酸洗问题的实例。我们决定系统地解决这个问题的方法是将外部类放入一个特定的元类中，该元类的目标是实现和隐藏黑客行为。请注意，如果存在多个嵌套级别，这会自动通过嵌套类传播。

Answer 5

Pickle 仅适用于模块范围（顶层）中定义的类。在这种情况下，您似乎可以在模块范围中定义嵌套类，然后将它们设置为 WidgetType 的属性，假设有理由不只引用 TextType 和 FloatType在你的代码中。或者，导入它们所在的模块并使用 widget_type.TextType 和 widget_type.FloatType。

Answer 6

纳迪亚的回答相当完整——这实际上不是你想做的事情；这是你想要做的事情。您确定不能在 WidgetTypes 中使用继承而不是嵌套类吗？

使用嵌套类的唯一原因是封装紧密协作的类，您的具体示例对我来说看起来像是直接继承候选者 - 将 WidgetType 类嵌套在一起没有任何好处；将它们放在一个模块中并从基本 WidgetType 继承。

Answer 7

这似乎在较新版本的 Python 中工作得很好。我在 v3.8 中尝试过，它能够 pickle 和 unpickle 嵌套类。