Baoding-FenShuaJiang
/
Green_GoodERP18_FSJ_Standard
Watch 1
Star 0
Wiki 捐赠
gooderp18绿色标准版
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 0f75e31513
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0f75e31513'
${ noResults }
Green_GoodERP18_FSJ_Standard/python/Doc/html/library/functools.html

1035 lines
101KB
Raw Blame History 

  1. <!DOCTYPE html>

  2. 

  3. <html lang="en" data-content_root="../">

  4.   <head>

  5.     <meta charset="utf-8" />

  6.     <meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />

  7. <meta property="og:title" content="functools — Higher-order functions and operations on callable objects" />

  8. <meta property="og:type" content="website" />

  9. <meta property="og:url" content="https://docs.python.org/3/library/functools.html" />

  10. <meta property="og:site_name" content="Python documentation" />

  11. <meta property="og:description" content="Source code: Lib/functools.py The functools module is for higher-order functions: functions that act on or return other functions. In general, any callable object can be treated as a function for t..." />

  12. <meta property="og:image" content="https://docs.python.org/3/_static/og-image.png" />

  13. <meta property="og:image:alt" content="Python documentation" />

  14. <meta name="description" content="Source code: Lib/functools.py The functools module is for higher-order functions: functions that act on or return other functions. In general, any callable object can be treated as a function for t..." />

  15. <meta property="og:image:width" content="200" />

  16. <meta property="og:image:height" content="200" />

  17. <meta name="theme-color" content="#3776ab" />

  18. 

  19.     <title>functools — Higher-order functions and operations on callable objects &#8212; Python 3.12.3 documentation</title><meta name="viewport" content="width=device-width, initial-scale=1.0">

  20.     

  21.     <link rel="stylesheet" type="text/css" href="../_static/pygments.css?v=80d5e7a1" />

  22.     <link rel="stylesheet" type="text/css" href="../_static/pydoctheme.css?v=bb723527" />

  23.     <link id="pygments_dark_css" media="(prefers-color-scheme: dark)" rel="stylesheet" type="text/css" href="../_static/pygments_dark.css?v=b20cc3f5" />

  24.     

  25.     <script src="../_static/documentation_options.js?v=2c828074"></script>

  26.     <script src="../_static/doctools.js?v=888ff710"></script>

  27.     <script src="../_static/sphinx_highlight.js?v=dc90522c"></script>

  28.     

  29.     <script src="../_static/sidebar.js"></script>

  30.     

  31.     <link rel="search" type="application/opensearchdescription+xml"

  32.           title="Search within Python 3.12.3 documentation"

  33.           href="../_static/opensearch.xml"/>

  34.     <link rel="author" title="About these documents" href="../about.html" />

  35.     <link rel="index" title="Index" href="../genindex.html" />

  36.     <link rel="search" title="Search" href="../search.html" />

  37.     <link rel="copyright" title="Copyright" href="../copyright.html" />

  38.     <link rel="next" title="operator — Standard operators as functions" href="operator.html" />

  39.     <link rel="prev" title="itertools — Functions creating iterators for efficient looping" href="itertools.html" />

  40.     <link rel="canonical" href="https://docs.python.org/3/library/functools.html" />

  41.     

  42.       

  43.     

  44. 

  45.     

  46.     <style>

  47.       @media only screen {

  48.         table.full-width-table {

  49.             width: 100%;

  50.         }

  51.       }

  52.     </style>

  53. <link rel="stylesheet" href="../_static/pydoctheme_dark.css" media="(prefers-color-scheme: dark)" id="pydoctheme_dark_css">

  54.     <link rel="shortcut icon" type="image/png" href="../_static/py.svg" />

  55.             <script type="text/javascript" src="../_static/copybutton.js"></script>

  56.             <script type="text/javascript" src="../_static/menu.js"></script>

  57.             <script type="text/javascript" src="../_static/search-focus.js"></script>

  58.             <script type="text/javascript" src="../_static/themetoggle.js"></script> 

  59. 

  60.   </head>

  61. <body>

  62. <div class="mobile-nav">

  63.     <input type="checkbox" id="menuToggler" class="toggler__input" aria-controls="navigation"

  64.            aria-pressed="false" aria-expanded="false" role="button" aria-label="Menu" />

  65.     <nav class="nav-content" role="navigation">

  66.         <label for="menuToggler" class="toggler__label">

  67.             <span></span>

  68.         </label>

  69.         <span class="nav-items-wrapper">

  70.             <a href="https://www.python.org/" class="nav-logo">

  71.                 <img src="../_static/py.svg" alt="Python logo"/>

  72.             </a>

  73.             <span class="version_switcher_placeholder"></span>

  74.             <form role="search" class="search" action="../search.html" method="get">

  75.                 <svg xmlns="http://www.w3.org/2000/svg" width="20" height="20" viewBox="0 0 24 24" class="search-icon">

  76.                     <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>

  77.                 </svg>

  78.                 <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" />

  79.                 <input type="submit" value="Go"/>

  80.             </form>

  81.         </span>

  82.     </nav>

  83.     <div class="menu-wrapper">

  84.         <nav class="menu" role="navigation" aria-label="main navigation">

  85.             <div class="language_switcher_placeholder"></div>

  86.             

  87. <label class="theme-selector-label">

  88.     Theme

  89.     <select class="theme-selector" oninput="activateTheme(this.value)">

  90.         <option value="auto" selected>Auto</option>

  91.         <option value="light">Light</option>

  92.         <option value="dark">Dark</option>

  93.     </select>

  94. </label>

  95.   <div>

  96.     <h3><a href="../contents.html">Table of Contents</a></h3>

  97.     <ul>

  98. <li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code> — Higher-order functions and operations on callable objects</a><ul>

  99. <li><a class="reference internal" href="#partial-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code> Objects</a></li>

  100. </ul>

  101. </li>

  102. </ul>

  103. 

  104.   </div>

  105.   <div>

  106.     <h4>Previous topic</h4>

  107.     <p class="topless"><a href="itertools.html"

  108.                           title="previous chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">itertools</span></code> — Functions creating iterators for efficient looping</a></p>

  109.   </div>

  110.   <div>

  111.     <h4>Next topic</h4>

  112.     <p class="topless"><a href="operator.html"

  113.                           title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">operator</span></code> — Standard operators as functions</a></p>

  114.   </div>

  115.   <div role="note" aria-label="source link">

  116.     <h3>This Page</h3>

  117.     <ul class="this-page-menu">

  118.       <li><a href="../bugs.html">Report a Bug</a></li>

  119.       <li>

  120.         <a href="https://github.com/python/cpython/blob/main/Doc/library/functools.rst"

  121.             rel="nofollow">Show Source

  122.         </a>

  123.       </li>

  124.     </ul>

  125.   </div>

  126.         </nav>

  127.     </div>

  128. </div>

  129. 

  130.   

  131.     <div class="related" role="navigation" aria-label="related navigation">

  132.       <h3>Navigation</h3>

  133.       <ul>

  134.         <li class="right" style="margin-right: 10px">

  135.           <a href="../genindex.html" title="General Index"

  136.              accesskey="I">index</a></li>

  137.         <li class="right" >

  138.           <a href="../py-modindex.html" title="Python Module Index"

  139.              >modules</a> |</li>

  140.         <li class="right" >

  141.           <a href="operator.html" title="operator — Standard operators as functions"

  142.              accesskey="N">next</a> |</li>

  143.         <li class="right" >

  144.           <a href="itertools.html" title="itertools — Functions creating iterators for efficient looping"

  145.              accesskey="P">previous</a> |</li>

  146. 

  147.           <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>

  148.           <li><a href="https://www.python.org/">Python</a> &#187;</li>

  149.           <li class="switchers">

  150.             <div class="language_switcher_placeholder"></div>

  151.             <div class="version_switcher_placeholder"></div>

  152.           </li>

  153.           <li>

  154.               

  155.           </li>

  156.     <li id="cpython-language-and-version">

  157.       <a href="../index.html">3.12.3 Documentation</a> &#187;

  158.     </li>

  159. 

  160.           <li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>

  161.           <li class="nav-item nav-item-2"><a href="functional.html" accesskey="U">Functional Programming Modules</a> &#187;</li>

  162.         <li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code> — Higher-order functions and operations on callable objects</a></li>

  163.                 <li class="right">

  164.                     

  165. 

  166.     <div class="inline-search" role="search">

  167.         <form class="inline-search" action="../search.html" method="get">

  168.           <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />

  169.           <input type="submit" value="Go" />

  170.         </form>

  171.     </div>

  172.                      |

  173.                 </li>

  174.             <li class="right">

  175. <label class="theme-selector-label">

  176.     Theme

  177.     <select class="theme-selector" oninput="activateTheme(this.value)">

  178.         <option value="auto" selected>Auto</option>

  179.         <option value="light">Light</option>

  180.         <option value="dark">Dark</option>

  181.     </select>

  182. </label> |</li>

  183.             

  184.       </ul>

  185.     </div>    

  186. 

  187.     <div class="document">

  188.       <div class="documentwrapper">

  189.         <div class="bodywrapper">

  190.           <div class="body" role="main">

  191.             

  192.   <section id="module-functools">

  193. <span id="functools-higher-order-functions-and-operations-on-callable-objects"></span><h1><a class="reference internal" href="#module-functools" title="functools: Higher-order functions and operations on callable objects."><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code></a> — Higher-order functions and operations on callable objects<a class="headerlink" href="#module-functools" title="Link to this heading">¶</a></h1>

  194. <p><strong>Source code:</strong> <a class="reference external" href="https://github.com/python/cpython/tree/3.12/Lib/functools.py">Lib/functools.py</a></p>

  195. <hr class="docutils" />

  196. <p>The <a class="reference internal" href="#module-functools" title="functools: Higher-order functions and operations on callable objects."><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code></a> module is for higher-order functions: functions that act on

  197. or return other functions. In general, any callable object can be treated as a

  198. function for the purposes of this module.</p>

  199. <p>The <a class="reference internal" href="#module-functools" title="functools: Higher-order functions and operations on callable objects."><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code></a> module defines the following functions:</p>

  200. <dl class="py function">

  201. <dt class="sig sig-object py" id="functools.cache">

  202. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">cache</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">user_function</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.cache" title="Link to this definition">¶</a></dt>

  203. <dd><p>Simple lightweight unbounded function cache.  Sometimes called

  204. <a class="reference external" href="https://en.wikipedia.org/wiki/Memoization">“memoize”</a>.</p>

  205. <p>Returns the same as <code class="docutils literal notranslate"><span class="pre">lru_cache(maxsize=None)</span></code>, creating a thin

  206. wrapper around a dictionary lookup for the function arguments.  Because it

  207. never needs to evict old values, this is smaller and faster than

  208. <a class="reference internal" href="#functools.lru_cache" title="functools.lru_cache"><code class="xref py py-func docutils literal notranslate"><span class="pre">lru_cache()</span></code></a> with a size limit.</p>

  209. <p>For example:</p>

  210. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nd">@cache</span>

  211. <span class="k">def</span> <span class="nf">factorial</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>

  212.     <span class="k">return</span> <span class="n">n</span> <span class="o">*</span> <span class="n">factorial</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="k">if</span> <span class="n">n</span> <span class="k">else</span> <span class="mi">1</span>

  213. 

  214. <span class="o">&gt;&gt;&gt;</span> <span class="n">factorial</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span>      <span class="c1"># no previously cached result, makes 11 recursive calls</span>

  215. <span class="mi">3628800</span>

  216. <span class="o">&gt;&gt;&gt;</span> <span class="n">factorial</span><span class="p">(</span><span class="mi">5</span><span class="p">)</span>       <span class="c1"># just looks up cached value result</span>

  217. <span class="mi">120</span>

  218. <span class="o">&gt;&gt;&gt;</span> <span class="n">factorial</span><span class="p">(</span><span class="mi">12</span><span class="p">)</span>      <span class="c1"># makes two new recursive calls, the other 10 are cached</span>

  219. <span class="mi">479001600</span>

  220. </pre></div>

  221. </div>

  222. <p>The cache is threadsafe so that the wrapped function can be used in

  223. multiple threads.  This means that the underlying data structure will

  224. remain coherent during concurrent updates.</p>

  225. <p>It is possible for the wrapped function to be called more than once if

  226. another thread makes an additional call before the initial call has been

  227. completed and cached.</p>

  228. <div class="versionadded">

  229. <p><span class="versionmodified added">New in version 3.9.</span></p>

  230. </div>

  231. </dd></dl>

  232. 

  233. <dl class="py function">

  234. <dt class="sig sig-object py" id="functools.cached_property">

  235. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">cached_property</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.cached_property" title="Link to this definition">¶</a></dt>

  236. <dd><p>Transform a method of a class into a property whose value is computed once

  237. and then cached as a normal attribute for the life of the instance. Similar

  238. to <a class="reference internal" href="functions.html#property" title="property"><code class="xref py py-func docutils literal notranslate"><span class="pre">property()</span></code></a>, with the addition of caching. Useful for expensive

  239. computed properties of instances that are otherwise effectively immutable.</p>

  240. <p>Example:</p>

  241. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">DataSet</span><span class="p">:</span>

  242. 

  243.     <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">sequence_of_numbers</span><span class="p">):</span>

  244.         <span class="bp">self</span><span class="o">.</span><span class="n">_data</span> <span class="o">=</span> <span class="nb">tuple</span><span class="p">(</span><span class="n">sequence_of_numbers</span><span class="p">)</span>

  245. 

  246.     <span class="nd">@cached_property</span>

  247.     <span class="k">def</span> <span class="nf">stdev</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>

  248.         <span class="k">return</span> <span class="n">statistics</span><span class="o">.</span><span class="n">stdev</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">_data</span><span class="p">)</span>

  249. </pre></div>

  250. </div>

  251. <p>The mechanics of <a class="reference internal" href="#functools.cached_property" title="functools.cached_property"><code class="xref py py-func docutils literal notranslate"><span class="pre">cached_property()</span></code></a> are somewhat different from

  252. <a class="reference internal" href="functions.html#property" title="property"><code class="xref py py-func docutils literal notranslate"><span class="pre">property()</span></code></a>.  A regular property blocks attribute writes unless a

  253. setter is defined. In contrast, a <em>cached_property</em> allows writes.</p>

  254. <p>The <em>cached_property</em> decorator only runs on lookups and only when an

  255. attribute of the same name doesn’t exist.  When it does run, the

  256. <em>cached_property</em> writes to the attribute with the same name. Subsequent

  257. attribute reads and writes take precedence over the <em>cached_property</em>

  258. method and it works like a normal attribute.</p>

  259. <p>The cached value can be cleared by deleting the attribute.  This

  260. allows the <em>cached_property</em> method to run again.</p>

  261. <p>The <em>cached_property</em> does not prevent a possible race condition in

  262. multi-threaded usage. The getter function could run more than once on the

  263. same instance, with the latest run setting the cached value. If the cached

  264. property is idempotent or otherwise not harmful to run more than once on an

  265. instance, this is fine. If synchronization is needed, implement the necessary

  266. locking inside the decorated getter function or around the cached property

  267. access.</p>

  268. <p>Note, this decorator interferes with the operation of <span class="target" id="index-0"></span><a class="pep reference external" href="https://peps.python.org/pep-0412/"><strong>PEP 412</strong></a>

  269. key-sharing dictionaries.  This means that instance dictionaries

  270. can take more space than usual.</p>

  271. <p>Also, this decorator requires that the <code class="docutils literal notranslate"><span class="pre">__dict__</span></code> attribute on each instance

  272. be a mutable mapping. This means it will not work with some types, such as

  273. metaclasses (since the <code class="docutils literal notranslate"><span class="pre">__dict__</span></code> attributes on type instances are

  274. read-only proxies for the class namespace), and those that specify

  275. <code class="docutils literal notranslate"><span class="pre">__slots__</span></code> without including <code class="docutils literal notranslate"><span class="pre">__dict__</span></code> as one of the defined slots

  276. (as such classes don’t provide a <code class="docutils literal notranslate"><span class="pre">__dict__</span></code> attribute at all).</p>

  277. <p>If a mutable mapping is not available or if space-efficient key sharing is

  278. desired, an effect similar to <a class="reference internal" href="#functools.cached_property" title="functools.cached_property"><code class="xref py py-func docutils literal notranslate"><span class="pre">cached_property()</span></code></a> can also be achieved by

  279. stacking <a class="reference internal" href="functions.html#property" title="property"><code class="xref py py-func docutils literal notranslate"><span class="pre">property()</span></code></a> on top of <a class="reference internal" href="#functools.lru_cache" title="functools.lru_cache"><code class="xref py py-func docutils literal notranslate"><span class="pre">lru_cache()</span></code></a>. See

  280. <a class="reference internal" href="../faq/programming.html#faq-cache-method-calls"><span class="std std-ref">How do I cache method calls?</span></a> for more details on how this differs from <a class="reference internal" href="#functools.cached_property" title="functools.cached_property"><code class="xref py py-func docutils literal notranslate"><span class="pre">cached_property()</span></code></a>.</p>

  281. <div class="versionadded">

  282. <p><span class="versionmodified added">New in version 3.8.</span></p>

  283. </div>

  284. <div class="versionchanged">

  285. <p><span class="versionmodified changed">Changed in version 3.12: </span>Prior to Python 3.12, <code class="docutils literal notranslate"><span class="pre">cached_property</span></code> included an undocumented lock to

  286. ensure that in multi-threaded usage the getter function was guaranteed to

  287. run only once per instance. However, the lock was per-property, not

  288. per-instance, which could result in unacceptably high lock contention. In

  289. Python 3.12+ this locking is removed.</p>

  290. </div>

  291. </dd></dl>

  292. 

  293. <dl class="py function">

  294. <dt class="sig sig-object py" id="functools.cmp_to_key">

  295. <span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">cmp_to_key</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.cmp_to_key" title="Link to this definition">¶</a></dt>

  296. <dd><p>Transform an old-style comparison function to a <a class="reference internal" href="../glossary.html#term-key-function"><span class="xref std std-term">key function</span></a>.  Used

  297. with tools that accept key functions (such as <a class="reference internal" href="functions.html#sorted" title="sorted"><code class="xref py py-func docutils literal notranslate"><span class="pre">sorted()</span></code></a>, <a class="reference internal" href="functions.html#min" title="min"><code class="xref py py-func docutils literal notranslate"><span class="pre">min()</span></code></a>,

  298. <a class="reference internal" href="functions.html#max" title="max"><code class="xref py py-func docutils literal notranslate"><span class="pre">max()</span></code></a>, <a class="reference internal" href="heapq.html#heapq.nlargest" title="heapq.nlargest"><code class="xref py py-func docutils literal notranslate"><span class="pre">heapq.nlargest()</span></code></a>, <a class="reference internal" href="heapq.html#heapq.nsmallest" title="heapq.nsmallest"><code class="xref py py-func docutils literal notranslate"><span class="pre">heapq.nsmallest()</span></code></a>,

  299. <a class="reference internal" href="itertools.html#itertools.groupby" title="itertools.groupby"><code class="xref py py-func docutils literal notranslate"><span class="pre">itertools.groupby()</span></code></a>).  This function is primarily used as a transition

  300. tool for programs being converted from Python 2 which supported the use of

  301. comparison functions.</p>

  302. <p>A comparison function is any callable that accepts two arguments, compares them,

  303. and returns a negative number for less-than, zero for equality, or a positive

  304. number for greater-than.  A key function is a callable that accepts one

  305. argument and returns another value to be used as the sort key.</p>

  306. <p>Example:</p>

  307. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nb">sorted</span><span class="p">(</span><span class="n">iterable</span><span class="p">,</span> <span class="n">key</span><span class="o">=</span><span class="n">cmp_to_key</span><span class="p">(</span><span class="n">locale</span><span class="o">.</span><span class="n">strcoll</span><span class="p">))</span>  <span class="c1"># locale-aware sort order</span>

  308. </pre></div>

  309. </div>

  310. <p>For sorting examples and a brief sorting tutorial, see <a class="reference internal" href="../howto/sorting.html#sortinghowto"><span class="std std-ref">Sorting Techniques</span></a>.</p>

  311. <div class="versionadded">

  312. <p><span class="versionmodified added">New in version 3.2.</span></p>

  313. </div>

  314. </dd></dl>

  315. 

  316. <dl class="py function">

  317. <dt class="sig sig-object py" id="functools.lru_cache">

  318. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">lru_cache</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">user_function</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.lru_cache" title="Link to this definition">¶</a></dt>

  319. <dt class="sig sig-object py">

  320. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">lru_cache</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">maxsize</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">128</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">typed</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">False</span></span></em><span class="sig-paren">)</span></dt>

  321. <dd><p>Decorator to wrap a function with a memoizing callable that saves up to the

  322. <em>maxsize</em> most recent calls.  It can save time when an expensive or I/O bound

  323. function is periodically called with the same arguments.</p>

  324. <p>The cache is threadsafe so that the wrapped function can be used in

  325. multiple threads.  This means that the underlying data structure will

  326. remain coherent during concurrent updates.</p>

  327. <p>It is possible for the wrapped function to be called more than once if

  328. another thread makes an additional call before the initial call has been

  329. completed and cached.</p>

  330. <p>Since a dictionary is used to cache results, the positional and keyword

  331. arguments to the function must be <a class="reference internal" href="../glossary.html#term-hashable"><span class="xref std std-term">hashable</span></a>.</p>

  332. <p>Distinct argument patterns may be considered to be distinct calls with

  333. separate cache entries.  For example, <code class="docutils literal notranslate"><span class="pre">f(a=1,</span> <span class="pre">b=2)</span></code> and <code class="docutils literal notranslate"><span class="pre">f(b=2,</span> <span class="pre">a=1)</span></code>

  334. differ in their keyword argument order and may have two separate cache

  335. entries.</p>

  336. <p>If <em>user_function</em> is specified, it must be a callable. This allows the

  337. <em>lru_cache</em> decorator to be applied directly to a user function, leaving

  338. the <em>maxsize</em> at its default value of 128:</p>

  339. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nd">@lru_cache</span>

  340. <span class="k">def</span> <span class="nf">count_vowels</span><span class="p">(</span><span class="n">sentence</span><span class="p">):</span>

  341.     <span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">sentence</span><span class="o">.</span><span class="n">count</span><span class="p">(</span><span class="n">vowel</span><span class="p">)</span> <span class="k">for</span> <span class="n">vowel</span> <span class="ow">in</span> <span class="s1">&#39;AEIOUaeiou&#39;</span><span class="p">)</span>

  342. </pre></div>

  343. </div>

  344. <p>If <em>maxsize</em> is set to <code class="docutils literal notranslate"><span class="pre">None</span></code>, the LRU feature is disabled and the cache can

  345. grow without bound.</p>

  346. <p>If <em>typed</em> is set to true, function arguments of different types will be

  347. cached separately.  If <em>typed</em> is false, the implementation will usually

  348. regard them as equivalent calls and only cache a single result. (Some

  349. types such as <em>str</em> and <em>int</em> may be cached separately even when <em>typed</em>

  350. is false.)</p>

  351. <p>Note, type specificity applies only to the function’s immediate arguments

  352. rather than their contents.  The scalar arguments, <code class="docutils literal notranslate"><span class="pre">Decimal(42)</span></code> and

  353. <code class="docutils literal notranslate"><span class="pre">Fraction(42)</span></code> are be treated as distinct calls with distinct results.

  354. In contrast, the tuple arguments <code class="docutils literal notranslate"><span class="pre">('answer',</span> <span class="pre">Decimal(42))</span></code> and

  355. <code class="docutils literal notranslate"><span class="pre">('answer',</span> <span class="pre">Fraction(42))</span></code> are treated as equivalent.</p>

  356. <p>The wrapped function is instrumented with a <code class="xref py py-func docutils literal notranslate"><span class="pre">cache_parameters()</span></code>

  357. function that returns a new <a class="reference internal" href="stdtypes.html#dict" title="dict"><code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></a> showing the values for <em>maxsize</em>

  358. and <em>typed</em>.  This is for information purposes only.  Mutating the values

  359. has no effect.</p>

  360. <p>To help measure the effectiveness of the cache and tune the <em>maxsize</em>

  361. parameter, the wrapped function is instrumented with a <code class="xref py py-func docutils literal notranslate"><span class="pre">cache_info()</span></code>

  362. function that returns a <a class="reference internal" href="../glossary.html#term-named-tuple"><span class="xref std std-term">named tuple</span></a> showing <em>hits</em>, <em>misses</em>,

  363. <em>maxsize</em> and <em>currsize</em>.</p>

  364. <p>The decorator also provides a <code class="xref py py-func docutils literal notranslate"><span class="pre">cache_clear()</span></code> function for clearing or

  365. invalidating the cache.</p>

  366. <p>The original underlying function is accessible through the

  367. <code class="xref py py-attr docutils literal notranslate"><span class="pre">__wrapped__</span></code> attribute.  This is useful for introspection, for

  368. bypassing the cache, or for rewrapping the function with a different cache.</p>

  369. <p>The cache keeps references to the arguments and return values until they age

  370. out of the cache or until the cache is cleared.</p>

  371. <p>If a method is cached, the <code class="docutils literal notranslate"><span class="pre">self</span></code> instance argument is included in the

  372. cache.  See <a class="reference internal" href="../faq/programming.html#faq-cache-method-calls"><span class="std std-ref">How do I cache method calls?</span></a></p>

  373. <p>An <a class="reference external" href="https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)">LRU (least recently used) cache</a>

  374. works best when the most recent calls are the best predictors of upcoming

  375. calls (for example, the most popular articles on a news server tend to

  376. change each day).  The cache’s size limit assures that the cache does not

  377. grow without bound on long-running processes such as web servers.</p>

  378. <p>In general, the LRU cache should only be used when you want to reuse

  379. previously computed values.  Accordingly, it doesn’t make sense to cache

  380. functions with side-effects, functions that need to create

  381. distinct mutable objects on each call (such as generators and async functions),

  382. or impure functions such as time() or random().</p>

  383. <p>Example of an LRU cache for static web content:</p>

  384. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nd">@lru_cache</span><span class="p">(</span><span class="n">maxsize</span><span class="o">=</span><span class="mi">32</span><span class="p">)</span>

  385. <span class="k">def</span> <span class="nf">get_pep</span><span class="p">(</span><span class="n">num</span><span class="p">):</span>

  386.     <span class="s1">&#39;Retrieve text of a Python Enhancement Proposal&#39;</span>

  387.     <span class="n">resource</span> <span class="o">=</span> <span class="sa">f</span><span class="s1">&#39;https://peps.python.org/pep-</span><span class="si">{</span><span class="n">num</span><span class="si">:</span><span class="s1">04d</span><span class="si">}</span><span class="s1">&#39;</span>

  388.     <span class="k">try</span><span class="p">:</span>

  389.         <span class="k">with</span> <span class="n">urllib</span><span class="o">.</span><span class="n">request</span><span class="o">.</span><span class="n">urlopen</span><span class="p">(</span><span class="n">resource</span><span class="p">)</span> <span class="k">as</span> <span class="n">s</span><span class="p">:</span>

  390.             <span class="k">return</span> <span class="n">s</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>

  391.     <span class="k">except</span> <span class="n">urllib</span><span class="o">.</span><span class="n">error</span><span class="o">.</span><span class="n">HTTPError</span><span class="p">:</span>

  392.         <span class="k">return</span> <span class="s1">&#39;Not Found&#39;</span>

  393. 

  394. <span class="o">&gt;&gt;&gt;</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">290</span><span class="p">,</span> <span class="mi">308</span><span class="p">,</span> <span class="mi">320</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">218</span><span class="p">,</span> <span class="mi">320</span><span class="p">,</span> <span class="mi">279</span><span class="p">,</span> <span class="mi">289</span><span class="p">,</span> <span class="mi">320</span><span class="p">,</span> <span class="mi">9991</span><span class="p">:</span>

  395. <span class="o">...</span>     <span class="n">pep</span> <span class="o">=</span> <span class="n">get_pep</span><span class="p">(</span><span class="n">n</span><span class="p">)</span>

  396. <span class="o">...</span>     <span class="nb">print</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="nb">len</span><span class="p">(</span><span class="n">pep</span><span class="p">))</span>

  397. 

  398. <span class="o">&gt;&gt;&gt;</span> <span class="n">get_pep</span><span class="o">.</span><span class="n">cache_info</span><span class="p">()</span>

  399. <span class="n">CacheInfo</span><span class="p">(</span><span class="n">hits</span><span class="o">=</span><span class="mi">3</span><span class="p">,</span> <span class="n">misses</span><span class="o">=</span><span class="mi">8</span><span class="p">,</span> <span class="n">maxsize</span><span class="o">=</span><span class="mi">32</span><span class="p">,</span> <span class="n">currsize</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>

  400. </pre></div>

  401. </div>

  402. <p>Example of efficiently computing

  403. <a class="reference external" href="https://en.wikipedia.org/wiki/Fibonacci_number">Fibonacci numbers</a>

  404. using a cache to implement a

  405. <a class="reference external" href="https://en.wikipedia.org/wiki/Dynamic_programming">dynamic programming</a>

  406. technique:</p>

  407. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nd">@lru_cache</span><span class="p">(</span><span class="n">maxsize</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>

  408. <span class="k">def</span> <span class="nf">fib</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>

  409.     <span class="k">if</span> <span class="n">n</span> <span class="o">&lt;</span> <span class="mi">2</span><span class="p">:</span>

  410.         <span class="k">return</span> <span class="n">n</span>

  411.     <span class="k">return</span> <span class="n">fib</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="n">fib</span><span class="p">(</span><span class="n">n</span><span class="o">-</span><span class="mi">2</span><span class="p">)</span>

  412. 

  413. <span class="o">&gt;&gt;&gt;</span> <span class="p">[</span><span class="n">fib</span><span class="p">(</span><span class="n">n</span><span class="p">)</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">16</span><span class="p">)]</span>

  414. <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">8</span><span class="p">,</span> <span class="mi">13</span><span class="p">,</span> <span class="mi">21</span><span class="p">,</span> <span class="mi">34</span><span class="p">,</span> <span class="mi">55</span><span class="p">,</span> <span class="mi">89</span><span class="p">,</span> <span class="mi">144</span><span class="p">,</span> <span class="mi">233</span><span class="p">,</span> <span class="mi">377</span><span class="p">,</span> <span class="mi">610</span><span class="p">]</span>

  415. 

  416. <span class="o">&gt;&gt;&gt;</span> <span class="n">fib</span><span class="o">.</span><span class="n">cache_info</span><span class="p">()</span>

  417. <span class="n">CacheInfo</span><span class="p">(</span><span class="n">hits</span><span class="o">=</span><span class="mi">28</span><span class="p">,</span> <span class="n">misses</span><span class="o">=</span><span class="mi">16</span><span class="p">,</span> <span class="n">maxsize</span><span class="o">=</span><span class="kc">None</span><span class="p">,</span> <span class="n">currsize</span><span class="o">=</span><span class="mi">16</span><span class="p">)</span>

  418. </pre></div>

  419. </div>

  420. <div class="versionadded">

  421. <p><span class="versionmodified added">New in version 3.2.</span></p>

  422. </div>

  423. <div class="versionchanged">

  424. <p><span class="versionmodified changed">Changed in version 3.3: </span>Added the <em>typed</em> option.</p>

  425. </div>

  426. <div class="versionchanged">

  427. <p><span class="versionmodified changed">Changed in version 3.8: </span>Added the <em>user_function</em> option.</p>

  428. </div>

  429. <div class="versionchanged">

  430. <p><span class="versionmodified changed">Changed in version 3.9: </span>Added the function <code class="xref py py-func docutils literal notranslate"><span class="pre">cache_parameters()</span></code></p>

  431. </div>

  432. </dd></dl>

  433. 

  434. <dl class="py function">

  435. <dt class="sig sig-object py" id="functools.total_ordering">

  436. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">total_ordering</span></span><a class="headerlink" href="#functools.total_ordering" title="Link to this definition">¶</a></dt>

  437. <dd><p>Given a class defining one or more rich comparison ordering methods, this

  438. class decorator supplies the rest.  This simplifies the effort involved

  439. in specifying all of the possible rich comparison operations:</p>

  440. <p>The class must define one of <code class="xref py py-meth docutils literal notranslate"><span class="pre">__lt__()</span></code>, <code class="xref py py-meth docutils literal notranslate"><span class="pre">__le__()</span></code>,

  441. <code class="xref py py-meth docutils literal notranslate"><span class="pre">__gt__()</span></code>, or <code class="xref py py-meth docutils literal notranslate"><span class="pre">__ge__()</span></code>.

  442. In addition, the class should supply an <code class="xref py py-meth docutils literal notranslate"><span class="pre">__eq__()</span></code> method.</p>

  443. <p>For example:</p>

  444. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="nd">@total_ordering</span>

  445. <span class="k">class</span> <span class="nc">Student</span><span class="p">:</span>

  446.     <span class="k">def</span> <span class="nf">_is_valid_operand</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>

  447.         <span class="k">return</span> <span class="p">(</span><span class="nb">hasattr</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="s2">&quot;lastname&quot;</span><span class="p">)</span> <span class="ow">and</span>

  448.                 <span class="nb">hasattr</span><span class="p">(</span><span class="n">other</span><span class="p">,</span> <span class="s2">&quot;firstname&quot;</span><span class="p">))</span>

  449.     <span class="k">def</span> <span class="fm">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>

  450.         <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">_is_valid_operand</span><span class="p">(</span><span class="n">other</span><span class="p">):</span>

  451.             <span class="k">return</span> <span class="bp">NotImplemented</span>

  452.         <span class="k">return</span> <span class="p">((</span><span class="bp">self</span><span class="o">.</span><span class="n">lastname</span><span class="o">.</span><span class="n">lower</span><span class="p">(),</span> <span class="bp">self</span><span class="o">.</span><span class="n">firstname</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span> <span class="o">==</span>

  453.                 <span class="p">(</span><span class="n">other</span><span class="o">.</span><span class="n">lastname</span><span class="o">.</span><span class="n">lower</span><span class="p">(),</span> <span class="n">other</span><span class="o">.</span><span class="n">firstname</span><span class="o">.</span><span class="n">lower</span><span class="p">()))</span>

  454.     <span class="k">def</span> <span class="fm">__lt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>

  455.         <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">_is_valid_operand</span><span class="p">(</span><span class="n">other</span><span class="p">):</span>

  456.             <span class="k">return</span> <span class="bp">NotImplemented</span>

  457.         <span class="k">return</span> <span class="p">((</span><span class="bp">self</span><span class="o">.</span><span class="n">lastname</span><span class="o">.</span><span class="n">lower</span><span class="p">(),</span> <span class="bp">self</span><span class="o">.</span><span class="n">firstname</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span> <span class="o">&lt;</span>

  458.                 <span class="p">(</span><span class="n">other</span><span class="o">.</span><span class="n">lastname</span><span class="o">.</span><span class="n">lower</span><span class="p">(),</span> <span class="n">other</span><span class="o">.</span><span class="n">firstname</span><span class="o">.</span><span class="n">lower</span><span class="p">()))</span>

  459. </pre></div>

  460. </div>

  461. <div class="admonition note">

  462. <p class="admonition-title">Note</p>

  463. <p>While this decorator makes it easy to create well behaved totally

  464. ordered types, it <em>does</em> come at the cost of slower execution and

  465. more complex stack traces for the derived comparison methods. If

  466. performance benchmarking indicates this is a bottleneck for a given

  467. application, implementing all six rich comparison methods instead is

  468. likely to provide an easy speed boost.</p>

  469. </div>

  470. <div class="admonition note">

  471. <p class="admonition-title">Note</p>

  472. <p>This decorator makes no attempt to override methods that have been

  473. declared in the class <em>or its superclasses</em>. Meaning that if a

  474. superclass defines a comparison operator, <em>total_ordering</em> will not

  475. implement it again, even if the original method is abstract.</p>

  476. </div>

  477. <div class="versionadded">

  478. <p><span class="versionmodified added">New in version 3.2.</span></p>

  479. </div>

  480. <div class="versionchanged">

  481. <p><span class="versionmodified changed">Changed in version 3.4: </span>Returning NotImplemented from the underlying comparison function for

  482. unrecognised types is now supported.</p>

  483. </div>

  484. </dd></dl>

  485. 

  486. <dl class="py function">

  487. <dt class="sig sig-object py" id="functools.partial">

  488. <span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">partial</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">keywords</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.partial" title="Link to this definition">¶</a></dt>

  489. <dd><p>Return a new <a class="reference internal" href="#partial-objects"><span class="std std-ref">partial object</span></a> which when called

  490. will behave like <em>func</em> called with the positional arguments <em>args</em>

  491. and keyword arguments <em>keywords</em>. If more arguments are supplied to the

  492. call, they are appended to <em>args</em>. If additional keyword arguments are

  493. supplied, they extend and override <em>keywords</em>.

  494. Roughly equivalent to:</p>

  495. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">partial</span><span class="p">(</span><span class="n">func</span><span class="p">,</span> <span class="o">/</span><span class="p">,</span> <span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">keywords</span><span class="p">):</span>

  496.     <span class="k">def</span> <span class="nf">newfunc</span><span class="p">(</span><span class="o">*</span><span class="n">fargs</span><span class="p">,</span> <span class="o">**</span><span class="n">fkeywords</span><span class="p">):</span>

  497.         <span class="n">newkeywords</span> <span class="o">=</span> <span class="p">{</span><span class="o">**</span><span class="n">keywords</span><span class="p">,</span> <span class="o">**</span><span class="n">fkeywords</span><span class="p">}</span>

  498.         <span class="k">return</span> <span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">*</span><span class="n">fargs</span><span class="p">,</span> <span class="o">**</span><span class="n">newkeywords</span><span class="p">)</span>

  499.     <span class="n">newfunc</span><span class="o">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>

  500.     <span class="n">newfunc</span><span class="o">.</span><span class="n">args</span> <span class="o">=</span> <span class="n">args</span>

  501.     <span class="n">newfunc</span><span class="o">.</span><span class="n">keywords</span> <span class="o">=</span> <span class="n">keywords</span>

  502.     <span class="k">return</span> <span class="n">newfunc</span>

  503. </pre></div>

  504. </div>

  505. <p>The <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-func docutils literal notranslate"><span class="pre">partial()</span></code></a> is used for partial function application which “freezes”

  506. some portion of a function’s arguments and/or keywords resulting in a new object

  507. with a simplified signature.  For example, <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-func docutils literal notranslate"><span class="pre">partial()</span></code></a> can be used to create

  508. a callable that behaves like the <a class="reference internal" href="functions.html#int" title="int"><code class="xref py py-func docutils literal notranslate"><span class="pre">int()</span></code></a> function where the <em>base</em> argument

  509. defaults to two:</p>

  510. <div class="doctest highlight-default notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="n">partial</span>

  511. <span class="gp">&gt;&gt;&gt; </span><span class="n">basetwo</span> <span class="o">=</span> <span class="n">partial</span><span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="n">base</span><span class="o">=</span><span class="mi">2</span><span class="p">)</span>

  512. <span class="gp">&gt;&gt;&gt; </span><span class="n">basetwo</span><span class="o">.</span><span class="vm">__doc__</span> <span class="o">=</span> <span class="s1">&#39;Convert base 2 string to an int.&#39;</span>

  513. <span class="gp">&gt;&gt;&gt; </span><span class="n">basetwo</span><span class="p">(</span><span class="s1">&#39;10010&#39;</span><span class="p">)</span>

  514. <span class="go">18</span>

  515. </pre></div>

  516. </div>

  517. </dd></dl>

  518. 

  519. <dl class="py class">

  520. <dt class="sig sig-object py" id="functools.partialmethod">

  521. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">partialmethod</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">/</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">*</span></span><span class="n"><span class="pre">args</span></span></em>, <em class="sig-param"><span class="o"><span class="pre">**</span></span><span class="n"><span class="pre">keywords</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.partialmethod" title="Link to this definition">¶</a></dt>

  522. <dd><p>Return a new <a class="reference internal" href="#functools.partialmethod" title="functools.partialmethod"><code class="xref py py-class docutils literal notranslate"><span class="pre">partialmethod</span></code></a> descriptor which behaves

  523. like <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> except that it is designed to be used as a method

  524. definition rather than being directly callable.</p>

  525. <p><em>func</em> must be a <a class="reference internal" href="../glossary.html#term-descriptor"><span class="xref std std-term">descriptor</span></a> or a callable (objects which are both,

  526. like normal functions, are handled as descriptors).</p>

  527. <p>When <em>func</em> is a descriptor (such as a normal Python function,

  528. <a class="reference internal" href="functions.html#classmethod" title="classmethod"><code class="xref py py-func docutils literal notranslate"><span class="pre">classmethod()</span></code></a>, <a class="reference internal" href="functions.html#staticmethod" title="staticmethod"><code class="xref py py-func docutils literal notranslate"><span class="pre">staticmethod()</span></code></a>, <code class="xref py py-func docutils literal notranslate"><span class="pre">abstractmethod()</span></code> or

  529. another instance of <a class="reference internal" href="#functools.partialmethod" title="functools.partialmethod"><code class="xref py py-class docutils literal notranslate"><span class="pre">partialmethod</span></code></a>), calls to <code class="docutils literal notranslate"><span class="pre">__get__</span></code> are

  530. delegated to the underlying descriptor, and an appropriate

  531. <a class="reference internal" href="#partial-objects"><span class="std std-ref">partial object</span></a> returned as the result.</p>

  532. <p>When <em>func</em> is a non-descriptor callable, an appropriate bound method is

  533. created dynamically. This behaves like a normal Python function when

  534. used as a method: the <em>self</em> argument will be inserted as the first

  535. positional argument, even before the <em>args</em> and <em>keywords</em> supplied to

  536. the <a class="reference internal" href="#functools.partialmethod" title="functools.partialmethod"><code class="xref py py-class docutils literal notranslate"><span class="pre">partialmethod</span></code></a> constructor.</p>

  537. <p>Example:</p>

  538. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="k">class</span> <span class="nc">Cell</span><span class="p">:</span>

  539. <span class="gp">... </span>    <span class="k">def</span> <span class="fm">__init__</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>

  540. <span class="gp">... </span>        <span class="bp">self</span><span class="o">.</span><span class="n">_alive</span> <span class="o">=</span> <span class="kc">False</span>

  541. <span class="gp">... </span>    <span class="nd">@property</span>

  542. <span class="gp">... </span>    <span class="k">def</span> <span class="nf">alive</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>

  543. <span class="gp">... </span>        <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">_alive</span>

  544. <span class="gp">... </span>    <span class="k">def</span> <span class="nf">set_state</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">state</span><span class="p">):</span>

  545. <span class="gp">... </span>        <span class="bp">self</span><span class="o">.</span><span class="n">_alive</span> <span class="o">=</span> <span class="nb">bool</span><span class="p">(</span><span class="n">state</span><span class="p">)</span>

  546. <span class="gp">... </span>    <span class="n">set_alive</span> <span class="o">=</span> <span class="n">partialmethod</span><span class="p">(</span><span class="n">set_state</span><span class="p">,</span> <span class="kc">True</span><span class="p">)</span>

  547. <span class="gp">... </span>    <span class="n">set_dead</span> <span class="o">=</span> <span class="n">partialmethod</span><span class="p">(</span><span class="n">set_state</span><span class="p">,</span> <span class="kc">False</span><span class="p">)</span>

  548. <span class="gp">...</span>

  549. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span> <span class="o">=</span> <span class="n">Cell</span><span class="p">()</span>

  550. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="o">.</span><span class="n">alive</span>

  551. <span class="go">False</span>

  552. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="o">.</span><span class="n">set_alive</span><span class="p">()</span>

  553. <span class="gp">&gt;&gt;&gt; </span><span class="n">c</span><span class="o">.</span><span class="n">alive</span>

  554. <span class="go">True</span>

  555. </pre></div>

  556. </div>

  557. <div class="versionadded">

  558. <p><span class="versionmodified added">New in version 3.4.</span></p>

  559. </div>

  560. </dd></dl>

  561. 

  562. <dl class="py function">

  563. <dt class="sig sig-object py" id="functools.reduce">

  564. <span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">reduce</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">function</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">iterable</span></span></em><span class="optional">[</span>, <em class="sig-param"><span class="n"><span class="pre">initializer</span></span></em><span class="optional">]</span><span class="sig-paren">)</span><a class="headerlink" href="#functools.reduce" title="Link to this definition">¶</a></dt>

  565. <dd><p>Apply <em>function</em> of two arguments cumulatively to the items of <em>iterable</em>, from

  566. left to right, so as to reduce the iterable to a single value.  For example,

  567. <code class="docutils literal notranslate"><span class="pre">reduce(lambda</span> <span class="pre">x,</span> <span class="pre">y:</span> <span class="pre">x+y,</span> <span class="pre">[1,</span> <span class="pre">2,</span> <span class="pre">3,</span> <span class="pre">4,</span> <span class="pre">5])</span></code> calculates <code class="docutils literal notranslate"><span class="pre">((((1+2)+3)+4)+5)</span></code>.

  568. The left argument, <em>x</em>, is the accumulated value and the right argument, <em>y</em>, is

  569. the update value from the <em>iterable</em>.  If the optional <em>initializer</em> is present,

  570. it is placed before the items of the iterable in the calculation, and serves as

  571. a default when the iterable is empty.  If <em>initializer</em> is not given and

  572. <em>iterable</em> contains only one item, the first item is returned.</p>

  573. <p>Roughly equivalent to:</p>

  574. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">def</span> <span class="nf">reduce</span><span class="p">(</span><span class="n">function</span><span class="p">,</span> <span class="n">iterable</span><span class="p">,</span> <span class="n">initializer</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>

  575.     <span class="n">it</span> <span class="o">=</span> <span class="nb">iter</span><span class="p">(</span><span class="n">iterable</span><span class="p">)</span>

  576.     <span class="k">if</span> <span class="n">initializer</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">:</span>

  577.         <span class="n">value</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">it</span><span class="p">)</span>

  578.     <span class="k">else</span><span class="p">:</span>

  579.         <span class="n">value</span> <span class="o">=</span> <span class="n">initializer</span>

  580.     <span class="k">for</span> <span class="n">element</span> <span class="ow">in</span> <span class="n">it</span><span class="p">:</span>

  581.         <span class="n">value</span> <span class="o">=</span> <span class="n">function</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">element</span><span class="p">)</span>

  582.     <span class="k">return</span> <span class="n">value</span>

  583. </pre></div>

  584. </div>

  585. <p>See <a class="reference internal" href="itertools.html#itertools.accumulate" title="itertools.accumulate"><code class="xref py py-func docutils literal notranslate"><span class="pre">itertools.accumulate()</span></code></a> for an iterator that yields all intermediate

  586. values.</p>

  587. </dd></dl>

  588. 

  589. <dl class="py function">

  590. <dt class="sig sig-object py" id="functools.singledispatch">

  591. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">singledispatch</span></span><a class="headerlink" href="#functools.singledispatch" title="Link to this definition">¶</a></dt>

  592. <dd><p>Transform a function into a <a class="reference internal" href="../glossary.html#term-single-dispatch"><span class="xref std std-term">single-dispatch</span></a> <a class="reference internal" href="../glossary.html#term-generic-function"><span class="xref std std-term">generic function</span></a>.</p>

  593. <p>To define a generic function, decorate it with the <code class="docutils literal notranslate"><span class="pre">&#64;singledispatch</span></code>

  594. decorator. When defining a function using <code class="docutils literal notranslate"><span class="pre">&#64;singledispatch</span></code>, note that the

  595. dispatch happens on the type of the first argument:</p>

  596. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="n">singledispatch</span>

  597. <span class="gp">&gt;&gt;&gt; </span><span class="nd">@singledispatch</span>

  598. <span class="gp">... </span><span class="k">def</span> <span class="nf">fun</span><span class="p">(</span><span class="n">arg</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  599. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  600. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Let me just say,&quot;</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">&quot; &quot;</span><span class="p">)</span>

  601. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>

  602. </pre></div>

  603. </div>

  604. <p>To add overloaded implementations to the function, use the <code class="xref py py-func docutils literal notranslate"><span class="pre">register()</span></code>

  605. attribute of the generic function, which can be used as a decorator.  For

  606. functions annotated with types, the decorator will infer the type of the

  607. first argument automatically:</p>

  608. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span>

  609. <span class="gp">... </span><span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="n">arg</span><span class="p">:</span> <span class="nb">int</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  610. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  611. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Strength in numbers, eh?&quot;</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">&quot; &quot;</span><span class="p">)</span>

  612. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>

  613. <span class="gp">...</span>

  614. <span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span>

  615. <span class="gp">... </span><span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="n">arg</span><span class="p">:</span> <span class="nb">list</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  616. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  617. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Enumerate this:&quot;</span><span class="p">)</span>

  618. <span class="gp">... </span>    <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">elem</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">arg</span><span class="p">):</span>

  619. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">elem</span><span class="p">)</span>

  620. </pre></div>

  621. </div>

  622. <p><a class="reference internal" href="types.html#types.UnionType" title="types.UnionType"><code class="xref py py-data docutils literal notranslate"><span class="pre">types.UnionType</span></code></a> and <a class="reference internal" href="typing.html#typing.Union" title="typing.Union"><code class="xref py py-data docutils literal notranslate"><span class="pre">typing.Union</span></code></a> can also be used:</p>

  623. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span>

  624. <span class="gp">... </span><span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="n">arg</span><span class="p">:</span> <span class="nb">int</span> <span class="o">|</span> <span class="nb">float</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  625. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  626. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Strength in numbers, eh?&quot;</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">&quot; &quot;</span><span class="p">)</span>

  627. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">arg</span><span class="p">)</span>

  628. <span class="gp">...</span>

  629. <span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Union</span>

  630. <span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span>

  631. <span class="gp">... </span><span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="n">arg</span><span class="p">:</span> <span class="n">Union</span><span class="p">[</span><span class="nb">list</span><span class="p">,</span> <span class="nb">set</span><span class="p">],</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  632. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  633. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Enumerate this:&quot;</span><span class="p">)</span>

  634. <span class="gp">... </span>    <span class="k">for</span> <span class="n">i</span><span class="p">,</span> <span class="n">elem</span> <span class="ow">in</span> <span class="nb">enumerate</span><span class="p">(</span><span class="n">arg</span><span class="p">):</span>

  635. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="n">i</span><span class="p">,</span> <span class="n">elem</span><span class="p">)</span>

  636. <span class="gp">...</span>

  637. </pre></div>

  638. </div>

  639. <p>For code which doesn’t use type annotations, the appropriate type

  640. argument can be passed explicitly to the decorator itself:</p>

  641. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">complex</span><span class="p">)</span>

  642. <span class="gp">... </span><span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="n">arg</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  643. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  644. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Better than complicated.&quot;</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">&quot; &quot;</span><span class="p">)</span>

  645. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">arg</span><span class="o">.</span><span class="n">real</span><span class="p">,</span> <span class="n">arg</span><span class="o">.</span><span class="n">imag</span><span class="p">)</span>

  646. <span class="gp">...</span>

  647. </pre></div>

  648. </div>

  649. <p>To enable registering <a class="reference internal" href="../glossary.html#term-lambda"><span class="xref std std-term">lambdas</span></a> and pre-existing functions,

  650. the <code class="xref py py-func docutils literal notranslate"><span class="pre">register()</span></code> attribute can also be used in a functional form:</p>

  651. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">nothing</span><span class="p">(</span><span class="n">arg</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  652. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Nothing.&quot;</span><span class="p">)</span>

  653. <span class="gp">...</span>

  654. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="kc">None</span><span class="p">),</span> <span class="n">nothing</span><span class="p">)</span>

  655. </pre></div>

  656. </div>

  657. <p>The <code class="xref py py-func docutils literal notranslate"><span class="pre">register()</span></code> attribute returns the undecorated function. This

  658. enables decorator stacking, <a class="reference internal" href="pickle.html#module-pickle" title="pickle: Convert Python objects to streams of bytes and back."><code class="xref py py-mod docutils literal notranslate"><span class="pre">pickling</span></code></a>, and the creation

  659. of unit tests for each variant independently:</p>

  660. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="nb">float</span><span class="p">)</span>

  661. <span class="gp">... </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span><span class="p">(</span><span class="n">Decimal</span><span class="p">)</span>

  662. <span class="gp">... </span><span class="k">def</span> <span class="nf">fun_num</span><span class="p">(</span><span class="n">arg</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  663. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  664. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Half of your number:&quot;</span><span class="p">,</span> <span class="n">end</span><span class="o">=</span><span class="s2">&quot; &quot;</span><span class="p">)</span>

  665. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="n">arg</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span>

  666. <span class="gp">...</span>

  667. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun_num</span> <span class="ow">is</span> <span class="n">fun</span>

  668. <span class="go">False</span>

  669. </pre></div>

  670. </div>

  671. <p>When called, the generic function dispatches on the type of the first

  672. argument:</p>

  673. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">(</span><span class="s2">&quot;Hello, world.&quot;</span><span class="p">)</span>

  674. <span class="go">Hello, world.</span>

  675. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">(</span><span class="s2">&quot;test.&quot;</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>

  676. <span class="go">Let me just say, test.</span>

  677. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">(</span><span class="mi">42</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>

  678. <span class="go">Strength in numbers, eh? 42</span>

  679. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">([</span><span class="s1">&#39;spam&#39;</span><span class="p">,</span> <span class="s1">&#39;spam&#39;</span><span class="p">,</span> <span class="s1">&#39;eggs&#39;</span><span class="p">,</span> <span class="s1">&#39;spam&#39;</span><span class="p">],</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>

  680. <span class="go">Enumerate this:</span>

  681. <span class="go">0 spam</span>

  682. <span class="go">1 spam</span>

  683. <span class="go">2 eggs</span>

  684. <span class="go">3 spam</span>

  685. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">(</span><span class="kc">None</span><span class="p">)</span>

  686. <span class="go">Nothing.</span>

  687. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">(</span><span class="mf">1.23</span><span class="p">)</span>

  688. <span class="go">0.615</span>

  689. </pre></div>

  690. </div>

  691. <p>Where there is no registered implementation for a specific type, its

  692. method resolution order is used to find a more generic implementation.

  693. The original function decorated with <code class="docutils literal notranslate"><span class="pre">&#64;singledispatch</span></code> is registered

  694. for the base <a class="reference internal" href="functions.html#object" title="object"><code class="xref py py-class docutils literal notranslate"><span class="pre">object</span></code></a> type, which means it is used if no better

  695. implementation is found.</p>

  696. <p>If an implementation is registered to an <a class="reference internal" href="../glossary.html#term-abstract-base-class"><span class="xref std std-term">abstract base class</span></a>,

  697. virtual subclasses of the base class will be dispatched to that

  698. implementation:</p>

  699. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">collections.abc</span> <span class="kn">import</span> <span class="n">Mapping</span>

  700. <span class="gp">&gt;&gt;&gt; </span><span class="nd">@fun</span><span class="o">.</span><span class="n">register</span>

  701. <span class="gp">... </span><span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="n">arg</span><span class="p">:</span> <span class="n">Mapping</span><span class="p">,</span> <span class="n">verbose</span><span class="o">=</span><span class="kc">False</span><span class="p">):</span>

  702. <span class="gp">... </span>    <span class="k">if</span> <span class="n">verbose</span><span class="p">:</span>

  703. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Keys &amp; Values&quot;</span><span class="p">)</span>

  704. <span class="gp">... </span>    <span class="k">for</span> <span class="n">key</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="n">arg</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>

  705. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="n">key</span><span class="p">,</span> <span class="s2">&quot;=&gt;&quot;</span><span class="p">,</span> <span class="n">value</span><span class="p">)</span>

  706. <span class="gp">...</span>

  707. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="p">({</span><span class="s2">&quot;a&quot;</span><span class="p">:</span> <span class="s2">&quot;b&quot;</span><span class="p">})</span>

  708. <span class="go">a =&gt; b</span>

  709. </pre></div>

  710. </div>

  711. <p>To check which implementation the generic function will choose for

  712. a given type, use the <code class="docutils literal notranslate"><span class="pre">dispatch()</span></code> attribute:</p>

  713. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="o">.</span><span class="n">dispatch</span><span class="p">(</span><span class="nb">float</span><span class="p">)</span>

  714. <span class="go">&lt;function fun_num at 0x1035a2840&gt;</span>

  715. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="o">.</span><span class="n">dispatch</span><span class="p">(</span><span class="nb">dict</span><span class="p">)</span>    <span class="c1"># note: default implementation</span>

  716. <span class="go">&lt;function fun at 0x103fe0000&gt;</span>

  717. </pre></div>

  718. </div>

  719. <p>To access all registered implementations, use the read-only <code class="docutils literal notranslate"><span class="pre">registry</span></code>

  720. attribute:</p>

  721. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="o">.</span><span class="n">registry</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>

  722. <span class="go">dict_keys([&lt;class &#39;NoneType&#39;&gt;, &lt;class &#39;int&#39;&gt;, &lt;class &#39;object&#39;&gt;,</span>

  723. <span class="go">          &lt;class &#39;decimal.Decimal&#39;&gt;, &lt;class &#39;list&#39;&gt;,</span>

  724. <span class="go">          &lt;class &#39;float&#39;&gt;])</span>

  725. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="o">.</span><span class="n">registry</span><span class="p">[</span><span class="nb">float</span><span class="p">]</span>

  726. <span class="go">&lt;function fun_num at 0x1035a2840&gt;</span>

  727. <span class="gp">&gt;&gt;&gt; </span><span class="n">fun</span><span class="o">.</span><span class="n">registry</span><span class="p">[</span><span class="nb">object</span><span class="p">]</span>

  728. <span class="go">&lt;function fun at 0x103fe0000&gt;</span>

  729. </pre></div>

  730. </div>

  731. <div class="versionadded">

  732. <p><span class="versionmodified added">New in version 3.4.</span></p>

  733. </div>

  734. <div class="versionchanged">

  735. <p><span class="versionmodified changed">Changed in version 3.7: </span>The <code class="xref py py-func docutils literal notranslate"><span class="pre">register()</span></code> attribute now supports using type annotations.</p>

  736. </div>

  737. <div class="versionchanged">

  738. <p><span class="versionmodified changed">Changed in version 3.11: </span>The <code class="xref py py-func docutils literal notranslate"><span class="pre">register()</span></code> attribute now supports <a class="reference internal" href="types.html#types.UnionType" title="types.UnionType"><code class="xref py py-data docutils literal notranslate"><span class="pre">types.UnionType</span></code></a>

  739. and <a class="reference internal" href="typing.html#typing.Union" title="typing.Union"><code class="xref py py-data docutils literal notranslate"><span class="pre">typing.Union</span></code></a> as type annotations.</p>

  740. </div>

  741. </dd></dl>

  742. 

  743. <dl class="py class">

  744. <dt class="sig sig-object py" id="functools.singledispatchmethod">

  745. <em class="property"><span class="pre">class</span><span class="w"> </span></em><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">singledispatchmethod</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">func</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.singledispatchmethod" title="Link to this definition">¶</a></dt>

  746. <dd><p>Transform a method into a <a class="reference internal" href="../glossary.html#term-single-dispatch"><span class="xref std std-term">single-dispatch</span></a> <a class="reference internal" href="../glossary.html#term-generic-function"><span class="xref std std-term">generic function</span></a>.</p>

  747. <p>To define a generic method, decorate it with the <code class="docutils literal notranslate"><span class="pre">&#64;singledispatchmethod</span></code>

  748. decorator. When defining a function using <code class="docutils literal notranslate"><span class="pre">&#64;singledispatchmethod</span></code>, note

  749. that the dispatch happens on the type of the first non-<em>self</em> or non-<em>cls</em>

  750. argument:</p>

  751. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Negator</span><span class="p">:</span>

  752.     <span class="nd">@singledispatchmethod</span>

  753.     <span class="k">def</span> <span class="nf">neg</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">arg</span><span class="p">):</span>

  754.         <span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">&quot;Cannot negate a&quot;</span><span class="p">)</span>

  755. 

  756.     <span class="nd">@neg</span><span class="o">.</span><span class="n">register</span>

  757.     <span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">arg</span><span class="p">:</span> <span class="nb">int</span><span class="p">):</span>

  758.         <span class="k">return</span> <span class="o">-</span><span class="n">arg</span>

  759. 

  760.     <span class="nd">@neg</span><span class="o">.</span><span class="n">register</span>

  761.     <span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">arg</span><span class="p">:</span> <span class="nb">bool</span><span class="p">):</span>

  762.         <span class="k">return</span> <span class="ow">not</span> <span class="n">arg</span>

  763. </pre></div>

  764. </div>

  765. <p><code class="docutils literal notranslate"><span class="pre">&#64;singledispatchmethod</span></code> supports nesting with other decorators such as

  766. <a class="reference internal" href="functions.html#classmethod" title="classmethod"><code class="xref py py-func docutils literal notranslate"><span class="pre">&#64;classmethod</span></code></a>. Note that to allow for

  767. <code class="docutils literal notranslate"><span class="pre">dispatcher.register</span></code>, <code class="docutils literal notranslate"><span class="pre">singledispatchmethod</span></code> must be the <em>outer most</em>

  768. decorator. Here is the <code class="docutils literal notranslate"><span class="pre">Negator</span></code> class with the <code class="docutils literal notranslate"><span class="pre">neg</span></code> methods bound to

  769. the class, rather than an instance of the class:</p>

  770. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="k">class</span> <span class="nc">Negator</span><span class="p">:</span>

  771.     <span class="nd">@singledispatchmethod</span>

  772.     <span class="nd">@classmethod</span>

  773.     <span class="k">def</span> <span class="nf">neg</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">arg</span><span class="p">):</span>

  774.         <span class="k">raise</span> <span class="ne">NotImplementedError</span><span class="p">(</span><span class="s2">&quot;Cannot negate a&quot;</span><span class="p">)</span>

  775. 

  776.     <span class="nd">@neg</span><span class="o">.</span><span class="n">register</span>

  777.     <span class="nd">@classmethod</span>

  778.     <span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">arg</span><span class="p">:</span> <span class="nb">int</span><span class="p">):</span>

  779.         <span class="k">return</span> <span class="o">-</span><span class="n">arg</span>

  780. 

  781.     <span class="nd">@neg</span><span class="o">.</span><span class="n">register</span>

  782.     <span class="nd">@classmethod</span>

  783.     <span class="k">def</span> <span class="nf">_</span><span class="p">(</span><span class="bp">cls</span><span class="p">,</span> <span class="n">arg</span><span class="p">:</span> <span class="nb">bool</span><span class="p">):</span>

  784.         <span class="k">return</span> <span class="ow">not</span> <span class="n">arg</span>

  785. </pre></div>

  786. </div>

  787. <p>The same pattern can be used for other similar decorators:

  788. <a class="reference internal" href="functions.html#staticmethod" title="staticmethod"><code class="xref py py-func docutils literal notranslate"><span class="pre">&#64;staticmethod</span></code></a>,

  789. <a class="reference internal" href="abc.html#abc.abstractmethod" title="abc.abstractmethod"><code class="xref py py-func docutils literal notranslate"><span class="pre">&#64;abstractmethod</span></code></a>, and others.</p>

  790. <div class="versionadded">

  791. <p><span class="versionmodified added">New in version 3.8.</span></p>

  792. </div>

  793. </dd></dl>

  794. 

  795. <dl class="py function">

  796. <dt class="sig sig-object py" id="functools.update_wrapper">

  797. <span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">update_wrapper</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">wrapper</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">wrapped</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">assigned</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">WRAPPER_ASSIGNMENTS</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">updated</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">WRAPPER_UPDATES</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.update_wrapper" title="Link to this definition">¶</a></dt>

  798. <dd><p>Update a <em>wrapper</em> function to look like the <em>wrapped</em> function. The optional

  799. arguments are tuples to specify which attributes of the original function are

  800. assigned directly to the matching attributes on the wrapper function and which

  801. attributes of the wrapper function are updated with the corresponding attributes

  802. from the original function. The default values for these arguments are the

  803. module level constants <code class="docutils literal notranslate"><span class="pre">WRAPPER_ASSIGNMENTS</span></code> (which assigns to the wrapper

  804. function’s <code class="docutils literal notranslate"><span class="pre">__module__</span></code>, <code class="docutils literal notranslate"><span class="pre">__name__</span></code>, <code class="docutils literal notranslate"><span class="pre">__qualname__</span></code>, <code class="docutils literal notranslate"><span class="pre">__annotations__</span></code>

  805. and <code class="docutils literal notranslate"><span class="pre">__doc__</span></code>, the documentation string) and <code class="docutils literal notranslate"><span class="pre">WRAPPER_UPDATES</span></code> (which

  806. updates the wrapper function’s <code class="docutils literal notranslate"><span class="pre">__dict__</span></code>, i.e. the instance dictionary).</p>

  807. <p>To allow access to the original function for introspection and other purposes

  808. (e.g. bypassing a caching decorator such as <a class="reference internal" href="#functools.lru_cache" title="functools.lru_cache"><code class="xref py py-func docutils literal notranslate"><span class="pre">lru_cache()</span></code></a>), this function

  809. automatically adds a <code class="docutils literal notranslate"><span class="pre">__wrapped__</span></code> attribute to the wrapper that refers to

  810. the function being wrapped.</p>

  811. <p>The main intended use for this function is in <a class="reference internal" href="../glossary.html#term-decorator"><span class="xref std std-term">decorator</span></a> functions which

  812. wrap the decorated function and return the wrapper. If the wrapper function is

  813. not updated, the metadata of the returned function will reflect the wrapper

  814. definition rather than the original function definition, which is typically less

  815. than helpful.</p>

  816. <p><a class="reference internal" href="#functools.update_wrapper" title="functools.update_wrapper"><code class="xref py py-func docutils literal notranslate"><span class="pre">update_wrapper()</span></code></a> may be used with callables other than functions. Any

  817. attributes named in <em>assigned</em> or <em>updated</em> that are missing from the object

  818. being wrapped are ignored (i.e. this function will not attempt to set them

  819. on the wrapper function). <a class="reference internal" href="exceptions.html#AttributeError" title="AttributeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">AttributeError</span></code></a> is still raised if the

  820. wrapper function itself is missing any attributes named in <em>updated</em>.</p>

  821. <div class="versionchanged">

  822. <p><span class="versionmodified changed">Changed in version 3.2: </span>The <code class="docutils literal notranslate"><span class="pre">__wrapped__</span></code> attribute is now automatically added.

  823. The <code class="docutils literal notranslate"><span class="pre">__annotations__</span></code> attribute is now copied by default.

  824. Missing attributes no longer trigger an <a class="reference internal" href="exceptions.html#AttributeError" title="AttributeError"><code class="xref py py-exc docutils literal notranslate"><span class="pre">AttributeError</span></code></a>.</p>

  825. </div>

  826. <div class="versionchanged">

  827. <p><span class="versionmodified changed">Changed in version 3.4: </span>The <code class="docutils literal notranslate"><span class="pre">__wrapped__</span></code> attribute now always refers to the wrapped

  828. function, even if that function defined a <code class="docutils literal notranslate"><span class="pre">__wrapped__</span></code> attribute.

  829. (see <a class="reference external" href="https://bugs.python.org/issue?&#64;action=redirect&amp;bpo=17482">bpo-17482</a>)</p>

  830. </div>

  831. </dd></dl>

  832. 

  833. <dl class="py function">

  834. <dt class="sig sig-object py" id="functools.wraps">

  835. <span class="sig-prename descclassname"><span class="pre">&#64;</span></span><span class="sig-prename descclassname"><span class="pre">functools.</span></span><span class="sig-name descname"><span class="pre">wraps</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">wrapped</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">assigned</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">WRAPPER_ASSIGNMENTS</span></span></em>, <em class="sig-param"><span class="n"><span class="pre">updated</span></span><span class="o"><span class="pre">=</span></span><span class="default_value"><span class="pre">WRAPPER_UPDATES</span></span></em><span class="sig-paren">)</span><a class="headerlink" href="#functools.wraps" title="Link to this definition">¶</a></dt>

  836. <dd><p>This is a convenience function for invoking <a class="reference internal" href="#functools.update_wrapper" title="functools.update_wrapper"><code class="xref py py-func docutils literal notranslate"><span class="pre">update_wrapper()</span></code></a> as a

  837. function decorator when defining a wrapper function.  It is equivalent to

  838. <code class="docutils literal notranslate"><span class="pre">partial(update_wrapper,</span> <span class="pre">wrapped=wrapped,</span> <span class="pre">assigned=assigned,</span> <span class="pre">updated=updated)</span></code>.

  839. For example:</p>

  840. <div class="highlight-python3 notranslate"><div class="highlight"><pre><span></span><span class="gp">&gt;&gt;&gt; </span><span class="kn">from</span> <span class="nn">functools</span> <span class="kn">import</span> <span class="n">wraps</span>

  841. <span class="gp">&gt;&gt;&gt; </span><span class="k">def</span> <span class="nf">my_decorator</span><span class="p">(</span><span class="n">f</span><span class="p">):</span>

  842. <span class="gp">... </span>    <span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>

  843. <span class="gp">... </span>    <span class="k">def</span> <span class="nf">wrapper</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">):</span>

  844. <span class="gp">... </span>        <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Calling decorated function&#39;</span><span class="p">)</span>

  845. <span class="gp">... </span>        <span class="k">return</span> <span class="n">f</span><span class="p">(</span><span class="o">*</span><span class="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">kwds</span><span class="p">)</span>

  846. <span class="gp">... </span>    <span class="k">return</span> <span class="n">wrapper</span>

  847. <span class="gp">...</span>

  848. <span class="gp">&gt;&gt;&gt; </span><span class="nd">@my_decorator</span>

  849. <span class="gp">... </span><span class="k">def</span> <span class="nf">example</span><span class="p">():</span>

  850. <span class="gp">... </span><span class="w">    </span><span class="sd">&quot;&quot;&quot;Docstring&quot;&quot;&quot;</span>

  851. <span class="gp">... </span>    <span class="nb">print</span><span class="p">(</span><span class="s1">&#39;Called example function&#39;</span><span class="p">)</span>

  852. <span class="gp">...</span>

  853. <span class="gp">&gt;&gt;&gt; </span><span class="n">example</span><span class="p">()</span>

  854. <span class="go">Calling decorated function</span>

  855. <span class="go">Called example function</span>

  856. <span class="gp">&gt;&gt;&gt; </span><span class="n">example</span><span class="o">.</span><span class="vm">__name__</span>

  857. <span class="go">&#39;example&#39;</span>

  858. <span class="gp">&gt;&gt;&gt; </span><span class="n">example</span><span class="o">.</span><span class="vm">__doc__</span>

  859. <span class="go">&#39;Docstring&#39;</span>

  860. </pre></div>

  861. </div>

  862. <p>Without the use of this decorator factory, the name of the example function

  863. would have been <code class="docutils literal notranslate"><span class="pre">'wrapper'</span></code>, and the docstring of the original <code class="xref py py-func docutils literal notranslate"><span class="pre">example()</span></code>

  864. would have been lost.</p>

  865. </dd></dl>

  866. 

  867. <section id="partial-objects">

  868. <span id="id1"></span><h2><a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> Objects<a class="headerlink" href="#partial-objects" title="Link to this heading">¶</a></h2>

  869. <p><a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> objects are callable objects created by <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-func docutils literal notranslate"><span class="pre">partial()</span></code></a>. They

  870. have three read-only attributes:</p>

  871. <dl class="py attribute">

  872. <dt class="sig sig-object py" id="functools.partial.func">

  873. <span class="sig-prename descclassname"><span class="pre">partial.</span></span><span class="sig-name descname"><span class="pre">func</span></span><a class="headerlink" href="#functools.partial.func" title="Link to this definition">¶</a></dt>

  874. <dd><p>A callable object or function.  Calls to the <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> object will be

  875. forwarded to <a class="reference internal" href="#functools.partial.func" title="functools.partial.func"><code class="xref py py-attr docutils literal notranslate"><span class="pre">func</span></code></a> with new arguments and keywords.</p>

  876. </dd></dl>

  877. 

  878. <dl class="py attribute">

  879. <dt class="sig sig-object py" id="functools.partial.args">

  880. <span class="sig-prename descclassname"><span class="pre">partial.</span></span><span class="sig-name descname"><span class="pre">args</span></span><a class="headerlink" href="#functools.partial.args" title="Link to this definition">¶</a></dt>

  881. <dd><p>The leftmost positional arguments that will be prepended to the positional

  882. arguments provided to a <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> object call.</p>

  883. </dd></dl>

  884. 

  885. <dl class="py attribute">

  886. <dt class="sig sig-object py" id="functools.partial.keywords">

  887. <span class="sig-prename descclassname"><span class="pre">partial.</span></span><span class="sig-name descname"><span class="pre">keywords</span></span><a class="headerlink" href="#functools.partial.keywords" title="Link to this definition">¶</a></dt>

  888. <dd><p>The keyword arguments that will be supplied when the <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> object is

  889. called.</p>

  890. </dd></dl>

  891. 

  892. <p><a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> objects are like <code class="xref py py-class docutils literal notranslate"><span class="pre">function</span></code> objects in that they are

  893. callable, weak referenceable, and can have attributes.  There are some important

  894. differences.  For instance, the <a class="reference internal" href="stdtypes.html#definition.__name__" title="definition.__name__"><code class="xref py py-attr docutils literal notranslate"><span class="pre">__name__</span></code></a> and <code class="xref py py-attr docutils literal notranslate"><span class="pre">__doc__</span></code> attributes

  895. are not created automatically.  Also, <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code></a> objects defined in

  896. classes behave like static methods and do not transform into bound methods

  897. during instance attribute look-up.</p>

  898. </section>

  899. </section>

  900. 

  901. 

  902.             <div class="clearer"></div>

  903.           </div>

  904.         </div>

  905.       </div>

  906.       <div class="sphinxsidebar" role="navigation" aria-label="main navigation">

  907.         <div class="sphinxsidebarwrapper">

  908.   <div>

  909.     <h3><a href="../contents.html">Table of Contents</a></h3>

  910.     <ul>

  911. <li><a class="reference internal" href="#"><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code> — Higher-order functions and operations on callable objects</a><ul>

  912. <li><a class="reference internal" href="#partial-objects"><code class="xref py py-class docutils literal notranslate"><span class="pre">partial</span></code> Objects</a></li>

  913. </ul>

  914. </li>

  915. </ul>

  916. 

  917.   </div>

  918.   <div>

  919.     <h4>Previous topic</h4>

  920.     <p class="topless"><a href="itertools.html"

  921.                           title="previous chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">itertools</span></code> — Functions creating iterators for efficient looping</a></p>

  922.   </div>

  923.   <div>

  924.     <h4>Next topic</h4>

  925.     <p class="topless"><a href="operator.html"

  926.                           title="next chapter"><code class="xref py py-mod docutils literal notranslate"><span class="pre">operator</span></code> — Standard operators as functions</a></p>

  927.   </div>

  928.   <div role="note" aria-label="source link">

  929.     <h3>This Page</h3>

  930.     <ul class="this-page-menu">

  931.       <li><a href="../bugs.html">Report a Bug</a></li>

  932.       <li>

  933.         <a href="https://github.com/python/cpython/blob/main/Doc/library/functools.rst"

  934.             rel="nofollow">Show Source

  935.         </a>

  936.       </li>

  937.     </ul>

  938.   </div>

  939.         </div>

  940. <div id="sidebarbutton" title="Collapse sidebar">

  941. <span>«</span>

  942. </div>

  943. 

  944.       </div>

  945.       <div class="clearer"></div>

  946.     </div>  

  947.     <div class="related" role="navigation" aria-label="related navigation">

  948.       <h3>Navigation</h3>

  949.       <ul>

  950.         <li class="right" style="margin-right: 10px">

  951.           <a href="../genindex.html" title="General Index"

  952.              >index</a></li>

  953.         <li class="right" >

  954.           <a href="../py-modindex.html" title="Python Module Index"

  955.              >modules</a> |</li>

  956.         <li class="right" >

  957.           <a href="operator.html" title="operator — Standard operators as functions"

  958.              >next</a> |</li>

  959.         <li class="right" >

  960.           <a href="itertools.html" title="itertools — Functions creating iterators for efficient looping"

  961.              >previous</a> |</li>

  962. 

  963.           <li><img src="../_static/py.svg" alt="Python logo" style="vertical-align: middle; margin-top: -1px"/></li>

  964.           <li><a href="https://www.python.org/">Python</a> &#187;</li>

  965.           <li class="switchers">

  966.             <div class="language_switcher_placeholder"></div>

  967.             <div class="version_switcher_placeholder"></div>

  968.           </li>

  969.           <li>

  970.               

  971.           </li>

  972.     <li id="cpython-language-and-version">

  973.       <a href="../index.html">3.12.3 Documentation</a> &#187;

  974.     </li>

  975. 

  976.           <li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>

  977.           <li class="nav-item nav-item-2"><a href="functional.html" >Functional Programming Modules</a> &#187;</li>

  978.         <li class="nav-item nav-item-this"><a href=""><code class="xref py py-mod docutils literal notranslate"><span class="pre">functools</span></code> — Higher-order functions and operations on callable objects</a></li>

  979.                 <li class="right">

  980.                     

  981. 

  982.     <div class="inline-search" role="search">

  983.         <form class="inline-search" action="../search.html" method="get">

  984.           <input placeholder="Quick search" aria-label="Quick search" type="search" name="q" id="search-box" />

  985.           <input type="submit" value="Go" />

  986.         </form>

  987.     </div>

  988.                      |

  989.                 </li>

  990.             <li class="right">

  991. <label class="theme-selector-label">

  992.     Theme

  993.     <select class="theme-selector" oninput="activateTheme(this.value)">

  994.         <option value="auto" selected>Auto</option>

  995.         <option value="light">Light</option>

  996.         <option value="dark">Dark</option>

  997.     </select>

  998. </label> |</li>

  999.             

  1000.       </ul>

  1001.     </div>  

  1002.     <div class="footer">

  1003.     &copy; 

  1004.       <a href="../copyright.html">

  1005.     

  1006.     Copyright

  1007.     

  1008.       </a>

  1009.      2001-2024, Python Software Foundation.

  1010.     <br />

  1011.     This page is licensed under the Python Software Foundation License Version 2.

  1012.     <br />

  1013.     Examples, recipes, and other code in the documentation are additionally licensed under the Zero Clause BSD License.

  1014.     <br />

  1015.     

  1016.       See <a href="/license.html">History and License</a> for more information.<br />

  1017.     

  1018.     

  1019.     <br />

  1020. 

  1021.     The Python Software Foundation is a non-profit corporation.

  1022. <a href="https://www.python.org/psf/donations/">Please donate.</a>

  1023. <br />

  1024.     <br />

  1025.       Last updated on Apr 09, 2024 (13:47 UTC).

  1026.     

  1027.       <a href="/bugs.html">Found a bug</a>?

  1028.     

  1029.     <br />

  1030. 

  1031.     Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 7.2.6.

  1032.     </div>

  1033. 

  1034.   </body>

  1035. </html>
上海开阖软件有限公司 沪ICP备12045867号-1