概述

Question

概述

我想序列化我的复杂对象。它看起来很简单，但每一步都会产生不同的问题。

最后，其他程序员还必须能够创建从父对象继承的复杂对象。对于Python 2.7和Python3.x，这个对象应该是可选择的。

我从一个简单的对象开始，并成功使用pickle.dump和pickle.load。

然后我创建了多个复杂的对象（类似但不完全相同），其中一些可以被转储，而有些则不能。

调试

pickle库knows哪些对象可以被腌制。从理论上讲，这意味着可以定制pdb以启用pickle调试。

替代序列化库

我想要一个独立于对象内容的可靠序列化。所以我搜索了其他序列化工具：

Cerealizer自我测试失败并且似乎已过时。
MessagePack，不适用于Python 3.
我尝试了JSON并得到了错误： builtins.TypeError: <lib.scan.Content object at 0x7f37f1e5da50> is not JSON serializable
我看了Marshal和Shelve，但都参考了Pickle。

深入使用泡菜

我看过How to check if an object is pickleable并没有给我答案。

我找到的最近的是How to find source of error in Python Pickle on massive object

我把它调整为：

import pickle

if _future_.isPython3():        
    class MyPickler(pickle._Pickler):        
        def save(self, obj):             
            try:
                pickle._Pickler.save(self, obj)
            except:
                print ('pick(3.x) {0} of type {1}'.format(obj, type(obj)))                  
else:
    class MyPickler (pickle.Pickler):

        def save(self, obj):         
            try:
                pickle.Pickler.save(self, obj)
            except:
                print('pick(2.x)', obj, 'of type', type(obj))

我使用以下方法调用此代码：

def save(obj, file):  
    if platform.python_implementation() == 'CPython':
        myPickler = MyPickler(file)                
        myPickler.save(obj)

我希望在引发异常之前执行保存。打印obj的内容，以便我可以确切地看到错误发生的位置。但结果是：

pick(3.x)  <class 'module'> of type <class 'type'>
pick(3.x)  <class 'module'> of type <class 'type'>
pick(3.x)  <class 'Struct'> of type <class 'type'>
pick(3.x)  <class 'site.setquit.<locals>.Quitter'> of type <class 'type'>
pick(3.x)  <class 'site.setquit.<locals>.Quitter'> of type <class 'type'>
pick(3.x)  <class 'module'> of type <class 'type'>
pick(3.x)  <class 'sys.int_info'> of type <class 'type'>
...

这只是结果的一小部分。我不理解这一点。它对我来说没有哪个细节错误。以及如何解决这个问题。

我已经看过：http://docs.python.org/3/library/pickle.html#what-can-be-pickled-and-unpickled但如果我无法检测到代码中的哪一行无法被腌制，那对我没什么帮助。

我的复杂对象中的代码按预期工作，最后将生成的代码运行为：

sys.modules['unum']

但是当腌制时，“模块”似乎没有按预期读取。

尝试解决方案

有些背景要明确我的意思。我有过工作的程序，突然没有工作。它可能是更新或其他更改资源。为他人而不是为我而且为对方工作的计划。

这是一个普遍的问题所以我想开发一个程序来检查所有类型的资源。不同种类资源的数量巨大。所以我有一个具有所有一般行为的父对象类。并且针对特定资源尽可能小的详细信息类。

这是在我的子资源课程中完成的。

必须使用不同版本f.e检查这些资源。 Python 2.7或Python 3.3 如果使用Python 2.7.5运行，则如果需要Python 2.7及更高版本，则资源有效。所以检查必须多于一个相等的值。这在自定义配置文件中指定为单个语句。每个程序都有一个特定的配置文件，它必须尽可能小才能使用。使用配置文件中的单个语句检查一个资源。

一般类约占代码的98％。特定资源和配置只占代码的2％左右。因此，添加要检查的新资源和新程序的新配置文件非常容易。

这个子资源：

class R_Sys(r_base.R_Base):
    '''
    doc : http://docs.python.org/3/library/sys.html#module-sys

    sys.modules returns only a list of imported module

    statement :
    sys.modules['psutil'] #  may return false (installed but not imported
    but the statements :
    import psutil
    sys.modules['psutil'] # will return true, now psutil is imported
    '''

    allowed_names = ('modules', 'path', 'builtin_module_names', 'stdin')

    allowed_keys_in_dict_config = ('name',)
    allowed_operators = ("R_NONE", "=", 'installed')  # installed only for modules

    class_group = 'Sys'
    module_used = sys   


    def __init__(self, check_type, group, name):
        super(R_Sys, self).__init__(check_type, group, name)

由此配置语句调用：

sc.analyse(r.R_Sys, c.ct('DETECT'), dict(name='path'))

可以成功腌制。但是使用config语句：

sc.analyse(r.R_Sys, c.ct('DETECT'),
                     dict(name='modules', tuplename='unum') )

失败了。

这意味着我认为98％的主要代码应该没问题，否则第一个声明也会失败。

子类中有类属性。这些都需要正常运行。并且在第一次调用时，转储执行得很好。我还没有加载。

Answer 1

dill有一些很好的酸洗诊断工具，其中最好的是酸洗痕迹（类似于你实施的）。

让我们构建一个复杂的对象，并探索：

>>> import dill
>>> class Foo(object):
...   @classmethod
...   def bar(self, x):
...     return self.z + x
...   def baz(self, z):
...     self.z = z
...   z = 1
...   zap = lambda self, x: x + self.bar(x)
... 
>>> f = Foo()
>>> f.zap(3)
7
>>> f.baz(7)
>>> f.z 
7

启用“pickle trace”：

>>> dill.detect.trace(True)
>>> _f = dill.dumps(f)
T2: <class '__main__.Foo'>
F2: <function _create_type at 0x10f94a668>
T1: <type 'type'>
F2: <function _load_type at 0x10f94a5f0>
T1: <type 'object'>
D2: <dict object at 0x10f96bb40>
Cm: <classmethod object at 0x10f9ad408>
T4: <type 'classmethod'>
F1: <function bar at 0x10f9aa9b0>
F2: <function _create_function at 0x10f94a6e0>
Co: <code object bar at 0x10f9a9130, file "<stdin>", line 2>
F2: <function _unmarshal at 0x10f94a578>
D1: <dict object at 0x10e8d6168>
D2: <dict object at 0x10f96b5c8>
F1: <function baz at 0x10f9aaa28>
Co: <code object baz at 0x10f9a9ab0, file "<stdin>", line 5>
D1: <dict object at 0x10e8d6168>
D2: <dict object at 0x10f969d70>
F1: <function <lambda> at 0x10f9aaaa0>
Co: <code object <lambda> at 0x10f9a9c30, file "<stdin>", line 8>
D1: <dict object at 0x10e8d6168>
D2: <dict object at 0x10f97d050>
D2: <dict object at 0x10e97b4b0>
>>> f_ = dill.loads(_f)
>>> f_.z
7

好的，dill可以腌制这个物体......所以让它变得更难。我们首先关闭跟踪。

>>> dill.detect.trace(False)
>>> 
>>> f.y = xrange(5)
>>> f.w = iter([1,2,3])
>>> 
>>> dill.pickles(f)
False

好的，现在dill失败了。那导致失败的原因是什么？如果我们深入挖掘对象f，我们可以查看所有未能腌制的对象。

>>> dill.detect.badtypes(f)
<class '__main__.Foo'>
>>> dill.detect.badtypes(f, depth=1)
{'__hash__': <type 'method-wrapper'>, '__setattr__': <type 'method-wrapper'>, '__reduce_ex__': <type 'builtin_function_or_method'>, 'baz': <type 'instancemethod'>, '__reduce__': <type 'builtin_function_or_method'>, '__str__': <type 'method-wrapper'>, '__format__': <type 'builtin_function_or_method'>, '__getattribute__': <type 'method-wrapper'>, 'zap': <type 'instancemethod'>, '__delattr__': <type 'method-wrapper'>, '__repr__': <type 'method-wrapper'>, 'w': <type 'listiterator'>, '__dict__': <type 'dict'>, '__sizeof__': <type 'builtin_function_or_method'>, '__init__': <type 'method-wrapper'>}
>>> dill.detect.badobjects(f, depth=1)
{'__hash__': <method-wrapper '__hash__' of Foo object at 0x10f9b0050>, '__setattr__': <method-wrapper '__setattr__' of Foo object at 0x10f9b0050>, '__reduce_ex__': <built-in method __reduce_ex__ of Foo object at 0x10f9b0050>, 'baz': <bound method Foo.baz of <__main__.Foo object at 0x10f9b0050>>, '__reduce__': <built-in method __reduce__ of Foo object at 0x10f9b0050>, '__str__': <method-wrapper '__str__' of Foo object at 0x10f9b0050>, '__format__': <built-in method __format__ of Foo object at 0x10f9b0050>, '__getattribute__': <method-wrapper '__getattribute__' of Foo object at 0x10f9b0050>, 'zap': <bound method Foo.<lambda> of <__main__.Foo object at 0x10f9b0050>>, '__delattr__': <method-wrapper '__delattr__' of Foo object at 0x10f9b0050>, '__repr__': <method-wrapper '__repr__' of Foo object at 0x10f9b0050>, 'w': <listiterator object at 0x10f9b0550>, '__dict__': {'y': xrange(5), 'z': 7, 'w': <listiterator object at 0x10f9b0550>}, '__sizeof__': <built-in method __sizeof__ of Foo object at 0x10f9b0050>, '__init__': <method-wrapper '__init__' of Foo object at 0x10f9b0050>}

嗯。好多啊。当然，并非所有这些对象都必须为我们的对象序列化序列化...但是至少一个导致失败。

自然要做的就是看看我们遇到的失败...... 那么，会抛出什么错误？也许这会暗示一下。

>>> dill.detect.errors(f)
PicklingError("Can't pickle <type 'listiterator'>: it's not found as __builtin__.listiterator",)

啊哈，listiterator是一个坏对象。让我们通过重新开启“追踪”来深入挖掘。

>>> dill.detect.trace(True)
>>> dill.pickles(f)
T2: <class '__main__.Foo'>
F2: <function _create_type at 0x10f94a668>
T1: <type 'type'>
F2: <function _load_type at 0x10f94a5f0>
T1: <type 'object'>
D2: <dict object at 0x10f9826e0>
Cm: <classmethod object at 0x10f9ad408>
T4: <type 'classmethod'>
F1: <function bar at 0x10f9aa9b0>
F2: <function _create_function at 0x10f94a6e0>
Co: <code object bar at 0x10f9a9130, file "<stdin>", line 2>
F2: <function _unmarshal at 0x10f94a578>
D1: <dict object at 0x10e8d6168>
D2: <dict object at 0x10f96b5c8>
F1: <function baz at 0x10f9aaa28>
Co: <code object baz at 0x10f9a9ab0, file "<stdin>", line 5>
D1: <dict object at 0x10e8d6168>
D2: <dict object at 0x10f969d70>
F1: <function <lambda> at 0x10f9aaaa0>
Co: <code object <lambda> at 0x10f9a9c30, file "<stdin>", line 8>
D1: <dict object at 0x10e8d6168>
D2: <dict object at 0x10f97d050>
D2: <dict object at 0x10e97b4b0>
Si: xrange(5)
F2: <function _eval_repr at 0x10f94acf8>
T4: <type 'listiterator'>
False

确实，它停在listiterator。但是，请注意（正好在上面）xrange确实发生了腌制。所以，让我们用iter

替换xrange

>>> f.w = xrange(1,4)  
>>> dill.detect.trace(False)
>>> dill.pickles(f)
True
>>>

我们的对象现在再次腌制。

dill内置了许多其他的pickle检测工具，包括跟踪哪些对象指向哪些方法（用于调试递归酸洗失败）。

我相信cloudpickle也有一些与dill类似的工具用于泡菜调试......但是在任何一种情况下的主要工具都与你构建的类似。

如何检查复杂对象的哪些细节不能被腌制

概述

调试

替代序列化库

深入使用泡菜

尝试解决方案

1 个答案: