My understanding is as follows:

• class X has no __dict__ <-------> class X and its superclasses all have __slots__ specified

• in this case, the actual slots of the class are comprised from the union of __slots__ declarations for X and its superclasses; the behavior is undefined (and will become an error) if this union is not disjoint

class WithSlots(object):
    __slots__ = "a_slot"

class NoSlots(object):       # This class has __dict__
    pass

First Item

class A(NoSlots):            # even though A has __slots__, it inherits __dict__
    __slots__ = "a_slot"     # from NoSlots, therefore __slots__ has no effect

Sixth Item

class B(WithSlots):          # This class has no __dict__
    __slots__ = "some_slot"

class C(WithSlots):          # This class has __dict__, because it doesn't
    pass                     # specify __slots__ even though the superclass does.

You probably won’t need to use __slots__ in the near future. It’s only intended to save memory at the cost of some flexibility. Unless you have tens of thousands of objects it won’t matter.

From the answer you linked:

The proper use of __slots__ is to save space in objects. Instead of having a dynamic dict…

“When inheriting from a class without __slots__, the __dict__ attribute of that class will always be accessible”, so adding your own __slots__ cannot prevent objects from having a __dict__, and cannot save space.

The bit about __slots__ not being inherited is a little obtuse. Remember that it’s a magic attribute and doesn’t behave like other attributes, then re-read that as saying this magic slots behavior isn’t inherited. (That’s really all there is to it.)

Python: How does inheritance of __slots__ in subclasses actually work?

I am thoroughly confused by the 1st and 6th items, because they seem to be contradicting each other.

Those items don’t actually contradict each other. The first regards subclasses of classes that don’t implement __slots__, the second regards subclasses of classes that do implement __slots__.

Subclasses of classes that don’t implement __slots__

I am increasingly aware that as great as the Python docs are (rightly) reputed to be, they are not perfect, especially regarding the less used features of the language. I would alter the docs as follows:

When inheriting from a class without __slots__, the __dict__ attribute
of that class will always be accessible, so a __slots__ definition in
the subclass is meaningless .

__slots__ is still meaningful for such a class. It documents the expected names of attributes of the class. It also creates slots for those attributes – they will get the faster lookups and use less space. It just allows for other attributes, which will be assigned to the __dict__.

This change has been accepted and is now in the latest documentation.

Here’s an example:

class Foo: 
    """instances have __dict__"""

class Bar(Foo):
    __slots__ = 'foo', 'bar'

Bar not only has the slots it declares, it also has Foo’s slots – which include __dict__:

>>> b = Bar()
>>> b.foo = 'foo'
>>> b.quux = 'quux'
>>> vars(b)
{'quux': 'quux'}
>>> b.foo
'foo'

Subclasses of classes that do implement __slots__

The action of a __slots__ declaration is limited to the class where it
is defined. As a result, subclasses will have a __dict__ unless they
also define __slots__ (which must only contain names of any additional
slots).

Well that’s not quite right either. The action of a __slots__ declaration is not entirely limited to the class where it is defined. They can have implications for multiple inheritance, for example.

I would change that to:

For classes in an inheritance tree that defines __slots__, subclasses will have a __dict__ unless they
also define __slots__ (which must only contain names of any additional
slots).

I have actually updated it to read:

The action of a __slots__ declaration is not limited to the class
where it is defined. __slots__ declared in parents are available in
child classes. However, child subclasses will get a __dict__ and
__weakref__ unless they also define __slots__ (which should only contain names of any additional slots).

Here’s an example:

class Foo:
    __slots__ = 'foo'

class Bar(Foo):
    """instances get __dict__ and __weakref__"""

And we see that a subclass of a slotted class gets to use the slots:

>>> b = Bar()
>>> b.foo = 'foo'
>>> b.bar = 'bar'
>>> vars(b)
{'bar': 'bar'}
>>> b.foo
'foo'

(For more on __slots__, see my answer here.)