22

✏️ Editing: functools.html

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
 "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
 <head>
 <meta http-equiv="X-UA-Compatible" content="IE=Edge" />
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
 <title>10.2. functools — Higher-order functions and operations on callable objects &#8212; Python 3.6.7 documentation</title>
 <link rel="stylesheet" href="../_static/pydoctheme.css" type="text/css" />
 <link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
 <script type="text/javascript" id="documentation_options" data-url_root="../" src="../_static/documentation_options.js"></script>
 <script type="text/javascript" src="../_static/jquery.js"></script>
 <script type="text/javascript" src="../_static/underscore.js"></script>
 <script type="text/javascript" src="../_static/doctools.js"></script>
 <script type="text/javascript" src="../_static/sidebar.js"></script>
 <link rel="search" type="application/opensearchdescription+xml"
 title="Search within Python 3.6.7 documentation"
 href="../_static/opensearch.xml"/>
 <link rel="author" title="About these documents" href="../about.html" />
 <link rel="index" title="Index" href="../genindex.html" />
 <link rel="search" title="Search" href="../search.html" />
 <link rel="copyright" title="Copyright" href="../copyright.html" />
 <link rel="next" title="10.3. operator — Standard operators as functions" href="operator.html" />
 <link rel="prev" title="10.1. itertools — Functions creating iterators for efficient looping" href="itertools.html" />
 <link rel="shortcut icon" type="image/png" href="../_static/py.png" />
 <link rel="canonical" href="https://docs.python.org/3/library/functools.html" />
 
 <script type="text/javascript" src="../_static/copybutton.js"></script>

</head><body> 
 <div class="related" role="navigation" aria-label="related navigation">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 accesskey="I">index</a></li>
 <li class="right" >
 <a href="../py-modindex.html" title="Python Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="operator.html" title="10.3. operator — Standard operators as functions"
 accesskey="N">next</a> |</li>
 <li class="right" >
 <a href="itertools.html" title="10.1. itertools — Functions creating iterators for efficient looping"
 accesskey="P">previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="https://www.python.org/">Python</a> &#187;</li>
 <li>
 <a href="../index.html">3.6.7 Documentation</a> &#187;
 </li>

<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>
 <li class="nav-item nav-item-2"><a href="functional.html" accesskey="U">10. Functional Programming Modules</a> &#187;</li>
 <li class="right">

<div class="inline-search" style="display: none" role="search">
 <form class="inline-search" action="../search.html" method="get">
 <input placeholder="Quick search" type="text" name="q" />
 <input type="submit" value="Go" />
 <input type="hidden" name="check_keywords" value="yes" />
 <input type="hidden" name="area" value="default" />
 </form>
 </div>
 <script type="text/javascript">$('.inline-search').show(0);</script>
 |
 </li>

</ul>
 </div>

<div class="document">
 <div class="documentwrapper">
 <div class="bodywrapper">
 <div class="body" role="main">
 
 <div class="section" id="module-functools">
<h1>10.2. <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">functools</code></a> — Higher-order functions and operations on callable objects<a class="headerlink" href="#module-functools" title="Permalink to this headline">¶</a></h1>
Source code: <a class="reference external" href="https://github.com/python/cpython/tree/3.6/Lib/functools.py">Lib/functools.py</a>
<hr class="docutils" />
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">functools</code></a> 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 the purposes of this module.
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">functools</code></a> module defines the following functions:
<dl class="function">
<dt id="functools.cmp_to_key">
<code class="descclassname">functools.</code><code class="descname">cmp_to_key</code>(func)<a class="headerlink" href="#functools.cmp_to_key" title="Permalink to this definition">¶</a></dt>
<dd>Transform an old-style comparison function to a <a class="reference internal" href="../glossary.html#term-key-function">key function</a>. Used
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">sorted()</code></a>, <a class="reference internal" href="functions.html#min" title="min"><code class="xref py py-func docutils literal notranslate">min()</code></a>,
<a class="reference internal" href="functions.html#max" title="max"><code class="xref py py-func docutils literal notranslate">max()</code></a>, <a class="reference internal" href="heapq.html#heapq.nlargest" title="heapq.nlargest"><code class="xref py py-func docutils literal notranslate">heapq.nlargest()</code></a>, <a class="reference internal" href="heapq.html#heapq.nsmallest" title="heapq.nsmallest"><code class="xref py py-func docutils literal notranslate">heapq.nsmallest()</code></a>,
<a class="reference internal" href="itertools.html#itertools.groupby" title="itertools.groupby"><code class="xref py py-func docutils literal notranslate">itertools.groupby()</code></a>). This function is primarily used as a transition
tool for programs being converted from Python 2 which supported the use of
comparison functions.
A comparison function is any callable that accept two arguments, compares them,
and returns a negative number for less-than, zero for equality, or a positive
number for greater-than. A key function is a callable that accepts one
argument and returns another value to be used as the sort key.
Example:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>sorted(iterable, key=cmp_to_key(locale.strcoll)) # locale-aware sort order
</pre></div>
</div>
For sorting examples and a brief sorting tutorial, see <a class="reference internal" href="../howto/sorting.html#sortinghowto">Sorting HOW TO</a>.
<div class="versionadded">
New in version 3.2.
</div>
</dd></dl>

<dl class="function">
<dt id="functools.lru_cache">
<code class="descclassname">&#64;</code><code class="descclassname">functools.</code><code class="descname">lru_cache</code>(maxsize=128, typed=False)<a class="headerlink" href="#functools.lru_cache" title="Permalink to this definition">¶</a></dt>
<dd>Decorator to wrap a function with a memoizing callable that saves up to the
maxsize most recent calls. It can save time when an expensive or I/O bound
function is periodically called with the same arguments.
Since a dictionary is used to cache results, the positional and keyword
arguments to the function must be hashable.
If maxsize is set to <code class="docutils literal notranslate">None</code>, the LRU feature is disabled and the cache can
grow without bound. The LRU feature performs best when maxsize is a
power-of-two.
If typed is set to true, function arguments of different types will be
cached separately. For example, <code class="docutils literal notranslate">f(3)</code> and <code class="docutils literal notranslate">f(3.0)</code> will be treated
as distinct calls with distinct results.
To help measure the effectiveness of the cache and tune the maxsize
parameter, the wrapped function is instrumented with a <code class="xref py py-func docutils literal notranslate">cache_info()</code>
function that returns a <a class="reference internal" href="../glossary.html#term-named-tuple">named tuple</a> showing hits, misses,
maxsize and currsize. In a multi-threaded environment, the hits
and misses are approximate.
The decorator also provides a <code class="xref py py-func docutils literal notranslate">cache_clear()</code> function for clearing or
invalidating the cache.
The original underlying function is accessible through the
<code class="xref py py-attr docutils literal notranslate">__wrapped__</code> attribute. This is useful for introspection, for
bypassing the cache, or for rewrapping the function with a different cache.
An <a class="reference external" href="https://en.wikipedia.org/wiki/Cache_algorithms#Examples">LRU (least recently used) cache</a> works
best when the most recent calls are the best predictors of upcoming calls (for
example, the most popular articles on a news server tend to change each day).
The cache’s size limit assures that the cache does not grow without bound on
long-running processes such as web servers.
Example of an LRU cache for static web content:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>@lru_cache(maxsize=32)
def get_pep(num):
 &#39;Retrieve text of a Python Enhancement Proposal&#39;
 resource = &#39;http://www.python.org/dev/peps/pep-%04d/&#39; % num
 try:
 with urllib.request.urlopen(resource) as s:
 return s.read()
 except urllib.error.HTTPError:
 return &#39;Not Found&#39;

&gt;&gt;&gt; for n in 8, 290, 308, 320, 8, 218, 320, 279, 289, 320, 9991:
... pep = get_pep(n)
... print(n, len(pep))

&gt;&gt;&gt; get_pep.cache_info()
CacheInfo(hits=3, misses=8, maxsize=32, currsize=8)
</pre></div>
</div>
Example of efficiently computing
<a class="reference external" href="https://en.wikipedia.org/wiki/Fibonacci_number">Fibonacci numbers</a>
using a cache to implement a
<a class="reference external" href="https://en.wikipedia.org/wiki/Dynamic_programming">dynamic programming</a>
technique:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>@lru_cache(maxsize=None)
def fib(n):
 if n &lt; 2:
 return n
 return fib(n-1) + fib(n-2)

&gt;&gt;&gt; [fib(n) for n in range(16)]
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610]

&gt;&gt;&gt; fib.cache_info()
CacheInfo(hits=28, misses=16, maxsize=None, currsize=16)
</pre></div>
</div>
<div class="versionadded">
New in version 3.2.
</div>
<div class="versionchanged">
Changed in version 3.3: Added the typed option.
</div>
</dd></dl>

<dl class="function">
<dt id="functools.total_ordering">
<code class="descclassname">&#64;</code><code class="descclassname">functools.</code><code class="descname">total_ordering</code><a class="headerlink" href="#functools.total_ordering" title="Permalink to this definition">¶</a></dt>
<dd>Given a class defining one or more rich comparison ordering methods, this
class decorator supplies the rest. This simplifies the effort involved
in specifying all of the possible rich comparison operations:
The class must define one of <a class="reference internal" href="../reference/datamodel.html#object.__lt__" title="object.__lt__"><code class="xref py py-meth docutils literal notranslate">__lt__()</code></a>, <a class="reference internal" href="../reference/datamodel.html#object.__le__" title="object.__le__"><code class="xref py py-meth docutils literal notranslate">__le__()</code></a>,
<a class="reference internal" href="../reference/datamodel.html#object.__gt__" title="object.__gt__"><code class="xref py py-meth docutils literal notranslate">__gt__()</code></a>, or <a class="reference internal" href="../reference/datamodel.html#object.__ge__" title="object.__ge__"><code class="xref py py-meth docutils literal notranslate">__ge__()</code></a>.
In addition, the class should supply an <a class="reference internal" href="../reference/datamodel.html#object.__eq__" title="object.__eq__"><code class="xref py py-meth docutils literal notranslate">__eq__()</code></a> method.
For example:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>@total_ordering
class Student:
 def _is_valid_operand(self, other):
 return (hasattr(other, &quot;lastname&quot;) and
 hasattr(other, &quot;firstname&quot;))
 def __eq__(self, other):
 if not self._is_valid_operand(other):
 return NotImplemented
 return ((self.lastname.lower(), self.firstname.lower()) ==
 (other.lastname.lower(), other.firstname.lower()))
 def __lt__(self, other):
 if not self._is_valid_operand(other):
 return NotImplemented
 return ((self.lastname.lower(), self.firstname.lower()) &lt;
 (other.lastname.lower(), other.firstname.lower()))
</pre></div>
</div>
<div class="admonition note">
Note
While this decorator makes it easy to create well behaved totally
ordered types, it does come at the cost of slower execution and
more complex stack traces for the derived comparison methods. If
performance benchmarking indicates this is a bottleneck for a given
application, implementing all six rich comparison methods instead is
likely to provide an easy speed boost.
</div>
<div class="versionadded">
New in version 3.2.
</div>
<div class="versionchanged">
Changed in version 3.4: Returning NotImplemented from the underlying comparison function for
unrecognised types is now supported.
</div>
</dd></dl>

<dl class="function">
<dt id="functools.partial">
<code class="descclassname">functools.</code><code class="descname">partial</code>(func, *args, **keywords)<a class="headerlink" href="#functools.partial" title="Permalink to this definition">¶</a></dt>
<dd>Return a new <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> object which when called will behave like func
called with the positional arguments args and keyword arguments keywords. If
more arguments are supplied to the call, they are appended to args. If
additional keyword arguments are supplied, they extend and override keywords.
Roughly equivalent to:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>def partial(func, *args, **keywords):
 def newfunc(*fargs, **fkeywords):
 newkeywords = keywords.copy()
 newkeywords.update(fkeywords)
 return func(*args, *fargs, **newkeywords)
 newfunc.func = func
 newfunc.args = args
 newfunc.keywords = keywords
 return newfunc
</pre></div>
</div>
The <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-func docutils literal notranslate">partial()</code></a> is used for partial function application which “freezes”
some portion of a function’s arguments and/or keywords resulting in a new object
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">partial()</code></a> can be used to create
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">int()</code></a> function where the base argument
defaults to two:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; from functools import partial
&gt;&gt;&gt; basetwo = partial(int, base=2)
&gt;&gt;&gt; basetwo.__doc__ = &#39;Convert base 2 string to an int.&#39;
&gt;&gt;&gt; basetwo(&#39;10010&#39;)
18
</pre></div>
</div>
</dd></dl>

<dl class="class">
<dt id="functools.partialmethod">
class <code class="descclassname">functools.</code><code class="descname">partialmethod</code>(func, *args, **keywords)<a class="headerlink" href="#functools.partialmethod" title="Permalink to this definition">¶</a></dt>
<dd>Return a new <a class="reference internal" href="#functools.partialmethod" title="functools.partialmethod"><code class="xref py py-class docutils literal notranslate">partialmethod</code></a> descriptor which behaves
like <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> except that it is designed to be used as a method
definition rather than being directly callable.
func must be a <a class="reference internal" href="../glossary.html#term-descriptor">descriptor</a> or a callable (objects which are both,
like normal functions, are handled as descriptors).
When func is a descriptor (such as a normal Python function,
<a class="reference internal" href="functions.html#classmethod" title="classmethod"><code class="xref py py-func docutils literal notranslate">classmethod()</code></a>, <a class="reference internal" href="functions.html#staticmethod" title="staticmethod"><code class="xref py py-func docutils literal notranslate">staticmethod()</code></a>, <code class="xref py py-func docutils literal notranslate">abstractmethod()</code> or
another instance of <a class="reference internal" href="#functools.partialmethod" title="functools.partialmethod"><code class="xref py py-class docutils literal notranslate">partialmethod</code></a>), calls to <code class="docutils literal notranslate">__get__</code> are
delegated to the underlying descriptor, and an appropriate
<a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> object returned as the result.
When func is a non-descriptor callable, an appropriate bound method is
created dynamically. This behaves like a normal Python function when
used as a method: the self argument will be inserted as the first
positional argument, even before the args and keywords supplied to
the <a class="reference internal" href="#functools.partialmethod" title="functools.partialmethod"><code class="xref py py-class docutils literal notranslate">partialmethod</code></a> constructor.
Example:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; class Cell(object):
... def __init__(self):
... self._alive = False
... @property
... def alive(self):
... return self._alive
... def set_state(self, state):
... self._alive = bool(state)
... set_alive = partialmethod(set_state, True)
... set_dead = partialmethod(set_state, False)
...
&gt;&gt;&gt; c = Cell()
&gt;&gt;&gt; c.alive
False
&gt;&gt;&gt; c.set_alive()
&gt;&gt;&gt; c.alive
True
</pre></div>
</div>
<div class="versionadded">
New in version 3.4.
</div>
</dd></dl>

<dl class="function">
<dt id="functools.reduce">
<code class="descclassname">functools.</code><code class="descname">reduce</code>(function, iterable[, initializer])<a class="headerlink" href="#functools.reduce" title="Permalink to this definition">¶</a></dt>
<dd>Apply function of two arguments cumulatively to the items of sequence, from
left to right, so as to reduce the sequence to a single value. For example,
<code class="docutils literal notranslate">reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])</code> calculates <code class="docutils literal notranslate">((((1+2)+3)+4)+5)</code>.
The left argument, x, is the accumulated value and the right argument, y, is
the update value from the sequence. If the optional initializer is present,
it is placed before the items of the sequence in the calculation, and serves as
a default when the sequence is empty. If initializer is not given and
sequence contains only one item, the first item is returned.
Roughly equivalent to:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>def reduce(function, iterable, initializer=None):
 it = iter(iterable)
 if initializer is None:
 value = next(it)
 else:
 value = initializer
 for element in it:
 value = function(value, element)
 return value
</pre></div>
</div>
</dd></dl>

<dl class="function">
<dt id="functools.singledispatch">
<code class="descclassname">&#64;</code><code class="descclassname">functools.</code><code class="descname">singledispatch</code><a class="headerlink" href="#functools.singledispatch" title="Permalink to this definition">¶</a></dt>
<dd>Transform a function into a <a class="reference internal" href="../glossary.html#term-single-dispatch">single-dispatch</a> <a class="reference internal" href="../glossary.html#term-generic-function">generic function</a>.
To define a generic function, decorate it with the <code class="docutils literal notranslate">&#64;singledispatch</code>
decorator. Note that the dispatch happens on the type of the first argument,
create your function accordingly:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; from functools import singledispatch
&gt;&gt;&gt; @singledispatch
... def fun(arg, verbose=False):
... if verbose:
... print(&quot;Let me just say,&quot;, end=&quot; &quot;)
... print(arg)
</pre></div>
</div>
To add overloaded implementations to the function, use the <code class="xref py py-func docutils literal notranslate">register()</code>
attribute of the generic function. It is a decorator, taking a type
parameter and decorating a function implementing the operation for that
type:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; @fun.register(int)
... def _(arg, verbose=False):
... if verbose:
... print(&quot;Strength in numbers, eh?&quot;, end=&quot; &quot;)
... print(arg)
...
&gt;&gt;&gt; @fun.register(list)
... def _(arg, verbose=False):
... if verbose:
... print(&quot;Enumerate this:&quot;)
... for i, elem in enumerate(arg):
... print(i, elem)
</pre></div>
</div>
To enable registering lambdas and pre-existing functions, the
<code class="xref py py-func docutils literal notranslate">register()</code> attribute can be used in a functional form:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; def nothing(arg, verbose=False):
... print(&quot;Nothing.&quot;)
...
&gt;&gt;&gt; fun.register(type(None), nothing)
</pre></div>
</div>
The <code class="xref py py-func docutils literal notranslate">register()</code> attribute returns the undecorated function which
enables decorator stacking, pickling, as well as creating unit tests for
each variant independently:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; @fun.register(float)
... @fun.register(Decimal)
... def fun_num(arg, verbose=False):
... if verbose:
... print(&quot;Half of your number:&quot;, end=&quot; &quot;)
... print(arg / 2)
...
&gt;&gt;&gt; fun_num is fun
False
</pre></div>
</div>
When called, the generic function dispatches on the type of the first
argument:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; fun(&quot;Hello, world.&quot;)
Hello, world.
&gt;&gt;&gt; fun(&quot;test.&quot;, verbose=True)
Let me just say, test.
&gt;&gt;&gt; fun(42, verbose=True)
Strength in numbers, eh? 42
&gt;&gt;&gt; fun([&#39;spam&#39;, &#39;spam&#39;, &#39;eggs&#39;, &#39;spam&#39;], verbose=True)
Enumerate this:
0 spam
1 spam
2 eggs
3 spam
&gt;&gt;&gt; fun(None)
Nothing.
&gt;&gt;&gt; fun(1.23)
0.615
</pre></div>
</div>
Where there is no registered implementation for a specific type, its
method resolution order is used to find a more generic implementation.
The original function decorated with <code class="docutils literal notranslate">&#64;singledispatch</code> is registered
for the base <code class="docutils literal notranslate">object</code> type, which means it is used if no better
implementation is found.
To check which implementation will the generic function choose for
a given type, use the <code class="docutils literal notranslate">dispatch()</code> attribute:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; fun.dispatch(float)
&lt;function fun_num at 0x1035a2840&gt;
&gt;&gt;&gt; fun.dispatch(dict) # note: default implementation
&lt;function fun at 0x103fe0000&gt;
</pre></div>
</div>
To access all registered implementations, use the read-only <code class="docutils literal notranslate">registry</code>
attribute:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; fun.registry.keys()
dict_keys([&lt;class &#39;NoneType&#39;&gt;, &lt;class &#39;int&#39;&gt;, &lt;class &#39;object&#39;&gt;,
 &lt;class &#39;decimal.Decimal&#39;&gt;, &lt;class &#39;list&#39;&gt;,
 &lt;class &#39;float&#39;&gt;])
&gt;&gt;&gt; fun.registry[float]
&lt;function fun_num at 0x1035a2840&gt;
&gt;&gt;&gt; fun.registry[object]
&lt;function fun at 0x103fe0000&gt;
</pre></div>
</div>
<div class="versionadded">
New in version 3.4.
</div>
</dd></dl>

<dl class="function">
<dt id="functools.update_wrapper">
<code class="descclassname">functools.</code><code class="descname">update_wrapper</code>(wrapper, wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)<a class="headerlink" href="#functools.update_wrapper" title="Permalink to this definition">¶</a></dt>
<dd>Update a wrapper function to look like the wrapped function. The optional
arguments are tuples to specify which attributes of the original function are
assigned directly to the matching attributes on the wrapper function and which
attributes of the wrapper function are updated with the corresponding attributes
from the original function. The default values for these arguments are the
module level constants <code class="docutils literal notranslate">WRAPPER_ASSIGNMENTS</code> (which assigns to the wrapper
function’s <code class="docutils literal notranslate">__module__</code>, <code class="docutils literal notranslate">__name__</code>, <code class="docutils literal notranslate">__qualname__</code>, <code class="docutils literal notranslate">__annotations__</code>
and <code class="docutils literal notranslate">__doc__</code>, the documentation string) and <code class="docutils literal notranslate">WRAPPER_UPDATES</code> (which
updates the wrapper function’s <code class="docutils literal notranslate">__dict__</code>, i.e. the instance dictionary).
To allow access to the original function for introspection and other purposes
(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">lru_cache()</code></a>), this function
automatically adds a <code class="docutils literal notranslate">__wrapped__</code> attribute to the wrapper that refers to
the function being wrapped.
The main intended use for this function is in <a class="reference internal" href="../glossary.html#term-decorator">decorator</a> functions which
wrap the decorated function and return the wrapper. If the wrapper function is
not updated, the metadata of the returned function will reflect the wrapper
definition rather than the original function definition, which is typically less
than helpful.
<a class="reference internal" href="#functools.update_wrapper" title="functools.update_wrapper"><code class="xref py py-func docutils literal notranslate">update_wrapper()</code></a> may be used with callables other than functions. Any
attributes named in assigned or updated that are missing from the object
being wrapped are ignored (i.e. this function will not attempt to set them
on the wrapper function). <a class="reference internal" href="exceptions.html#AttributeError" title="AttributeError"><code class="xref py py-exc docutils literal notranslate">AttributeError</code></a> is still raised if the
wrapper function itself is missing any attributes named in updated.
<div class="versionadded">
New in version 3.2: Automatic addition of the <code class="docutils literal notranslate">__wrapped__</code> attribute.
</div>
<div class="versionadded">
New in version 3.2: Copying of the <code class="docutils literal notranslate">__annotations__</code> attribute by default.
</div>
<div class="versionchanged">
Changed in version 3.2: 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">AttributeError</code></a>.
</div>
<div class="versionchanged">
Changed in version 3.4: The <code class="docutils literal notranslate">__wrapped__</code> attribute now always refers to the wrapped
function, even if that function defined a <code class="docutils literal notranslate">__wrapped__</code> attribute.
(see <a class="reference external" href="https://bugs.python.org/issue17482">bpo-17482</a>)
</div>
</dd></dl>

<dl class="function">
<dt id="functools.wraps">
<code class="descclassname">&#64;</code><code class="descclassname">functools.</code><code class="descname">wraps</code>(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)<a class="headerlink" href="#functools.wraps" title="Permalink to this definition">¶</a></dt>
<dd>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">update_wrapper()</code></a> as a
function decorator when defining a wrapper function. It is equivalent to
<code class="docutils literal notranslate">partial(update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated)</code>.
For example:
<div class="highlight-python3 notranslate"><div class="highlight"><pre>&gt;&gt;&gt; from functools import wraps
&gt;&gt;&gt; def my_decorator(f):
... @wraps(f)
... def wrapper(*args, **kwds):
... print(&#39;Calling decorated function&#39;)
... return f(*args, **kwds)
... return wrapper
...
&gt;&gt;&gt; @my_decorator
... def example():
... &quot;&quot;&quot;Docstring&quot;&quot;&quot;
... print(&#39;Called example function&#39;)
...
&gt;&gt;&gt; example()
Calling decorated function
Called example function
&gt;&gt;&gt; example.__name__
&#39;example&#39;
&gt;&gt;&gt; example.__doc__
&#39;Docstring&#39;
</pre></div>
</div>
Without the use of this decorator factory, the name of the example function
would have been <code class="docutils literal notranslate">'wrapper'</code>, and the docstring of the original <code class="xref py py-func docutils literal notranslate">example()</code>
would have been lost.
</dd></dl>

<div class="section" id="partial-objects">
<h2>10.2.1. <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> Objects<a class="headerlink" href="#partial-objects" title="Permalink to this headline">¶</a></h2>
<a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</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">partial()</code></a>. They
have three read-only attributes:
<dl class="attribute">
<dt id="functools.partial.func">
<code class="descclassname">partial.</code><code class="descname">func</code><a class="headerlink" href="#functools.partial.func" title="Permalink to this definition">¶</a></dt>
<dd>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">partial</code></a> object will be
forwarded to <a class="reference internal" href="#functools.partial.func" title="functools.partial.func"><code class="xref py py-attr docutils literal notranslate">func</code></a> with new arguments and keywords.
</dd></dl>

<dl class="attribute">
<dt id="functools.partial.args">
<code class="descclassname">partial.</code><code class="descname">args</code><a class="headerlink" href="#functools.partial.args" title="Permalink to this definition">¶</a></dt>
<dd>The leftmost positional arguments that will be prepended to the positional
arguments provided to a <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> object call.
</dd></dl>

<dl class="attribute">
<dt id="functools.partial.keywords">
<code class="descclassname">partial.</code><code class="descname">keywords</code><a class="headerlink" href="#functools.partial.keywords" title="Permalink to this definition">¶</a></dt>
<dd>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">partial</code></a> object is
called.
</dd></dl>

<a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> objects are like <code class="xref py py-class docutils literal notranslate">function</code> objects in that they are
callable, weak referencable, and can have attributes. There are some important
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">__name__</code></a> and <code class="xref py py-attr docutils literal notranslate">__doc__</code> attributes
are not created automatically. Also, <a class="reference internal" href="#functools.partial" title="functools.partial"><code class="xref py py-class docutils literal notranslate">partial</code></a> objects defined in
classes behave like static methods and do not transform into bound methods
during instance attribute look-up.
</div>
</div>

</div>
 </div>
 </div>
 <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
 <div class="sphinxsidebarwrapper">
 <h3><a href="../contents.html">Table Of Contents</a></h3>
 <ul>
<li><a class="reference internal" href="#">10.2. <code class="docutils literal notranslate">functools</code> — Higher-order functions and operations on callable objects</a><ul>
<li><a class="reference internal" href="#partial-objects">10.2.1. <code class="docutils literal notranslate">partial</code> Objects</a></li>
</ul>
</li>
</ul>

<h4>Previous topic</h4>
 <a href="itertools.html"
 title="previous chapter">10.1. <code class="docutils literal notranslate">itertools</code> — Functions creating iterators for efficient looping</a>
 <h4>Next topic</h4>
 <a href="operator.html"
 title="next chapter">10.3. <code class="docutils literal notranslate">operator</code> — Standard operators as functions</a>
 <div role="note" aria-label="source link">
 <h3>This Page</h3>
 <ul class="this-page-menu">
 <li><a href="../bugs.html">Report a Bug</a></li>
 <li>
 <a href="https://github.com/python/cpython/blob/3.6/Doc/library/functools.rst"
 rel="nofollow">Show Source
 </a>
 </li>
 </ul>
 </div>
 </div>
 </div>
 <div class="clearer"></div>
 </div> 
 <div class="related" role="navigation" aria-label="related navigation">
 <h3>Navigation</h3>
 <ul>
 <li class="right" style="margin-right: 10px">
 <a href="../genindex.html" title="General Index"
 >index</a></li>
 <li class="right" >
 <a href="../py-modindex.html" title="Python Module Index"
 >modules</a> |</li>
 <li class="right" >
 <a href="operator.html" title="10.3. operator — Standard operators as functions"
 >next</a> |</li>
 <li class="right" >
 <a href="itertools.html" title="10.1. itertools — Functions creating iterators for efficient looping"
 >previous</a> |</li>
 <li><img src="../_static/py.png" alt=""
 style="vertical-align: middle; margin-top: -1px"/></li>
 <li><a href="https://www.python.org/">Python</a> &#187;</li>
 <li>
 <a href="../index.html">3.6.7 Documentation</a> &#187;
 </li>

<li class="nav-item nav-item-1"><a href="index.html" >The Python Standard Library</a> &#187;</li>
 <li class="nav-item nav-item-2"><a href="functional.html" >10. Functional Programming Modules</a> &#187;</li>
 <li class="right">

</ul>
 </div> 
 <div class="footer">
 &copy; <a href="../copyright.html">Copyright</a> 2001-2023, Python Software Foundation.
 
 The Python Software Foundation is a non-profit corporation.
 <a href="https://www.python.org/psf/donations/">Please donate.</a>
 
 Last updated on Dec 18, 2023.
 <a href="../bugs.html">Found a bug</a>?
 
 Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.7.6.
 </div>

</body>
</html>

MR SKB