be better off not deploying it in single-inheritance mode either this coding situation isn' nearly as abstract as it may seem here' real-world example of such casetaken from the pymailgui case study in programming python--the following very typical python classes use multiple inheritance to mix in both application logic and window tools from independentstandalone classesand hence must invoke both superclass constructors explicitly with direct calls by name as codeda super(__init__(here would run only one constructorand adding super throughout this example' disjoint class trees would be more workwould be no simplerand wouldn' make sense in tools meant for arbitrary deployment in clients that may use super or notclass pymailserverwindow(pymailserverwindows mainwindow)" tkwith extra protocol and mixed-in methodsdef __init__(self)windows mainwindow __init__(selfappnamesrvrnamepymailserver __init__(selfclass pymailfilewindow(pymailfilewindows popupwindow)" toplevelwith extra protocol and mixed-in methodsdef __init__(selffilename)windows popupwindow __init__(selfappnamefilenamepymailfile __init__(selffilenamethe crucial point here is that using super for just the single inheritance cases where it applies most clearly is potential source of error and confusionand means that programmers must remember two ways to accomplish the same goalwhen just one-explicit direct calls--could suffice for all cases in other wordsunless you can be sure that you will never add second superclass to class in tree over your software' entire lifespanyou cannot use super in singleinheritance mode without understanding and allowing for its much more sophisticated role in multiple-inheritance trees we'll discuss the latter aheadbut it' not optional if you deploy super at all from more practical viewit' also not clear that the trivial amount of code maintenance that this super role is envisioned to avoid fully justifies its presence in python practicesuperclass names in headers are rarely changedwhen they arethere are usually at most very small number of superclass calls to update within the class and consider thisif you add new superclass in the future that doesn' use super (as in the preceding example)you'll have to either wrap it in an adaptor proxy or augment all the super calls in your class to use the traditional explicit-name call scheme anyhow- maintenance task that seems just as likelybut perhaps more error-prone if you've grown to rely on super magic advanced class topics