使用 __setstate__ 和 __getstate__ 的简单示例

Question

我不知道 __setstate__ 和 __getstate__ 方法是做什么的，所以请帮我举一个简单的例子。

Answer 1

这是一个非常简单的 Python 示例，它应该补充 pickle 文档。

class Foo(object):
  def __init__(self, val=2):
     self.val = val
  def __getstate__(self):
     print("I'm being pickled")
     self.val *= 2
     return self.__dict__
  def __setstate__(self, d):
     print("I'm being unpickled with these values: " + repr(d))
     self.__dict__ = d
     self.val *= 3

import pickle
f = Foo()
f_data = pickle.dumps(f)
f_new = pickle.loads(f_data)

输出：

I'm being pickled
I'm being unpickled with these values: {'val': 4}

Answer 2

最小示例

getstate 产生的任何内容都会进入 setstate。它不需要是一个字典。

getstate 产生的任何内容都必须是可选取的，例如由 int、str、list 等基本内置函数组成>。

class C(object):
    def __init__(self, i):
        self.i = i
    def __getstate__(self):
        return self.i
    def __setstate__(self, i):
        self.i = i
import pickle
assert pickle.loads(pickle.dumps(C(1), -1)).i == 1

默认__setstate__

默认__setstate__采用dict。

self.__dict__ 是一个不错的选择，如 https://stackoverflow.com/a/1939384/895245< /a> ，但我们可以自己构造一个，以便更好地了解发生了什么：

class C(object):
    def __init__(self, i):
        self.i = i
    def __getstate__(self):
        return {'i': self.i}
assert pickle.loads(pickle.dumps(C(1), -1)).i == 1

默认__getstate__

类似于__setstate__。

class C(object):
    def __init__(self, i):
        self.i = i
    def __setstate__(self, d):
        self.i = d['i']
assert pickle.loads(pickle.dumps(C(1), -1)).i == 1

__slots__ 对象不具有 __dict__

如果对象具有 __slots__，则它不具有 __dict__

如果您要同时实现 get 和 setstate，默认的方式是：

class C(object):
    __slots__ = 'i'
    def __init__(self, i):
        self.i = i
    def __getstate__(self):
        return { slot: getattr(self, slot) for slot in self.__slots__ }
    def __setstate__(self, d):
        for slot in d:
            setattr(self, slot, d[slot])
assert pickle.loads(pickle.dumps(C(1), -1)).i == 1

__slots__ default get and set 需要一个元组

如果您想重用默认的 __getstate__ 或 __setstate__，则必须将元组传递为：

class C(object):
    __slots__ = 'i'
    def __init__(self, i):
        self.i = i
    def __getstate__(self):
        return (None, { slot: getattr(self, slot) for slot in self.__slots__ })
assert pickle.loads(pickle.dumps(C(1), -1)).i == 1

我不确定这是什么为了。

继承

首先看看pickling默认是有效的：

class C(object):
    def __init__(self, i):
        self.i = i
class D(C):
    def __init__(self, i, j):
        super(D, self).__init__(i)
        self.j = j
d = pickle.loads(pickle.dumps(D(1, 2), -1))
assert d.i == 1
assert d.j == 2

继承自定义__getstate__

如果没有__slots__，它很容易，因为D 的 >__dict__ 包含 C 的 __dict__，因此我们不需要触及 C > 根本：

class C(object):
    def __init__(self, i):
        self.i = i
class D(C):
    def __init__(self, i, j):
        super(D, self).__init__(i)
        self.j = j
    def __getstate__(self):
        return self.__dict__
    def __setstate__(self, d):
        self.__dict__ = d
d = pickle.loads(pickle.dumps(D(1, 2), -1))
assert d.i == 1
assert d.j == 2

继承和 __slots__

使用 __slots__，我们需要转发到基类，并且可以传递元组：

class C(object):
    __slots__ = 'i'
    def __init__(self, i):
        self.i = i
    def __getstate__(self):
        return { slot: getattr(self, slot) for slot in C.__slots__ }
    def __setstate__(self, d):
        for slot in d:
            setattr(self, slot, d[slot])

class D(C):
    __slots__ = 'j'
    def __init__(self, i, j):
        super(D, self).__init__(i)
        self.j = j
    def __getstate__(self):
        return (
            C.__getstate__(self),
            { slot: getattr(self, slot) for slot in self.__slots__ }
        )
    def __setstate__(self, ds):
        C.__setstate__(self, ds[0])
        d = ds[1]
        for slot in d:
            setattr(self, slot, d[slot])

d = pickle.loads(pickle.dumps(D(1, 2), -1))
assert d.i == 1
assert d.j == 2

不幸的是，它不是可以重用基础的默认 __getstate__ 和 __setstate__：https://groups.google.com/forum/#!topic/python-ideas/QkvOwa1-pHQ 我们被迫定义它们。

在 Python 2.7.12 上测试。 GitHub 上游。

Answer 3

这些方法用于控制 pickle 如何对对象进行 pickle 和 unpickle模块。这通常是自动处理的，因此除非您需要覆盖类的 pickle 或 unpickled 方式，否则您不需要担心它。

Answer 4

对@BrainCore 答案的澄清。实际上，您可能不想修改 __getstate__ 内的 self。相反，构造一个将被腌制的新对象，保持原始对象不变以供进一步使用。看起来是这样的：

import pickle

class Foo:
    def __init__(self, x:int=2, y:int=3):
        self.x = x
        self.y = y
        self.z = x*y

    def __getstate__(self):
        # Create a copy of __dict__ to modify values and return;
        # you could also construct a new dict (or other object) manually
        out = self.__dict__.copy()
        out["x"] *= 3
        out["y"] *= 10
        # You can remove attributes, but note they will not get set with
        # some default value in __setstate__ automatically; you would need
        # to write a custom __setstate__ method yourself; this might be
        # useful if you have unpicklable objects that need removing, or perhaps
        # an external resource that can be reloaded in __setstate__ instead of
        # pickling inside the stream
        del out["z"]
        return out

    # The default __setstate__ will update Foo's __dict__;
    # so no need for a custom implementation here if __getstate__ returns a dict;
    # Be aware that __init__ is not called by default; Foo.__new__ gets called,
    # and the empty object is modified by __setstate__

f = Foo()
f_str = pickle.dumps(f)
f2 = pickle.loads(f_str)

print("Pre-pickle:", f.x, f.y, hasattr(f,"z"))
print("Post-pickle:", f2.x, f2.y, hasattr(f2,"z"))