def act(self)super(act( ( act( super applied to single-inheritance tree if such classes later grow to use more than one superclassthoughsuper can become error-proneand even unusable--it does not raise an exception for multiple inheritance treesbut will naively pick just the leftmost superclass having the method being run (technicallythe first per the mro)which may or may not be the one that you wantclass (ab)def act(self)super(act( ( act( class (ba)def act(self)super(act( ( act( add mix-in class with the same method doesn' fail on multi-inherbut picks just oneif is listed firsta act(is no longer runperhaps worsethis silently masks the fact that you should probably be selecting superclasses explicitly in this caseas we learned earlier in both this and its predecessor in other wordssuper usage may obscure common source of errors in python --one so common that it shows up again in this part' "gotchas if you may need to use direct calls laterwhy not use them earlier tooclass (ab)def act(self) act(selfb act(selfx ( act( traditional form you probably need to be more explicit here this form handles both single and multiple inher and works the same in both python and so why use the super(special case at allas we'll see in few momentsyou might also be able to address such cases by deploying super calls in every class of the tree but that' also one of the biggest downsides of super--why code it in every classwhen it' usually not neededand when using the preceding simpler traditional form in single class will usually sufficeespecially in existing code--and new code that uses existing code--this super requirement seems harshif not unrealistic much more subtlyas we'll also see aheadonce you step up to multiple inheritance calls this waythe super calls in your code might not invoke the class you expect them to they'll be routed per the mro orderwhichdepending on where else super might be usedmay invoke method in class that is not the caller' superclass at all--an the super built-in functionfor better or worse