What does object.__getstate__() return for a plain instance versus a __slots__ class?

## The method itself Before 3.11, `object` had no `__getstate__`. The default state was computed by internal pickle machinery, `hasattr(obj, "__getstate__")` was `False` for an ordinary instance, and a subclass that wanted "the default, minus one field" had to reconstruct the default by hand: `self.__dict__.copy()`, plus explicit slot handling if the class had slots. Python 3.11 promoted it to a real inherited method, so `super().__getstate__()` is now the supported way to ask for the default and then adjust it. ## The three shapes ```python class Plain: def __init__(self): self.a = 1 class Slotted: __slots__ = ("b",) def __init__(self): self.b = 2 class Mixed(Slotted): def __init__(self): super().__init__() self.c = 3 print(Plain().__getstate__()) # {'a': 1} print(Slotted().__getstate__()) # (None, {'b': 2}) print(Mixed().__getstate__()) # ({'c': 3}, {'b': 2}) ``` * **Ordinary attributes only** -- the instance `__dict__`. * **Slot values present** -- a two-element tuple `(dict_or_None, slots_dict)`. The first element is the instance dict if the class also has one and it is non-empty, otherwise `None`; the second maps each *set* slot name to its value. An unset slot is simply absent from that mapping. * **Nothing set** -- `None`. That includes a slotted instance whose slots have all been deleted. ## Why the tuple exists Slot values do not live in `__dict__`; they occupy fixed storage on the instance. A single dict therefore cannot express the state of a class that has both kinds of attribute, because there would be no way to tell on restore which name goes where. The tuple keeps the two spaces separate, and the default restore path understands it: it merges the first element into `__dict__` and assigns the second element's entries with ordinary attribute assignment. That is why a class using slots pickles and unpickles correctly with no hooks written at all -- the default state already speaks the tuple form. ## The aliasing trap The dict that comes back is the **live** instance mapping: `Plain().__getstate__() is instance.__dict__` is `True`, and the first element of the tuple form is the live dict too. The modern-looking idiom ```python def __getstate__(self): state = super().__getstate__() # the live __dict__ for a plain class del state["lock"] # deletes the attribute from self return state ``` silently strips the attribute off the object being pickled. Copy first -- `dict(super().__getstate__())` for the plain case -- and remember that for the tuple form you have two mappings to copy, not one, and that the shape you get depends on whether the class has slots, so code written against one shape breaks when someone adds `__slots__` later. ## Practical guidance For a class you control with no slots, `self.__dict__.copy()` remains the clearest and most portable spelling of "the default state", and it works identically on 3.10 and 3.14. Calling `super().__getstate__()` earns its place in a mixin or base class that must produce a correct default for subclasses it has never seen -- including subclasses that may or may not use slots -- since reproducing the tuple logic by hand is exactly the kind of duplication that goes stale. Whichever spelling you choose, handle all three return shapes if the code is generic, copy before mutating, and remember the `None` case: returning it means the restore hook will not be called at all. ## Interview framing This is differentiator material rather than a gate. Nobody is marked down for not knowing the release that added the method. What does read well is the underlying model: state is the instance's data, slots live outside `__dict__` so they need their own compartment, and the default the interpreter computes is the same thing your handwritten hook is trying to approximate. ## Reading the tuple correctly Generic code that inspects the default state has to branch on all three shapes, and the order of the checks matters. Test for `None` first, because it means there is nothing to work with and, if returned as your own state, it suppresses the restore hook entirely. Then test for a tuple, which is the slots-bearing form; unpack it as `instance_dict, slot_values`, remembering that the first element may itself be `None` when the class has no instance dict or that dict is empty. Only the remaining case is a plain mapping. Code that assumes the mapping case and indexes the result with a string key will raise `TypeError` the moment somebody adds `__slots__` to the class, and that failure surfaces at dump time in whatever process happened to be serialising the object.