985 lines
73 KiB
HTML
985 lines
73 KiB
HTML
<!DOCTYPE html>
|
||
|
||
<html lang="en" data-content_root="../">
|
||
<head>
|
||
<meta charset="utf-8" />
|
||
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
|
||
<meta property="og:title" content="The Python 2.3 Method Resolution Order" />
|
||
<meta property="og:type" content="website" />
|
||
<meta property="og:url" content="https://docs.python.org/3/howto/mro.html" />
|
||
<meta property="og:site_name" content="Python documentation" />
|
||
<meta property="og:description" content="By Michele Simionato. Abstract, This document is intended for Python programmers who want to understand the C3 Method Resolution Order used in Python 2.3. Although it is not intended for newbies, i..." />
|
||
<meta property="og:image" content="https://docs.python.org/3/_static/og-image.png" />
|
||
<meta property="og:image:alt" content="Python documentation" />
|
||
<meta name="description" content="By Michele Simionato. Abstract, This document is intended for Python programmers who want to understand the C3 Method Resolution Order used in Python 2.3. Although it is not intended for newbies, i..." />
|
||
<meta property="og:image:width" content="200">
|
||
<meta property="og:image:height" content="200">
|
||
<meta name="theme-color" content="#3776ab">
|
||
|
||
<title>The Python 2.3 Method Resolution Order — Python 3.13.3 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0">
|
||
|
||
<link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=b86133f3" />
|
||
<link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=23252803" />
|
||
<link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=5349f25f" />
|
||
|
||
<script src="../_static/documentation_options.js?v=5d57ca2d"></script>
|
||
<script src="../_static/doctools.js?v=9bcbadda"></script>
|
||
<script src="../_static/sphinx_highlight.js?v=dc90522c"></script>
|
||
|
||
<script src="../_static/sidebar.js"></script>
|
||
|
||
<link rel="search" type="application/opensearchdescription+xml"
|
||
title="Search within Python 3.13.3 documentation"
|
||
href="../_static/opensearch.xml"/>
|
||
<link rel="author" title="About these documents" href="../about.html" />
|
||
<link rel="index" title="Index" href="../genindex.html" />
|
||
<link rel="search" title="Search" href="../search.html" />
|
||
<link rel="copyright" title="Copyright" href="../copyright.html" />
|
||
<link rel="next" title="Python experimental support for free threading" href="free-threading-python.html" />
|
||
<link rel="prev" title="timer file descriptor HOWTO" href="timerfd.html" />
|
||
|
||
<link rel="canonical" href="https://docs.python.org/3/howto/mro.html">
|
||
|
||
|
||
|
||
|
||
|
||
<style>
|
||
@media only screen {
|
||
table.full-width-table {
|
||
width: 100%;
|
||
}
|
||
}
|
||
</style>
|
||
<link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css">
|
||
<link rel="shortcut icon" type="image/png" href="../_static/py.svg" />
|
||
<script type="text/javascript" src="../_static/copybutton.js"></script>
|
||
<script type="text/javascript" src="../_static/menu.js"></script>
|
||
<script type="text/javascript" src="../_static/search-focus.js"></script>
|
||
<script type="text/javascript" src="../_static/themetoggle.js"></script>
|
||
<script type="text/javascript" src="../_static/rtd_switcher.js"></script>
|
||
<meta name="readthedocs-addons-api-version" content="1">
|
||
|
||
</head>
|
||
<body>
|
||
<div class="mobile-nav">
|
||
<input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"
|
||
aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />
|
||
<nav class="nav-content" role="navigation">
|
||
<label for="menuToggler" class="toggler__label">
|
||
<span></span>
|
||
</label>
|
||
<span class="nav-items-wrapper">
|
||
<a href="https://www.python.org/" class="nav-logo">
|
||
<img src="../_static/py.svg" alt="Python logo"/>
|
||
</a>
|
||
<span class="version_switcher_placeholder"></span>
|
||
<form role="search" class="search" action="../search.html" method="get">
|
||
<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">
|
||
<path fill-rule="nonzero" fill="currentColor" d="M15.5 14h-.79l-.28-.27a6.5 6.5 0 001.48-5.34c-.47-2.78-2.79-5-5.59-5.34a6.505 6.505 0 00-7.27 7.27c.34 2.8 2.56 5.12 5.34 5.59a6.5 6.5 0 005.34-1.48l.27.28v.79l4.25 4.25c.41.41 1.08.41 1.49 0 .41-.41.41-1.08 0-1.49L15.5 14zm-6 0C7.01 14 5 11.99 5 9.5S7.01 5 9.5 5 14 7.01 14 9.5 11.99 14 9.5 14z"></path>
|
||
</svg>
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" />
|
||
<input type="submit" value="Go"/>
|
||
</form>
|
||
</span>
|
||
</nav>
|
||
<div class="menu-wrapper">
|
||
<nav class="menu" role="navigation" aria-label="main navigation">
|
||
<div class="language_switcher_placeholder"></div>
|
||
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label>
|
||
<div>
|
||
<h3><a href="../contents.html">Table of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#">The Python 2.3 Method Resolution Order</a><ul>
|
||
<li><a class="reference internal" href="#the-beginning">The beginning</a></li>
|
||
<li><a class="reference internal" href="#the-c3-method-resolution-order">The C3 Method Resolution Order</a></li>
|
||
<li><a class="reference internal" href="#examples">Examples</a></li>
|
||
<li><a class="reference internal" href="#bad-method-resolution-orders">Bad Method Resolution Orders</a></li>
|
||
<li><a class="reference internal" href="#the-end">The end</a></li>
|
||
<li><a class="reference internal" href="#resources">Resources</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
</div>
|
||
<div>
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="timerfd.html"
|
||
title="previous chapter">timer file descriptor HOWTO</a></p>
|
||
</div>
|
||
<div>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="free-threading-python.html"
|
||
title="next chapter">Python experimental support for free threading</a></p>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/main/Doc/howto/mro.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</nav>
|
||
</div>
|
||
</div>
|
||
|
||
|
||
<div class="related" role="navigation" aria-label="Related">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
accesskey="I">index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="free-threading-python.html" title="Python experimental support for free threading"
|
||
accesskey="N">next</a> |</li>
|
||
<li class="right" >
|
||
<a href="timerfd.html" title="timer file descriptor HOWTO"
|
||
accesskey="P">previous</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.13.3 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" accesskey="U">Python HOWTOs</a> »</li>
|
||
<li class="nav-item nav-item-this"><a href="">The Python 2.3 Method Resolution Order</a></li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
<li class="right">
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label> |</li>
|
||
|
||
</ul>
|
||
</div>
|
||
|
||
<div class="document">
|
||
<div class="documentwrapper">
|
||
<div class="bodywrapper">
|
||
<div class="body" role="main">
|
||
|
||
<section id="the-python-2-3-method-resolution-order">
|
||
<span id="python-2-3-mro"></span><h1>The Python 2.3 Method Resolution Order<a class="headerlink" href="#the-python-2-3-method-resolution-order" title="Link to this heading">¶</a></h1>
|
||
<div class="admonition note">
|
||
<p class="admonition-title">Note</p>
|
||
<p>This is a historical document, provided as an appendix to the official
|
||
documentation.
|
||
The Method Resolution Order discussed here was <em>introduced</em> in Python 2.3,
|
||
but it is still used in later versions – including Python 3.</p>
|
||
</div>
|
||
<p>By <a class="reference external" href="https://www.phyast.pitt.edu/~micheles/">Michele Simionato</a>.</p>
|
||
<dl class="field-list simple">
|
||
<dt class="field-odd">Abstract<span class="colon">:</span></dt>
|
||
<dd class="field-odd"><p><em>This document is intended for Python programmers who want to
|
||
understand the C3 Method Resolution Order used in Python 2.3.
|
||
Although it is not intended for newbies, it is quite pedagogical with
|
||
many worked out examples. I am not aware of other publicly available
|
||
documents with the same scope, therefore it should be useful.</em></p>
|
||
</dd>
|
||
</dl>
|
||
<p>Disclaimer:</p>
|
||
<blockquote>
|
||
<div><p><em>I donate this document to the Python Software Foundation, under the
|
||
Python 2.3 license. As usual in these circumstances, I warn the
|
||
reader that what follows</em> should <em>be correct, but I don’t give any
|
||
warranty. Use it at your own risk and peril!</em></p>
|
||
</div></blockquote>
|
||
<p>Acknowledgments:</p>
|
||
<blockquote>
|
||
<div><p><em>All the people of the Python mailing list who sent me their support.
|
||
Paul Foley who pointed out various imprecisions and made me to add the
|
||
part on local precedence ordering. David Goodger for help with the
|
||
formatting in reStructuredText. David Mertz for help with the editing.
|
||
Finally, Guido van Rossum who enthusiastically added this document to
|
||
the official Python 2.3 home-page.</em></p>
|
||
</div></blockquote>
|
||
<section id="the-beginning">
|
||
<h2>The beginning<a class="headerlink" href="#the-beginning" title="Link to this heading">¶</a></h2>
|
||
<blockquote>
|
||
<div><p><em>Felix qui potuit rerum cognoscere causas</em> – Virgilius</p>
|
||
</div></blockquote>
|
||
<p>Everything started with a post by Samuele Pedroni to the Python
|
||
development mailing list <a class="footnote-reference brackets" href="#id4" id="id1" role="doc-noteref"><span class="fn-bracket">[</span>1<span class="fn-bracket">]</span></a>. In his post, Samuele showed that the
|
||
Python 2.2 method resolution order is not monotonic and he proposed to
|
||
replace it with the C3 method resolution order. Guido agreed with his
|
||
arguments and therefore now Python 2.3 uses C3. The C3 method itself
|
||
has nothing to do with Python, since it was invented by people working
|
||
on Dylan and it is described in a paper intended for lispers <a class="footnote-reference brackets" href="#id5" id="id2" role="doc-noteref"><span class="fn-bracket">[</span>2<span class="fn-bracket">]</span></a>. The
|
||
present paper gives a (hopefully) readable discussion of the C3
|
||
algorithm for Pythonistas who want to understand the reasons for the
|
||
change.</p>
|
||
<p>First of all, let me point out that what I am going to say only applies
|
||
to the <em>new style classes</em> introduced in Python 2.2: <em>classic classes</em>
|
||
maintain their old method resolution order, depth first and then left to
|
||
right. Therefore, there is no breaking of old code for classic classes;
|
||
and even if in principle there could be breaking of code for Python 2.2
|
||
new style classes, in practice the cases in which the C3 resolution
|
||
order differs from the Python 2.2 method resolution order are so rare
|
||
that no real breaking of code is expected. Therefore:</p>
|
||
<blockquote>
|
||
<div><p><em>Don’t be scared!</em></p>
|
||
</div></blockquote>
|
||
<p>Moreover, unless you make strong use of multiple inheritance and you
|
||
have non-trivial hierarchies, you don’t need to understand the C3
|
||
algorithm, and you can easily skip this paper. On the other hand, if
|
||
you really want to know how multiple inheritance works, then this paper
|
||
is for you. The good news is that things are not as complicated as you
|
||
might expect.</p>
|
||
<p>Let me begin with some basic definitions.</p>
|
||
<ol class="arabic simple">
|
||
<li><p>Given a class C in a complicated multiple inheritance hierarchy, it
|
||
is a non-trivial task to specify the order in which methods are
|
||
overridden, i.e. to specify the order of the ancestors of C.</p></li>
|
||
<li><p>The list of the ancestors of a class C, including the class itself,
|
||
ordered from the nearest ancestor to the furthest, is called the
|
||
class precedence list or the <em>linearization</em> of C.</p></li>
|
||
<li><p>The <em>Method Resolution Order</em> (MRO) is the set of rules that
|
||
construct the linearization. In the Python literature, the idiom
|
||
“the MRO of C” is also used as a synonymous for the linearization of
|
||
the class C.</p></li>
|
||
<li><p>For instance, in the case of single inheritance hierarchy, if C is a
|
||
subclass of C1, and C1 is a subclass of C2, then the linearization of
|
||
C is simply the list [C, C1 , C2]. However, with multiple
|
||
inheritance hierarchies, the construction of the linearization is
|
||
more cumbersome, since it is more difficult to construct a
|
||
linearization that respects <em>local precedence ordering</em> and
|
||
<em>monotonicity</em>.</p></li>
|
||
<li><p>I will discuss the local precedence ordering later, but I can give
|
||
the definition of monotonicity here. A MRO is monotonic when the
|
||
following is true: <em>if C1 precedes C2 in the linearization of C,
|
||
then C1 precedes C2 in the linearization of any subclass of C</em>.
|
||
Otherwise, the innocuous operation of deriving a new class could
|
||
change the resolution order of methods, potentially introducing very
|
||
subtle bugs. Examples where this happens will be shown later.</p></li>
|
||
<li><p>Not all classes admit a linearization. There are cases, in
|
||
complicated hierarchies, where it is not possible to derive a class
|
||
such that its linearization respects all the desired properties.</p></li>
|
||
</ol>
|
||
<p>Here I give an example of this situation. Consider the hierarchy</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">O</span> <span class="o">=</span> <span class="nb">object</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">X</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">Y</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">Y</span><span class="p">,</span><span class="n">X</span><span class="p">):</span> <span class="k">pass</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>which can be represented with the following inheritance graph, where I
|
||
have denoted with O the <code class="docutils literal notranslate"><span class="pre">object</span></code> class, which is the beginning of any
|
||
hierarchy for new style classes:</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span> -----------
|
||
| |
|
||
| O |
|
||
| / \ |
|
||
- X Y /
|
||
| / | /
|
||
| / |/
|
||
A B
|
||
\ /
|
||
?
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>In this case, it is not possible to derive a new class C from A and B,
|
||
since X precedes Y in A, but Y precedes X in B, therefore the method
|
||
resolution order would be ambiguous in C.</p>
|
||
<p>Python 2.3 raises an exception in this situation (TypeError: MRO
|
||
conflict among bases Y, X) forbidding the naive programmer from creating
|
||
ambiguous hierarchies. Python 2.2 instead does not raise an exception,
|
||
but chooses an <em>ad hoc</em> ordering (CABXYO in this case).</p>
|
||
</section>
|
||
<section id="the-c3-method-resolution-order">
|
||
<h2>The C3 Method Resolution Order<a class="headerlink" href="#the-c3-method-resolution-order" title="Link to this heading">¶</a></h2>
|
||
<p>Let me introduce a few simple notations which will be useful for the
|
||
following discussion. I will use the shortcut notation:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">C1</span> <span class="n">C2</span> <span class="o">...</span> <span class="n">CN</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>to indicate the list of classes [C1, C2, … , CN].</p>
|
||
<p>The <em>head</em> of the list is its first element:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">head</span> <span class="o">=</span> <span class="n">C1</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>whereas the <em>tail</em> is the rest of the list:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">tail</span> <span class="o">=</span> <span class="n">C2</span> <span class="o">...</span> <span class="n">CN</span><span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>I shall also use the notation:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">C</span> <span class="o">+</span> <span class="p">(</span><span class="n">C1</span> <span class="n">C2</span> <span class="o">...</span> <span class="n">CN</span><span class="p">)</span> <span class="o">=</span> <span class="n">C</span> <span class="n">C1</span> <span class="n">C2</span> <span class="o">...</span> <span class="n">CN</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>to denote the sum of the lists [C] + [C1, C2, … ,CN].</p>
|
||
<p>Now I can explain how the MRO works in Python 2.3.</p>
|
||
<p>Consider a class C in a multiple inheritance hierarchy, with C
|
||
inheriting from the base classes B1, B2, … , BN. We want to
|
||
compute the linearization L[C] of the class C. The rule is the
|
||
following:</p>
|
||
<blockquote>
|
||
<div><p><em>the linearization of C is the sum of C plus the merge of the
|
||
linearizations of the parents and the list of the parents.</em></p>
|
||
</div></blockquote>
|
||
<p>In symbolic notation:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">C</span><span class="p">(</span><span class="n">B1</span> <span class="o">...</span> <span class="n">BN</span><span class="p">)]</span> <span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">L</span><span class="p">[</span><span class="n">B1</span><span class="p">]</span> <span class="o">...</span> <span class="n">L</span><span class="p">[</span><span class="n">BN</span><span class="p">],</span> <span class="n">B1</span> <span class="o">...</span> <span class="n">BN</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>In particular, if C is the <code class="docutils literal notranslate"><span class="pre">object</span></code> class, which has no parents, the
|
||
linearization is trivial:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="nb">object</span><span class="p">]</span> <span class="o">=</span> <span class="nb">object</span><span class="o">.</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>However, in general one has to compute the merge according to the following
|
||
prescription:</p>
|
||
<blockquote>
|
||
<div><p><em>take the head of the first list, i.e L[B1][0]; if this head is not in
|
||
the tail of any of the other lists, then add it to the linearization
|
||
of C and remove it from the lists in the merge, otherwise look at the
|
||
head of the next list and take it, if it is a good head. Then repeat
|
||
the operation until all the class are removed or it is impossible to
|
||
find good heads. In this case, it is impossible to construct the
|
||
merge, Python 2.3 will refuse to create the class C and will raise an
|
||
exception.</em></p>
|
||
</div></blockquote>
|
||
<p>This prescription ensures that the merge operation <em>preserves</em> the
|
||
ordering, if the ordering can be preserved. On the other hand, if the
|
||
order cannot be preserved (as in the example of serious order
|
||
disagreement discussed above) then the merge cannot be computed.</p>
|
||
<p>The computation of the merge is trivial if C has only one parent
|
||
(single inheritance); in this case:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">C</span><span class="p">(</span><span class="n">B</span><span class="p">)]</span> <span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">L</span><span class="p">[</span><span class="n">B</span><span class="p">],</span><span class="n">B</span><span class="p">)</span> <span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">L</span><span class="p">[</span><span class="n">B</span><span class="p">]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>However, in the case of multiple inheritance things are more cumbersome
|
||
and I don’t expect you can understand the rule without a couple of
|
||
examples ;-)</p>
|
||
</section>
|
||
<section id="examples">
|
||
<h2>Examples<a class="headerlink" href="#examples" title="Link to this heading">¶</a></h2>
|
||
<p>First example. Consider the following hierarchy:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">O</span> <span class="o">=</span> <span class="nb">object</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">F</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">F</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">E</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">B</span><span class="p">,</span><span class="n">C</span><span class="p">):</span> <span class="k">pass</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>In this case the inheritance graph can be drawn as:</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span> 6
|
||
---
|
||
Level 3 | O | (more general)
|
||
/ --- \
|
||
/ | \ |
|
||
/ | \ |
|
||
/ | \ |
|
||
--- --- --- |
|
||
Level 2 3 | D | 4| E | | F | 5 |
|
||
--- --- --- |
|
||
\ \ _ / | |
|
||
\ / \ _ | |
|
||
\ / \ | |
|
||
--- --- |
|
||
Level 1 1 | B | | C | 2 |
|
||
--- --- |
|
||
\ / |
|
||
\ / \ /
|
||
---
|
||
Level 0 0 | A | (more specialized)
|
||
---
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>The linearizations of O,D,E and F are trivial:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">O</span><span class="p">]</span> <span class="o">=</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="o">=</span> <span class="n">D</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="o">=</span> <span class="n">E</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">F</span><span class="p">]</span> <span class="o">=</span> <span class="n">F</span> <span class="n">O</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The linearization of B can be computed as:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="o">=</span> <span class="n">B</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">DO</span><span class="p">,</span> <span class="n">EO</span><span class="p">,</span> <span class="n">DE</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>We see that D is a good head, therefore we take it and we are reduced to
|
||
compute <code class="docutils literal notranslate"><span class="pre">merge(O,EO,E)</span></code>. Now O is not a good head, since it is in the
|
||
tail of the sequence EO. In this case the rule says that we have to
|
||
skip to the next sequence. Then we see that E is a good head; we take
|
||
it and we are reduced to compute <code class="docutils literal notranslate"><span class="pre">merge(O,O)</span></code> which gives O. Therefore:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="o">=</span> <span class="n">B</span> <span class="n">D</span> <span class="n">E</span> <span class="n">O</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Using the same procedure one finds:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">DO</span><span class="p">,</span><span class="n">FO</span><span class="p">,</span><span class="n">DF</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">D</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">O</span><span class="p">,</span><span class="n">FO</span><span class="p">,</span><span class="n">F</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">D</span> <span class="o">+</span> <span class="n">F</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">O</span><span class="p">,</span><span class="n">O</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">C</span> <span class="n">D</span> <span class="n">F</span> <span class="n">O</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Now we can compute:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">A</span><span class="p">]</span> <span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">BDEO</span><span class="p">,</span><span class="n">CDFO</span><span class="p">,</span><span class="n">BC</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">B</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">DEO</span><span class="p">,</span><span class="n">CDFO</span><span class="p">,</span><span class="n">C</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">B</span> <span class="o">+</span> <span class="n">C</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">DEO</span><span class="p">,</span><span class="n">DFO</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">B</span> <span class="o">+</span> <span class="n">C</span> <span class="o">+</span> <span class="n">D</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">EO</span><span class="p">,</span><span class="n">FO</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">B</span> <span class="o">+</span> <span class="n">C</span> <span class="o">+</span> <span class="n">D</span> <span class="o">+</span> <span class="n">E</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">O</span><span class="p">,</span><span class="n">FO</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">A</span> <span class="o">+</span> <span class="n">B</span> <span class="o">+</span> <span class="n">C</span> <span class="o">+</span> <span class="n">D</span> <span class="o">+</span> <span class="n">E</span> <span class="o">+</span> <span class="n">F</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">O</span><span class="p">,</span><span class="n">O</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">A</span> <span class="n">B</span> <span class="n">C</span> <span class="n">D</span> <span class="n">E</span> <span class="n">F</span> <span class="n">O</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>In this example, the linearization is ordered in a pretty nice way
|
||
according to the inheritance level, in the sense that lower levels (i.e.
|
||
more specialized classes) have higher precedence (see the inheritance
|
||
graph). However, this is not the general case.</p>
|
||
<p>I leave as an exercise for the reader to compute the linearization for
|
||
my second example:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">O</span> <span class="o">=</span> <span class="nb">object</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">F</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">F</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">E</span><span class="p">,</span><span class="n">D</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">B</span><span class="p">,</span><span class="n">C</span><span class="p">):</span> <span class="k">pass</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>The only difference with the previous example is the change B(D,E) –>
|
||
B(E,D); however even such a little modification completely changes the
|
||
ordering of the hierarchy:</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span> 6
|
||
---
|
||
Level 3 | O |
|
||
/ --- \
|
||
/ | \
|
||
/ | \
|
||
/ | \
|
||
--- --- ---
|
||
Level 2 2 | E | 4 | D | | F | 5
|
||
--- --- ---
|
||
\ / \ /
|
||
\ / \ /
|
||
\ / \ /
|
||
--- ---
|
||
Level 1 1 | B | | C | 3
|
||
--- ---
|
||
\ /
|
||
\ /
|
||
---
|
||
Level 0 0 | A |
|
||
---
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>Notice that the class E, which is in the second level of the hierarchy,
|
||
precedes the class C, which is in the first level of the hierarchy, i.e.
|
||
E is more specialized than C, even if it is in a higher level.</p>
|
||
<p>A lazy programmer can obtain the MRO directly from Python 2.2, since in
|
||
this case it coincides with the Python 2.3 linearization. It is enough
|
||
to invoke the <a class="reference internal" href="../reference/datamodel.html#type.mro" title="type.mro"><code class="xref py py-meth docutils literal notranslate"><span class="pre">mro()</span></code></a> method of class A:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">A</span><span class="o">.</span><span class="n">mro</span><span class="p">()</span>
|
||
<span class="go">[<class 'A'>, <class 'B'>, <class 'E'>,</span>
|
||
<span class="go"><class 'C'>, <class 'D'>, <class 'F'>,</span>
|
||
<span class="go"><class 'object'>]</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Finally, let me consider the example discussed in the first section,
|
||
involving a serious order disagreement. In this case, it is
|
||
straightforward to compute the linearizations of O, X, Y, A and B:</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span>L[O] = 0
|
||
L[X] = X O
|
||
L[Y] = Y O
|
||
L[A] = A X Y O
|
||
L[B] = B Y X O
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>However, it is impossible to compute the linearization for a class C
|
||
that inherits from A and B:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">AXYO</span><span class="p">,</span> <span class="n">BYXO</span><span class="p">,</span> <span class="n">AB</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">A</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">XYO</span><span class="p">,</span> <span class="n">BYXO</span><span class="p">,</span> <span class="n">B</span><span class="p">)</span>
|
||
<span class="o">=</span> <span class="n">C</span> <span class="o">+</span> <span class="n">A</span> <span class="o">+</span> <span class="n">B</span> <span class="o">+</span> <span class="n">merge</span><span class="p">(</span><span class="n">XYO</span><span class="p">,</span> <span class="n">YXO</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>At this point we cannot merge the lists XYO and YXO, since X is in the
|
||
tail of YXO whereas Y is in the tail of XYO: therefore there are no
|
||
good heads and the C3 algorithm stops. Python 2.3 raises an error and
|
||
refuses to create the class C.</p>
|
||
</section>
|
||
<section id="bad-method-resolution-orders">
|
||
<h2>Bad Method Resolution Orders<a class="headerlink" href="#bad-method-resolution-orders" title="Link to this heading">¶</a></h2>
|
||
<p>A MRO is <em>bad</em> 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.</p>
|
||
<p>It is easier to start with the local precedence ordering. Consider the
|
||
following example:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">F</span><span class="o">=</span><span class="nb">type</span><span class="p">(</span><span class="s1">'Food'</span><span class="p">,(),{</span><span class="s1">'remember2buy'</span><span class="p">:</span><span class="s1">'spam'</span><span class="p">})</span>
|
||
<span class="gp">>>> </span><span class="n">E</span><span class="o">=</span><span class="nb">type</span><span class="p">(</span><span class="s1">'Eggs'</span><span class="p">,(</span><span class="n">F</span><span class="p">,),{</span><span class="s1">'remember2buy'</span><span class="p">:</span><span class="s1">'eggs'</span><span class="p">})</span>
|
||
<span class="gp">>>> </span><span class="n">G</span><span class="o">=</span><span class="nb">type</span><span class="p">(</span><span class="s1">'GoodFood'</span><span class="p">,(</span><span class="n">F</span><span class="p">,</span><span class="n">E</span><span class="p">),{})</span> <span class="c1"># under Python 2.3 this is an error!</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>with inheritance diagram</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span> O
|
||
|
|
||
(buy spam) F
|
||
| \
|
||
| E (buy eggs)
|
||
| /
|
||
G
|
||
|
||
(buy eggs or spam ?)
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>We see that class G inherits from F and E, with F <em>before</em> E: therefore
|
||
we would expect the attribute <em>G.remember2buy</em> to be inherited by
|
||
<em>F.remember2buy</em> and not by <em>E.remember2buy</em>: nevertheless Python 2.2
|
||
gives</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">remember2buy</span>
|
||
<span class="go">'eggs'</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>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:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">G</span><span class="p">,</span><span class="n">P22</span><span class="p">]</span><span class="o">=</span> <span class="n">G</span> <span class="n">E</span> <span class="n">F</span> <span class="nb">object</span> <span class="c1"># F *follows* E</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>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:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">F</span><span class="p">:</span> <span class="n">remember2buy</span><span class="o">=</span><span class="s1">'spam'</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="n">F</span><span class="p">):</span> <span class="n">remember2buy</span><span class="o">=</span><span class="s1">'eggs'</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">G</span><span class="p">(</span><span class="n">F</span><span class="p">,</span><span class="n">E</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="n">G</span><span class="o">.</span><span class="n">remember2buy</span>
|
||
<span class="go">'spam'</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>In this case the MRO is GFEF and the local precedence ordering is
|
||
preserved.</p>
|
||
<p>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:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">merge</span><span class="p">(</span><span class="n">FO</span><span class="p">,</span><span class="n">EFO</span><span class="p">,</span><span class="n">FE</span><span class="p">)</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>cannot be computed, because F is in the tail of EFO and E is in the tail
|
||
of FE.</p>
|
||
<p>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.</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span> O
|
||
|
|
||
F (spam)
|
||
/ |
|
||
(eggs) E |
|
||
\ |
|
||
G
|
||
(eggs, no doubt)
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>Python 2.3 forces the programmer to write good hierarchies (or, at
|
||
least, less error-prone ones).</p>
|
||
<p>On a related note, let me point out that the Python 2.3 algorithm is
|
||
smart enough to recognize obvious mistakes, as the duplication of
|
||
classes in the list of parents:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="n">A</span><span class="p">):</span> <span class="k">pass</span> <span class="c1"># error</span>
|
||
<span class="gt">Traceback (most recent call last):</span>
|
||
File <span class="nb">"<stdin>"</span>, line <span class="m">1</span>, in <span class="n">?</span>
|
||
<span class="gr">TypeError</span>: <span class="n">duplicate base class A</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Python 2.2 (both for classic classes and new style classes) in this
|
||
situation, would not raise any exception.</p>
|
||
<p>Finally, I would like to point out two lessons we have learned from this
|
||
example:</p>
|
||
<ol class="arabic simple">
|
||
<li><p>despite the name, the MRO determines the resolution order of
|
||
attributes, not only of methods;</p></li>
|
||
<li><p>the default food for Pythonistas is spam ! (but you already knew
|
||
that ;-)</p></li>
|
||
</ol>
|
||
<p>Having discussed the issue of local precedence ordering, let me now
|
||
consider the issue of monotonicity. My goal is to show that neither the
|
||
MRO for classic classes nor that for Python 2.2 new style classes is
|
||
monotonic.</p>
|
||
<p>To prove that the MRO for classic classes is non-monotonic is rather
|
||
trivial, it is enough to look at the diamond diagram:</p>
|
||
<blockquote>
|
||
<div><div class="highlight-text notranslate"><div class="highlight"><pre><span></span> C
|
||
/ \
|
||
/ \
|
||
A B
|
||
\ /
|
||
\ /
|
||
D
|
||
</pre></div>
|
||
</div>
|
||
</div></blockquote>
|
||
<p>One easily discerns the inconsistency:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">B</span><span class="p">,</span><span class="n">P21</span><span class="p">]</span> <span class="o">=</span> <span class="n">B</span> <span class="n">C</span> <span class="c1"># B precedes C : B's methods win</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">D</span><span class="p">,</span><span class="n">P21</span><span class="p">]</span> <span class="o">=</span> <span class="n">D</span> <span class="n">A</span> <span class="n">C</span> <span class="n">B</span> <span class="n">C</span> <span class="c1"># B follows C : C's methods win!</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>On the other hand, there are no problems with the Python 2.2 and 2.3
|
||
MROs, they give both:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="o">=</span> <span class="n">D</span> <span class="n">A</span> <span class="n">B</span> <span class="n">C</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Guido points out in his essay <a class="footnote-reference brackets" href="#id6" id="id3" role="doc-noteref"><span class="fn-bracket">[</span>3<span class="fn-bracket">]</span></a> that the classic MRO is not so bad in
|
||
practice, since one can typically avoids diamonds for classic classes.
|
||
But all new style classes inherit from <code class="docutils literal notranslate"><span class="pre">object</span></code>, therefore diamonds are
|
||
unavoidable and inconsistencies shows up in every multiple inheritance
|
||
graph.</p>
|
||
<p>The MRO of Python 2.2 makes breaking monotonicity difficult, but not
|
||
impossible. The following example, originally provided by Samuele
|
||
Pedroni, shows that the MRO of Python 2.2 is non-monotonic:</p>
|
||
<div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">K1</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">,</span><span class="n">C</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">K2</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">B</span><span class="p">,</span><span class="n">E</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">K3</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">A</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="gp">>>> </span><span class="k">class</span><span class="w"> </span><span class="nc">Z</span><span class="p">(</span><span class="n">K1</span><span class="p">,</span><span class="n">K2</span><span class="p">,</span><span class="n">K3</span><span class="p">):</span> <span class="k">pass</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Here are the linearizations according to the C3 MRO (the reader should
|
||
verify these linearizations as an exercise and draw the inheritance
|
||
diagram ;-)</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">A</span><span class="p">]</span> <span class="o">=</span> <span class="n">A</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">B</span><span class="p">]</span> <span class="o">=</span> <span class="n">B</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">C</span><span class="p">]</span> <span class="o">=</span> <span class="n">C</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">D</span><span class="p">]</span> <span class="o">=</span> <span class="n">D</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">E</span><span class="p">]</span> <span class="o">=</span> <span class="n">E</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">K1</span><span class="p">]</span><span class="o">=</span> <span class="n">K1</span> <span class="n">A</span> <span class="n">B</span> <span class="n">C</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">K2</span><span class="p">]</span><span class="o">=</span> <span class="n">K2</span> <span class="n">D</span> <span class="n">B</span> <span class="n">E</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">K3</span><span class="p">]</span><span class="o">=</span> <span class="n">K3</span> <span class="n">D</span> <span class="n">A</span> <span class="n">O</span>
|
||
<span class="n">L</span><span class="p">[</span><span class="n">Z</span><span class="p">]</span> <span class="o">=</span> <span class="n">Z</span> <span class="n">K1</span> <span class="n">K2</span> <span class="n">K3</span> <span class="n">D</span> <span class="n">A</span> <span class="n">B</span> <span class="n">C</span> <span class="n">E</span> <span class="n">O</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>Python 2.2 gives exactly the same linearizations for A, B, C, D, E, K1,
|
||
K2 and K3, but a different linearization for Z:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="n">L</span><span class="p">[</span><span class="n">Z</span><span class="p">,</span><span class="n">P22</span><span class="p">]</span> <span class="o">=</span> <span class="n">Z</span> <span class="n">K1</span> <span class="n">K3</span> <span class="n">A</span> <span class="n">K2</span> <span class="n">D</span> <span class="n">B</span> <span class="n">C</span> <span class="n">E</span> <span class="n">O</span>
|
||
</pre></div>
|
||
</div>
|
||
<p>It is clear that this linearization is <em>wrong</em>, since A comes before D
|
||
whereas in the linearization of K3 A comes <em>after</em> D. In other words, in
|
||
K3 methods derived by D override methods derived by A, but in Z, which
|
||
still is a subclass of K3, methods derived by A override methods derived
|
||
by D! This is a violation of monotonicity. Moreover, the Python 2.2
|
||
linearization of Z is also inconsistent with local precedence ordering,
|
||
since the local precedence list of the class Z is [K1, K2, K3] (K2
|
||
precedes K3), whereas in the linearization of Z K2 <em>follows</em> K3. These
|
||
problems explain why the 2.2 rule has been dismissed in favor of the C3
|
||
rule.</p>
|
||
</section>
|
||
<section id="the-end">
|
||
<h2>The end<a class="headerlink" href="#the-end" title="Link to this heading">¶</a></h2>
|
||
<p>This section is for the impatient reader, who skipped all the previous
|
||
sections and jumped immediately to the end. This section is for the
|
||
lazy programmer too, who didn’t want to exercise her/his brain.
|
||
Finally, it is for the programmer with some hubris, otherwise s/he would
|
||
not be reading a paper on the C3 method resolution order in multiple
|
||
inheritance hierarchies ;-) These three virtues taken all together (and
|
||
<em>not</em> separately) deserve a prize: the prize is a short Python 2.2
|
||
script that allows you to compute the 2.3 MRO without risk to your
|
||
brain. Simply change the last line to play with the various examples I
|
||
have discussed in this paper.:</p>
|
||
<div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="c1">#<mro.py></span>
|
||
|
||
<span class="sd">"""C3 algorithm by Samuele Pedroni (with readability enhanced by me)."""</span>
|
||
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">__metaclass__</span><span class="p">(</span><span class="nb">type</span><span class="p">):</span>
|
||
<span class="s2">"All classes are metamagically modified to be nicely printed"</span>
|
||
<span class="fm">__repr__</span> <span class="o">=</span> <span class="k">lambda</span> <span class="bp">cls</span><span class="p">:</span> <span class="bp">cls</span><span class="o">.</span><span class="vm">__name__</span>
|
||
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">ex_2</span><span class="p">:</span>
|
||
<span class="s2">"Serious order disagreement"</span> <span class="c1">#From Guido</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">O</span><span class="p">:</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">X</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">Y</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">X</span><span class="p">,</span><span class="n">Y</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">Y</span><span class="p">,</span><span class="n">X</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">try</span><span class="p">:</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">Z</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">):</span> <span class="k">pass</span> <span class="c1">#creates Z(A,B) in Python 2.2</span>
|
||
<span class="k">except</span> <span class="ne">TypeError</span><span class="p">:</span>
|
||
<span class="k">pass</span> <span class="c1"># Z(A,B) cannot be created in Python 2.3</span>
|
||
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">ex_5</span><span class="p">:</span>
|
||
<span class="s2">"My first example"</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">O</span><span class="p">:</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">F</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">F</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">E</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">B</span><span class="p">,</span><span class="n">C</span><span class="p">):</span> <span class="k">pass</span>
|
||
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">ex_6</span><span class="p">:</span>
|
||
<span class="s2">"My second example"</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">O</span><span class="p">:</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">F</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">F</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">E</span><span class="p">,</span><span class="n">D</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">B</span><span class="p">,</span><span class="n">C</span><span class="p">):</span> <span class="k">pass</span>
|
||
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">ex_9</span><span class="p">:</span>
|
||
<span class="s2">"Difference between Python 2.2 MRO and C3"</span> <span class="c1">#From Samuele</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">O</span><span class="p">:</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">A</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">B</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">C</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">D</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">E</span><span class="p">(</span><span class="n">O</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">K1</span><span class="p">(</span><span class="n">A</span><span class="p">,</span><span class="n">B</span><span class="p">,</span><span class="n">C</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">K2</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">B</span><span class="p">,</span><span class="n">E</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">K3</span><span class="p">(</span><span class="n">D</span><span class="p">,</span><span class="n">A</span><span class="p">):</span> <span class="k">pass</span>
|
||
<span class="k">class</span><span class="w"> </span><span class="nc">Z</span><span class="p">(</span><span class="n">K1</span><span class="p">,</span><span class="n">K2</span><span class="p">,</span><span class="n">K3</span><span class="p">):</span> <span class="k">pass</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">merge</span><span class="p">(</span><span class="n">seqs</span><span class="p">):</span>
|
||
<span class="nb">print</span> <span class="s1">'</span><span class="se">\n\n</span><span class="s1">CPL[</span><span class="si">%s</span><span class="s1">]=</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">seqs</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span><span class="n">seqs</span><span class="p">),</span>
|
||
<span class="n">res</span> <span class="o">=</span> <span class="p">[];</span> <span class="n">i</span><span class="o">=</span><span class="mi">0</span>
|
||
<span class="k">while</span> <span class="mi">1</span><span class="p">:</span>
|
||
<span class="n">nonemptyseqs</span><span class="o">=</span><span class="p">[</span><span class="n">seq</span> <span class="k">for</span> <span class="n">seq</span> <span class="ow">in</span> <span class="n">seqs</span> <span class="k">if</span> <span class="n">seq</span><span class="p">]</span>
|
||
<span class="k">if</span> <span class="ow">not</span> <span class="n">nonemptyseqs</span><span class="p">:</span> <span class="k">return</span> <span class="n">res</span>
|
||
<span class="n">i</span><span class="o">+=</span><span class="mi">1</span><span class="p">;</span> <span class="nb">print</span> <span class="s1">'</span><span class="se">\n</span><span class="s1">'</span><span class="p">,</span><span class="n">i</span><span class="p">,</span><span class="s1">'round: candidates...'</span><span class="p">,</span>
|
||
<span class="k">for</span> <span class="n">seq</span> <span class="ow">in</span> <span class="n">nonemptyseqs</span><span class="p">:</span> <span class="c1"># find merge candidates among seq heads</span>
|
||
<span class="n">cand</span> <span class="o">=</span> <span class="n">seq</span><span class="p">[</span><span class="mi">0</span><span class="p">];</span> <span class="nb">print</span> <span class="s1">' '</span><span class="p">,</span><span class="n">cand</span><span class="p">,</span>
|
||
<span class="n">nothead</span><span class="o">=</span><span class="p">[</span><span class="n">s</span> <span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">nonemptyseqs</span> <span class="k">if</span> <span class="n">cand</span> <span class="ow">in</span> <span class="n">s</span><span class="p">[</span><span class="mi">1</span><span class="p">:]]</span>
|
||
<span class="k">if</span> <span class="n">nothead</span><span class="p">:</span> <span class="n">cand</span><span class="o">=</span><span class="kc">None</span> <span class="c1">#reject candidate</span>
|
||
<span class="k">else</span><span class="p">:</span> <span class="k">break</span>
|
||
<span class="k">if</span> <span class="ow">not</span> <span class="n">cand</span><span class="p">:</span> <span class="k">raise</span> <span class="s2">"Inconsistent hierarchy"</span>
|
||
<span class="n">res</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">cand</span><span class="p">)</span>
|
||
<span class="k">for</span> <span class="n">seq</span> <span class="ow">in</span> <span class="n">nonemptyseqs</span><span class="p">:</span> <span class="c1"># remove cand</span>
|
||
<span class="k">if</span> <span class="n">seq</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="n">cand</span><span class="p">:</span> <span class="k">del</span> <span class="n">seq</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">mro</span><span class="p">(</span><span class="n">C</span><span class="p">):</span>
|
||
<span class="s2">"Compute the class precedence list (mro) according to C3"</span>
|
||
<span class="k">return</span> <span class="n">merge</span><span class="p">([[</span><span class="n">C</span><span class="p">]]</span><span class="o">+</span><span class="nb">map</span><span class="p">(</span><span class="n">mro</span><span class="p">,</span><span class="n">C</span><span class="o">.</span><span class="vm">__bases__</span><span class="p">)</span><span class="o">+</span><span class="p">[</span><span class="nb">list</span><span class="p">(</span><span class="n">C</span><span class="o">.</span><span class="vm">__bases__</span><span class="p">)])</span>
|
||
|
||
<span class="k">def</span><span class="w"> </span><span class="nf">print_mro</span><span class="p">(</span><span class="n">C</span><span class="p">):</span>
|
||
<span class="nb">print</span> <span class="s1">'</span><span class="se">\n</span><span class="s1">MRO[</span><span class="si">%s</span><span class="s1">]=</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">mro</span><span class="p">(</span><span class="n">C</span><span class="p">))</span>
|
||
<span class="nb">print</span> <span class="s1">'</span><span class="se">\n</span><span class="s1">P22 MRO[</span><span class="si">%s</span><span class="s1">]=</span><span class="si">%s</span><span class="s1">'</span> <span class="o">%</span> <span class="p">(</span><span class="n">C</span><span class="p">,</span><span class="n">C</span><span class="o">.</span><span class="n">mro</span><span class="p">())</span>
|
||
|
||
<span class="n">print_mro</span><span class="p">(</span><span class="n">ex_9</span><span class="o">.</span><span class="n">Z</span><span class="p">)</span>
|
||
|
||
<span class="c1">#</mro.py></span>
|
||
</pre></div>
|
||
</div>
|
||
<p>That’s all folks,</p>
|
||
<blockquote>
|
||
<div><p>enjoy !</p>
|
||
</div></blockquote>
|
||
</section>
|
||
<section id="resources">
|
||
<h2>Resources<a class="headerlink" href="#resources" title="Link to this heading">¶</a></h2>
|
||
<aside class="footnote-list brackets">
|
||
<aside class="footnote brackets" id="id4" role="doc-footnote">
|
||
<span class="label"><span class="fn-bracket">[</span><a role="doc-backlink" href="#id1">1</a><span class="fn-bracket">]</span></span>
|
||
<p>The thread on python-dev started by Samuele Pedroni:
|
||
<a class="reference external" href="https://mail.python.org/pipermail/python-dev/2002-October/029035.html">https://mail.python.org/pipermail/python-dev/2002-October/029035.html</a></p>
|
||
</aside>
|
||
<aside class="footnote brackets" id="id5" role="doc-footnote">
|
||
<span class="label"><span class="fn-bracket">[</span><a role="doc-backlink" href="#id2">2</a><span class="fn-bracket">]</span></span>
|
||
<p>The paper <em>A Monotonic Superclass Linearization for Dylan</em>:
|
||
<a class="reference external" href="https://doi.org/10.1145/236337.236343">https://doi.org/10.1145/236337.236343</a></p>
|
||
</aside>
|
||
<aside class="footnote brackets" id="id6" role="doc-footnote">
|
||
<span class="label"><span class="fn-bracket">[</span><a role="doc-backlink" href="#id3">3</a><span class="fn-bracket">]</span></span>
|
||
<p>Guido van Rossum’s essay, <em>Unifying types and classes in Python 2.2</em>:
|
||
<a class="reference external" href="https://web.archive.org/web/20140210194412/http://www.python.org/download/releases/2.2.2/descrintro">https://web.archive.org/web/20140210194412/http://www.python.org/download/releases/2.2.2/descrintro</a></p>
|
||
</aside>
|
||
</aside>
|
||
</section>
|
||
</section>
|
||
|
||
|
||
<div class="clearer"></div>
|
||
</div>
|
||
</div>
|
||
</div>
|
||
<div class="sphinxsidebar" role="navigation" aria-label="Main">
|
||
<div class="sphinxsidebarwrapper">
|
||
<div>
|
||
<h3><a href="../contents.html">Table of Contents</a></h3>
|
||
<ul>
|
||
<li><a class="reference internal" href="#">The Python 2.3 Method Resolution Order</a><ul>
|
||
<li><a class="reference internal" href="#the-beginning">The beginning</a></li>
|
||
<li><a class="reference internal" href="#the-c3-method-resolution-order">The C3 Method Resolution Order</a></li>
|
||
<li><a class="reference internal" href="#examples">Examples</a></li>
|
||
<li><a class="reference internal" href="#bad-method-resolution-orders">Bad Method Resolution Orders</a></li>
|
||
<li><a class="reference internal" href="#the-end">The end</a></li>
|
||
<li><a class="reference internal" href="#resources">Resources</a></li>
|
||
</ul>
|
||
</li>
|
||
</ul>
|
||
|
||
</div>
|
||
<div>
|
||
<h4>Previous topic</h4>
|
||
<p class="topless"><a href="timerfd.html"
|
||
title="previous chapter">timer file descriptor HOWTO</a></p>
|
||
</div>
|
||
<div>
|
||
<h4>Next topic</h4>
|
||
<p class="topless"><a href="free-threading-python.html"
|
||
title="next chapter">Python experimental support for free threading</a></p>
|
||
</div>
|
||
<div role="note" aria-label="source link">
|
||
<h3>This Page</h3>
|
||
<ul class="this-page-menu">
|
||
<li><a href="../bugs.html">Report a Bug</a></li>
|
||
<li>
|
||
<a href="https://github.com/python/cpython/blob/main/Doc/howto/mro.rst"
|
||
rel="nofollow">Show Source
|
||
</a>
|
||
</li>
|
||
</ul>
|
||
</div>
|
||
</div>
|
||
<div id="sidebarbutton" title="Collapse sidebar">
|
||
<span>«</span>
|
||
</div>
|
||
|
||
</div>
|
||
<div class="clearer"></div>
|
||
</div>
|
||
<div class="related" role="navigation" aria-label="Related">
|
||
<h3>Navigation</h3>
|
||
<ul>
|
||
<li class="right" style="margin-right: 10px">
|
||
<a href="../genindex.html" title="General Index"
|
||
>index</a></li>
|
||
<li class="right" >
|
||
<a href="../py-modindex.html" title="Python Module Index"
|
||
>modules</a> |</li>
|
||
<li class="right" >
|
||
<a href="free-threading-python.html" title="Python experimental support for free threading"
|
||
>next</a> |</li>
|
||
<li class="right" >
|
||
<a href="timerfd.html" title="timer file descriptor HOWTO"
|
||
>previous</a> |</li>
|
||
|
||
<li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>
|
||
<li><a href="https://www.python.org/">Python</a> »</li>
|
||
<li class="switchers">
|
||
<div class="language_switcher_placeholder"></div>
|
||
<div class="version_switcher_placeholder"></div>
|
||
</li>
|
||
<li>
|
||
|
||
</li>
|
||
<li id="cpython-language-and-version">
|
||
<a href="../index.html">3.13.3 Documentation</a> »
|
||
</li>
|
||
|
||
<li class="nav-item nav-item-1"><a href="index.html" >Python HOWTOs</a> »</li>
|
||
<li class="nav-item nav-item-this"><a href="">The Python 2.3 Method Resolution Order</a></li>
|
||
<li class="right">
|
||
|
||
|
||
<div class="inline-search" role="search">
|
||
<form class="inline-search" action="../search.html" method="get">
|
||
<input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />
|
||
<input type="submit" value="Go" />
|
||
</form>
|
||
</div>
|
||
|
|
||
</li>
|
||
<li class="right">
|
||
<label class="theme-selector-label">
|
||
Theme
|
||
<select class="theme-selector" oninput="activateTheme(this.value)">
|
||
<option value="auto" selected>Auto</option>
|
||
<option value="light">Light</option>
|
||
<option value="dark">Dark</option>
|
||
</select>
|
||
</label> |</li>
|
||
|
||
</ul>
|
||
</div>
|
||
<div class="footer">
|
||
©
|
||
<a href="../copyright.html">
|
||
|
||
Copyright
|
||
|
||
</a>
|
||
2001-2025, Python Software Foundation.
|
||
<br />
|
||
This page is licensed under the Python Software Foundation License Version 2.
|
||
<br />
|
||
Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.
|
||
<br />
|
||
|
||
See <a href="/license.html">History and License</a> for more information.<br />
|
||
|
||
|
||
<br />
|
||
|
||
The Python Software Foundation is a non-profit corporation.
|
||
<a href="https://www.python.org/psf/donations/">Please donate.</a>
|
||
<br />
|
||
<br />
|
||
Last updated on Apr 08, 2025 (14:33 UTC).
|
||
|
||
<a href="/bugs.html">Found a bug</a>?
|
||
|
||
<br />
|
||
|
||
Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 8.2.3.
|
||
</div>
|
||
|
||
</body>
|
||
</html> |