如何让OrderedSet类支持pickle序列化？

Great question! That recursive pickle error with the OrderedSet recipe is a common gotcha thanks to its doubly linked list under the hood—pickle tries to serialize those interconnected nodes, which can trigger a RecursionError when the list gets long (or even just from the circular reference at the root). Your current fix works, but I get why calling __init__ in __setstate__ feels clunky. Here are a couple more elegant approaches:

Option 1: Use __reduce__ for Clean, Concise Serialization #

Instead of defining both __getstate__ and __setstate__, you can use the __reduce__ method to tell pickle exactly how to reconstruct your OrderedSet. This is more idiomatic and cuts down on boilerplate:

def __reduce__(self):
    # Return the class constructor and the list of elements (in order)
    return (type(self), (list(self),))

When unpickling, pickle will automatically call OrderedSet(list_of_elements) to rebuild the instance. This achieves the same result as your original fix but with far less code, and it feels more aligned with Python's pickle conventions.

Option 2: Directly Reconstruct Internal State (For Fine-Grained Control) #

If you want to avoid calling __init__ entirely (maybe your __init__ has extra logic you don't want to re-run during unpickling), you can manually rebuild the linked list and internal map in __setstate__:

def __getstate__(self):
    # Still serialize just the ordered list of elements
    return list(self)

def __setstate__(self, state):
    # Initialize the empty linked list structure
    self._root = root = _Link()
    root.prev = root.next = root
    self._map = {}
    
    # Manually add each element to rebuild the list (bypasses self.add())
    for item in state:
        if item not in self._map:
            link = _Link()
            link.key = item
            # Insert the new link at the end of the list
            last = root.prev
            last.next = link
            link.prev = last
            link.next = root
            root.prev = link
            self._map[item] = link

This skips calling self.add() and __init__, which can be slightly more efficient for large sets since you're avoiding any extra checks or logic in those methods.

Why These Work #

Both approaches avoid serializing the linked list nodes directly, which is what caused the recursive error in the first place. Instead, they serialize the minimal necessary data—the ordered list of elements—and rebuild the internal structure from scratch during unpickling.

If you're curious about why the original recursion happens: pickle tries to traverse every reference in your object, and the doubly linked list creates a chain of prev/next references that can exceed Python's recursion depth limit (especially for large sets). By serializing just the element list, you break that chain entirely.

内容的提问来源于stack exchange，提问作者vdwees