What Python does when you subclass a
__slots__ class is the right answer
Recently on Twitter @simonw sort of asked this question:
Trying to figure out if it's possible to create an immutable Python class who's subclasses inherit its immutability - using __slots__ on the parent class prevents attrs being set, but any child class still gets a mutable __dict__
To rephrase this, if you subclass a class that uses __slots__, by default you can freely set arbitrary attributes on instances of your subclass. Python's behavior here surprises people every so often (me included); it seems to strike a fair number of people as intuitively obvious that __slots__ should be sticky, so that if you subclass a __slots__ class, you yourself would also be a __slots__ class. In light of this, we can ask whether Python has made the right decision here or if this is basically a bug.
My answer is that this is a feature and Python has made the right choice. Let's consider the problems if things worked the other way around and __slots__ was sticky to subclasses. The obvious problem that would come up is that any subclass would have to remember to declare any new instance attributes it used in a __slots__ of its own. In other words, if you wrote this, it would fail:
class subCls(slotsCls): def __init__(self, a, b, c): super().__init__(a) self.b = b self.c = c [...]
In practice, I don't think this is a big issue by itself. Almost all Python code sets all instance variables in __init__, which means that you'd find out about the problem the moment you created an instance of the subclass, for example in your tests. Even if you only create some instance variables in __init__ and defer others to later, a single new variable would be enough to trigger the usual failure. This means you're extremely likely to trip over this right away, either in tests or in real code; you'll almost never have mysterious deferred failures.
However, it points toward the real problem, which is that classes
couldn't switch to using __slots__ without breaking subclasses.
Effectively, that you weren't using __slots__ would become part
of your class API. With Python as it is today, using or not using
__slots__ is an implementation decision that's local to your
class; you can switch back and forth without affecting anyone else
(unless outside people try to set their own attributes on your
instances, but that's not a good idea anyway). If the __slots__
nature was inherited and you switched to using __slots__ for
your own reasons, all subclasses would break just like my
example above, including completely independent people outside your
codebase who are monkey subclassing you in order to change some
of your behavior.
(You could sort of work around this with the right magic, but then you'd lose some of the memory use benefits of switching to __slots__.)
Given the long term impact of making __slots__ sticky, I think that Python made the right decision to not do so. A Python where __slots__ was sticky would be a more annoying one with more breakage as people evolved classes (and also people feeling more constrained with how they could evolve their classes).
(There would also be technical issues with a sticky __slots__ with CPython today, but those could probably be worked around.)