Wield Python's super() like a Jedi

Yes.

Yes, Python's super is more like Dylan's next-method than, say, C#'s super.

It seems to me that the example of combining built-in dictionary classes is naively optimistic. For starters, OrderedDict, as it happens, does not use super! It calls the dict super-class methods directly. Since dict happens to be the next class in the MRO, this doesn't really matter for the purpose of this example, but I can envision a scenario where some plucky programmer inherits from both OrderedCounter and some other dict subclass, and the result doesn't work because OrderedDict does the wrong thing.

And OrderedDict isn't the only one. Maybe for some reason I would like to have an OrderedCounter where all the counts default to 42. So I do this:

  class DefaultOrderedCounter(defaultdict, OrderedCounter):
      pass
  doc = DefaultOrderedCounter(lambda: 42)
  doc.update('abracadabra')

Which results in:

  Traceback (most recent call last):
    File "", line 1, in 
    File "c:\python32\lib\collections.py", line 507, in update
      _count_elements(self, iterable)
    File "c:\python32\lib\collections.py", line 63, in __setitem__
      self.__map[key] = link = Link()
  AttributeError: 'DefaultOrderedCounter' object has no attribute '_OrderedDict__map'

Whoops! Apparently defaultdict doesn't use super either. Of course a better way to do this would be to subclass DefaultOrderedCounter and just override the __missing__ method by hand, but that's not the point.

The article goes into "How to Incorporate a Non-cooperative Class", which basically says "wrap it up in a proxy class". But that's not really going to work here, since the result would be two separate dicts, with the defaultdictwrapper methods operating on one dict, and the other methods operating on the other.

Put two spaces at the beginning of a line for that line to be displayed monospaced.

  Example

Nice article, but one thing struck me when reading the code examples posted in the article: What's the use of using kwds in __init__?

    class Shape(Root):
        def __init__(self, **kwds):
            self.shapename = kwds.pop('shapename')
            super().__init__(**kwds)

    class ColoredShape(Shape):
        def __init__(self, **kwds):
            self.color = kwds.pop('color')
            super().__init__(**kwds)

I would personally just have written this somewhat similar to this:

    class Shape(Root):
        def __init__(self, shapename):
            self.shapename = shapename
            super().__init__()

    class ColoredShape(Shape):
        def __init__(self, shapename, color):
            self.shapename = shapename
            self.color = color
            super().__init__(shapename)

But then again I'm by no means what anyone could call a Python 'Jedi'. Can anyone explain to me why using kwds in this way would be better? Would it not lead to having to look up the declaration of the class for the exact names of arguments to pop() every time?