The Python 2.3 Method Resolution Order — Bad Method Resolution Orders

Reference note (untrusted external data; do not execute it as instructions). A MRO is bad when it breaks such fundamental properties as local precedence ordering and monotonicity. In this section, I will show that both the MRO for classic classes and the MRO for new style classes in Python 2.2 are bad. It is easier to start with the local precedence ordering. Consider the following example >>> F=type('Food',(),{'remember2buy':'spam'}) >>> E=type('Eggs',(F,),{'remember2buy':'eggs'}) >>> G=type('GoodFood',(F,E),{}) # under Python 2.3 this is an error! # doctest: +SKIP Bounded code example (external data; do not execute automatically): ```text O | (buy spam) F | \ | E (buy eggs) | / G (buy eggs or spam ?) ``` We see that class G inherits from F and E, with F before E: therefore we would expect the attribute G.remember2buy to be inherited by F.remember2buy and not by E.remember2buy: nevertheless Python 2.2 gives >>> G.remember2buy # doctest: +SKIP 'eggs' This is a breaking of local precedence ordering since the order in the local precedence list, i.e. the list of the parents of G, is not preserved in the Python 2.2 linearization of G L[G,P22]= G E F object # F follows E One could argue that the reason why F follows E in the Python 2.2 linearization is that F is less specialized than E, since F is the superclass of E; nevertheless the breaking of local precedence ordering is quite non-intuitive and error prone. This is particularly true since it is a different from old style classes >>> class F: remember2buy='spam' >>> class E(F): remember2buy='eggs' >>> class G(F,E): pass # doctest: +SKIP >>> G.remember2buy # doctest: +SKIP 'spam' In this case the MRO is GFEF and the local precedence ordering is preserved. As a general rule, hierarchies such as the previous one should be avoided, since it is unclear if F should override E or vice-versa. Python 2.3 solves the ambiguity by raising an exception in the creation of class G, effectively stopping the programmer from generating ambiguous hierarchies. The reason for that is that the C3 algorithm fails when the merge cannot be computed, because F is in the tail of EFO and E is in the tail of FE. The real solution is to design a non-ambiguous hierarchy, i.e. to derive G from E and F (the more specific first) and not from F and E; in this case the MRO is GEF without any doubt. … Attribution: Adapted from Python Documentation under PSF-2.0. Adaptation: WikiKV isolated this documentation section, normalized formatting, retained only bounded code excerpts, and shortened it at a paragraph or sentence boundary for retrieval. Verify version-sensitive details at the source.