 <p>I'm not sure to what limitations the author of the python tutorial was referring, but I would guess it has in part to do with the way that method / attribute lookup is implemented in python (the "method resolution order" or MRO). Python uses the <a href="http://en.wikipedia.org/wiki/C3_linearization">C3 superclass linearization</a> mechanism; this is to deal with what is termed to be "<a href="http://en.wikipedia.org/wiki/Diamond_problem">The Diamond Problem</a>".</p> <p>Once you've introduced multiple inheritance into your class hierarchy, any given class doesn't have a single potential class that it inherits from, it only has "the next class in the MRO", even for classes that expect that they inherit from some class in particular.</p> <p>For example, if <code>class A(object)</code>, <code>class B(A)</code>, <code>class C(A)</code>, and <code>class D(B, C)</code>, then the MRO for class <code>D</code> is <code>D-&gt;B-&gt;C-&gt;A</code>. Class B might have been written, probably was, thinking that it descends from A, and when it calls <code>super()</code> on itself, it will get a method on A. But this is no longer true; when B calls <code>super()</code>, it will get a method on C instead, if it exists.</p> <p>If you change method signatures in overridden methods this can be a problem. Class B, expecting the signature of a method from class A when it calls super, instead gets a method from C, which might not have that signature (and might or might not not implement the desired behavior, from class B's point of view).</p> <pre><code>class A(object): def __init__(self, foo): print "A!" class B(A): def __init__(self, foo, bar): print "B!" super(B, self).__init__(foo) class C(A): def __init__(self, foo, baaz): print "C!" super(C, self).__init__(foo) class D(B, C): def __init__(self, foo, bar): print "D!" super(D, self).__init__(foo, bar) print D.mro() D("foo", "bar") </code></pre> <p>In this code sample, classes B and C have reasonably extended A, and changed their <code>__init__</code> signatures, but call their expected superclass signature correctly. But when you make D like that, the effective "superclass" of B becomes C instead of A. When it calls super, things blow up:</p> <pre><code>[&lt;class '__main__.D'&gt;, &lt;class '__main__.B'&gt;, &lt;class '__main__.C'&gt;, &lt;class '__main__.A'&gt;, &lt;type 'object'&gt;] D! B! Traceback (most recent call last): File "/tmp/multi_inherit.py", line 22, in &lt;module&gt; D("foo", "bar") File "/tmp/multi_inherit.py", line 19, in __init__ super(D, self).__init__(foo, bar) File "/tmp/multi_inherit.py", line 9, in __init__ super(B, self).__init__(foo) TypeError: __init__() takes exactly 3 arguments (2 given) </code></pre> <p>This same sort of thing could happen for other methods as well (if they call <code>super()</code>), and the "diamond" doesn't have to only appear at the root of the class hierarchy.</p>