thats

kw.update({k: v
           for k, v in defaults.items()
           if kw.get(k) is None})

Not sure if that is more readable

You can bet that if anything is writable as a comprehension I will likely have tried doing so. In this case I thought the appearance of kw twice, outside and inside, hinders legibility.

The double appearance in the expression is inherent to the problem. Essentially what we have todto (and what the expression also says):

Update kw
with keys and values from defaults
where the key is not in kw or maps to None

The more I think about it, the more I like the comprehension 😄.

Note also that kw.get(k, None) is the same as kw.get(k).

Actually I thought the clearest was way to just drop out the Nones first, ie

    def _getdefaults(self, ignore, kw):
        """
        If some keys in the property cycle (excluding those in the set
        *ignore*) are absent or set to None in the dict *kw*, return a copy
        of the next entry in the property cycle, excluding keys in *ignore*.
        Otherwise, don't advance the property cycle, and return an empty dict.
        """
        prop_keys = self._prop_keys - ignore
        keys_no_none = {k for k, v in kw.items() if v is not None}
        if prop_keys - keys_no_none:  # Some keys in prop_keys are not in kw.
            # Copy the default dict to avoid modifying the reference held by
            # the cycler.
            default_dict = next(self.prop_cycler).copy()
            for p in ignore:
                default_dict.pop(p, None)
        else:
            default_dict = {}
        return default_dict

and

    def _setdefaults(self, defaults, kw):
        """
        Add to the dict *kw* the entries in the dict *default* that are absent
        or set to None in *kw*.
        """
        kw_no_none = {k: v for k, v in kw.items() if v is not None}
        kw.clear()
        kw.update(defaults)
        kw.update(kw_no_none)

How does that look to you?

Actually, self._setdefaults(default_dict, kw) is basically kw = {**default_dict, **kw}. So if we can replace the kw instance by a new one (which I suppose we can), we can get rid of the function alltogether. Or you could use a collections.ChainMap.

Better but still a bit verbose. It's less efficient than the comprehension, but with few keywords that probably doesn't matter.

What about replacing the function with:

def _no_none(kw):
    return {k: v for k, v in kw.items() if v is not None}

kw = {**defaults, **_no_none(kw)}

or ChainMap(defaults, _no_none(kw))?

Indeed, introducing the _no_none helper makes the whole thing much simpler. Pushed a new version.

Actually, that doesn't work: we don't want to drop all the None entries in kw, only those that are present in defaults. Those that are not in defaults should be kept.
(This is needed e.g. for the closed kwarg to fill.)

Returning to the previous version...

The function is defined just above, and it's not as if you can really guess what it does from the name, so in practice you're going to scroll up and see what it does anyways.

ok.

Was this maybe here to prevent docstring inheritance? OTOH, doesn't make much sense since the class is private and thus neither shows up in the HTML docs nor should a user encounter it in an interactive session. So probably fine.