<!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="Content-Type" content="text/html; charset=utf-8" />
<title>9.2. functools — Higher order functions and operations on callable objects — Python v3.2.2 documentation</title>
<link rel="stylesheet" href="../_static/default.css" type="text/css" />
<link rel="stylesheet" href="../_static/pygments.css" type="text/css" />
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT: '../',
VERSION: '3.2.2',
COLLAPSE_INDEX: false,
FILE_SUFFIX: '.html',
HAS_SOURCE: true
};
</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 v3.2.2 documentation"
href="../_static/opensearch.xml"/>
<link rel="author" title="About these documents" href="../about.html" />
<link rel="copyright" title="Copyright" href="../copyright.html" />
<link rel="top" title="Python v3.2.2 documentation" href="../index.html" />
<link rel="up" title="9. Functional Programming Modules" href="functional.html" />
<link rel="next" title="9.3. operator — Standard operators as functions" href="operator.html" />
<link rel="prev" title="9.1. itertools — Functions creating iterators for efficient looping" href="itertools.html" />
<link rel="shortcut icon" type="image/png" href="../_static/py.png" />
</head>
<body>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
accesskey="I">index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="operator.html" title="9.3. operator — Standard operators as functions"
accesskey="N">next</a> |</li>
<li class="right" >
<a href="itertools.html" title="9.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="../index.html">Python v3.2.2 documentation</a> »</li>
<li><a href="index.html" >The Python Standard Library</a> »</li>
<li><a href="functional.html" accesskey="U">9. Functional Programming Modules</a> »</li>
</ul>
</div>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body">
<div class="section" id="module-functools">
<span id="functools-higher-order-functions-and-operations-on-callable-objects"></span><h1>9.2. <a class="reference internal" href="#module-functools" title="functools: Higher order functions and operations on callable objects."><tt class="xref py py-mod docutils literal"><span class="pre">functools</span></tt></a> — Higher order functions and operations on callable objects<a class="headerlink" href="#module-functools" title="Permalink to this headline">¶</a></h1>
<p><strong>Source code:</strong> <a class="reference external" href="http://hg.python.org/cpython/file/3.2/Lib/functools.py">Lib/functools.py</a></p>
<hr class="docutils" />
<p>The <a class="reference internal" href="#module-functools" title="functools: Higher order functions and operations on callable objects."><tt class="xref py py-mod docutils literal"><span class="pre">functools</span></tt></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.</p>
<p>The <a class="reference internal" href="#module-functools" title="functools: Higher order functions and operations on callable objects."><tt class="xref py py-mod docutils literal"><span class="pre">functools</span></tt></a> module defines the following functions:</p>
<dl class="function">
<dt id="functools.cmp_to_key">
<tt class="descclassname">functools.</tt><tt class="descname">cmp_to_key</tt><big>(</big><em>func</em><big>)</big><a class="headerlink" href="#functools.cmp_to_key" title="Permalink to this definition">¶</a></dt>
<dd><p>Transform an old-style comparison function to a key-function. Used with
tools that accept key functions (such as <a class="reference internal" href="functions.html#sorted" title="sorted"><tt class="xref py py-func docutils literal"><span class="pre">sorted()</span></tt></a>, <a class="reference internal" href="functions.html#min" title="min"><tt class="xref py py-func docutils literal"><span class="pre">min()</span></tt></a>,
<a class="reference internal" href="functions.html#max" title="max"><tt class="xref py py-func docutils literal"><span class="pre">max()</span></tt></a>, <a class="reference internal" href="heapq.html#heapq.nlargest" title="heapq.nlargest"><tt class="xref py py-func docutils literal"><span class="pre">heapq.nlargest()</span></tt></a>, <a class="reference internal" href="heapq.html#heapq.nsmallest" title="heapq.nsmallest"><tt class="xref py py-func docutils literal"><span class="pre">heapq.nsmallest()</span></tt></a>,
<a class="reference internal" href="itertools.html#itertools.groupby" title="itertools.groupby"><tt class="xref py py-func docutils literal"><span class="pre">itertools.groupby()</span></tt></a>). This function is primarily used as a transition
tool for programs being converted from Py2.x which supported the use of
comparison functions.</p>
<p>A compare 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 indicating the position in the desired
collation sequence.</p>
<p>Example:</p>
<div class="highlight-python3"><div class="highlight"><pre><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="c"># locale-aware sort order</span>
</pre></div>
</div>
<p class="versionadded">
<span class="versionmodified">New in version 3.2.</span></p>
</dd></dl>
<dl class="function">
<dt id="functools.lru_cache">
<tt class="descclassname">@</tt><tt class="descclassname">functools.</tt><tt class="descname">lru_cache</tt><big>(</big><em>maxsize=100</em><big>)</big><a class="headerlink" href="#functools.lru_cache" title="Permalink to this definition">¶</a></dt>
<dd><p>Decorator to wrap a function with a memoizing callable that saves up to the
<em>maxsize</em> most recent calls. It can save time when an expensive or I/O bound
function is periodically called with the same arguments.</p>
<p>Since a dictionary is used to cache results, the positional and keyword
arguments to the function must be hashable.</p>
<p>If <em>maxsize</em> is set to None, the LRU feature is disabled and the cache
can grow without bound.</p>
<p>To help measure the effectiveness of the cache and tune the <em>maxsize</em>
parameter, the wrapped function is instrumented with a <tt class="xref py py-func docutils literal"><span class="pre">cache_info()</span></tt>
function that returns a <a class="reference internal" href="../glossary.html#term-named-tuple"><em class="xref std std-term">named tuple</em></a> showing <em>hits</em>, <em>misses</em>,
<em>maxsize</em> and <em>currsize</em>. In a multi-threaded environment, the hits
and misses are approximate.</p>
<p>The decorator also provides a <tt class="xref py py-func docutils literal"><span class="pre">cache_clear()</span></tt> function for clearing or
invalidating the cache.</p>
<p>The original underlying function is accessible through the
<tt class="xref py py-attr docutils literal"><span class="pre">__wrapped__</span></tt> attribute. This is useful for introspection, for
bypassing the cache, or for rewrapping the function with a different cache.</p>
<p>An <a class="reference external" href="http://en.wikipedia.org/wiki/Cache_algorithms#Least_Recently_Used">LRU (least recently used) cache</a> works
best when more recent calls are the best predictors of upcoming calls (for
example, the most popular articles on a news server tend to change daily).
The cache’s size limit assures that the cache does not grow without bound on
long-running processes such as web servers.</p>
<p>Example of an LRU cache for static web content:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="nd">@lru_cache</span><span class="p">(</span><span class="n">maxsize</span><span class="o">=</span><span class="mi">20</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">get_pep</span><span class="p">(</span><span class="n">num</span><span class="p">):</span>
<span class="s">'Retrieve text of a Python Enhancement Proposal'</span>
<span class="n">resource</span> <span class="o">=</span> <span class="s">'http://www.python.org/dev/peps/pep-%04d/'</span> <span class="o">%</span> <span class="n">num</span>
<span class="k">try</span><span class="p">:</span>
<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>
<span class="k">return</span> <span class="n">s</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
<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>
<span class="k">return</span> <span class="s">'Not Found'</span>
<span class="o">>>></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>
<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>
<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>
<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">get_pep</span><span class="o">.</span><span class="n">cache_info</span><span class="p">())</span>
<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">20</span><span class="p">,</span> <span class="n">currsize</span><span class="o">=</span><span class="mi">8</span><span class="p">)</span>
</pre></div>
</div>
<p>Example of efficiently computing
<a class="reference external" href="http://en.wikipedia.org/wiki/Fibonacci_number">Fibonacci numbers</a>
using a cache to implement a
<a class="reference external" href="http://en.wikipedia.org/wiki/Dynamic_programming">dynamic programming</a>
technique:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="nd">@lru_cache</span><span class="p">(</span><span class="n">maxsize</span><span class="o">=</span><span class="k">None</span><span class="p">)</span>
<span class="k">def</span> <span class="nf">fib</span><span class="p">(</span><span class="n">n</span><span class="p">):</span>
<span class="k">if</span> <span class="n">n</span> <span class="o"><</span> <span class="mi">2</span><span class="p">:</span>
<span class="k">return</span> <span class="n">n</span>
<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>
<span class="o">>>></span> <span class="nb">print</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>
<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>
<span class="o">>>></span> <span class="nb">print</span><span class="p">(</span><span class="n">fib</span><span class="o">.</span><span class="n">cache_info</span><span class="p">())</span>
<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="k">None</span><span class="p">,</span> <span class="n">currsize</span><span class="o">=</span><span class="mi">16</span><span class="p">)</span>
</pre></div>
</div>
<p class="versionadded">
<span class="versionmodified">New in version 3.2.</span></p>
</dd></dl>
<dl class="function">
<dt id="functools.total_ordering">
<tt class="descclassname">@</tt><tt class="descclassname">functools.</tt><tt class="descname">total_ordering</tt><a class="headerlink" href="#functools.total_ordering" title="Permalink to this definition">¶</a></dt>
<dd><p>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:</p>
<p>The class must define one of <a class="reference internal" href="../reference/datamodel.html#object.__lt__" title="object.__lt__"><tt class="xref py py-meth docutils literal"><span class="pre">__lt__()</span></tt></a>, <a class="reference internal" href="../reference/datamodel.html#object.__le__" title="object.__le__"><tt class="xref py py-meth docutils literal"><span class="pre">__le__()</span></tt></a>,
<a class="reference internal" href="../reference/datamodel.html#object.__gt__" title="object.__gt__"><tt class="xref py py-meth docutils literal"><span class="pre">__gt__()</span></tt></a>, or <a class="reference internal" href="../reference/datamodel.html#object.__ge__" title="object.__ge__"><tt class="xref py py-meth docutils literal"><span class="pre">__ge__()</span></tt></a>.
In addition, the class should supply an <a class="reference internal" href="../reference/datamodel.html#object.__eq__" title="object.__eq__"><tt class="xref py py-meth docutils literal"><span class="pre">__eq__()</span></tt></a> method.</p>
<p>For example:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="nd">@total_ordering</span>
<span class="k">class</span> <span class="nc">Student</span><span class="p">:</span>
<span class="k">def</span> <span class="nf">__eq__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<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>
<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>
<span class="k">def</span> <span class="nf">__lt__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
<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>
<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>
</pre></div>
</div>
<p class="versionadded">
<span class="versionmodified">New in version 3.2.</span></p>
</dd></dl>
<dl class="function">
<dt id="functools.partial">
<tt class="descclassname">functools.</tt><tt class="descname">partial</tt><big>(</big><em>func</em>, <em>*args</em>, <em>**keywords</em><big>)</big><a class="headerlink" href="#functools.partial" title="Permalink to this definition">¶</a></dt>
<dd><p>Return a new <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> object which when called will behave like <em>func</em>
called with the positional arguments <em>args</em> and keyword arguments <em>keywords</em>. If
more arguments are supplied to the call, they are appended to <em>args</em>. If
additional keyword arguments are supplied, they extend and override <em>keywords</em>.
Roughly equivalent to:</p>
<div class="highlight-python3"><div class="highlight"><pre><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="n">args</span><span class="p">,</span> <span class="o">**</span><span class="n">keywords</span><span class="p">):</span>
<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>
<span class="n">newkeywords</span> <span class="o">=</span> <span class="n">keywords</span><span class="o">.</span><span class="n">copy</span><span class="p">()</span>
<span class="n">newkeywords</span><span class="o">.</span><span class="n">update</span><span class="p">(</span><span class="n">fkeywords</span><span class="p">)</span>
<span class="k">return</span> <span class="n">func</span><span class="p">(</span><span class="o">*</span><span class="p">(</span><span class="n">args</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>
<span class="n">newfunc</span><span class="o">.</span><span class="n">func</span> <span class="o">=</span> <span class="n">func</span>
<span class="n">newfunc</span><span class="o">.</span><span class="n">args</span> <span class="o">=</span> <span class="n">args</span>
<span class="n">newfunc</span><span class="o">.</span><span class="n">keywords</span> <span class="o">=</span> <span class="n">keywords</span>
<span class="k">return</span> <span class="n">newfunc</span>
</pre></div>
</div>
<p>The <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-func docutils literal"><span class="pre">partial()</span></tt></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"><tt class="xref py py-func docutils literal"><span class="pre">partial()</span></tt></a> can be used to create
a callable that behaves like the <a class="reference internal" href="functions.html#int" title="int"><tt class="xref py py-func docutils literal"><span class="pre">int()</span></tt></a> function where the <em>base</em> argument
defaults to two:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">partial</span>
<span class="gp">>>> </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>
<span class="gp">>>> </span><span class="n">basetwo</span><span class="o">.</span><span class="n">__doc__</span> <span class="o">=</span> <span class="s">'Convert base 2 string to an int.'</span>
<span class="gp">>>> </span><span class="n">basetwo</span><span class="p">(</span><span class="s">'10010'</span><span class="p">)</span>
<span class="go">18</span>
</pre></div>
</div>
</dd></dl>
<dl class="function">
<dt id="functools.reduce">
<tt class="descclassname">functools.</tt><tt class="descname">reduce</tt><big>(</big><em>function</em>, <em>iterable</em><span class="optional">[</span>, <em>initializer</em><span class="optional">]</span><big>)</big><a class="headerlink" href="#functools.reduce" title="Permalink to this definition">¶</a></dt>
<dd><p>Apply <em>function</em> of two arguments cumulatively to the items of <em>sequence</em>, from
left to right, so as to reduce the sequence to a single value. For example,
<tt class="docutils literal"><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></tt> calculates <tt class="docutils literal"><span class="pre">((((1+2)+3)+4)+5)</span></tt>.
The left argument, <em>x</em>, is the accumulated value and the right argument, <em>y</em>, is
the update value from the <em>sequence</em>. If the optional <em>initializer</em> 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 <em>initializer</em> is not given and
<em>sequence</em> contains only one item, the first item is returned.</p>
</dd></dl>
<dl class="function">
<dt id="functools.update_wrapper">
<tt class="descclassname">functools.</tt><tt class="descname">update_wrapper</tt><big>(</big><em>wrapper</em>, <em>wrapped</em>, <em>assigned=WRAPPER_ASSIGNMENTS</em>, <em>updated=WRAPPER_UPDATES</em><big>)</big><a class="headerlink" href="#functools.update_wrapper" title="Permalink to this definition">¶</a></dt>
<dd><p>Update a <em>wrapper</em> function to look like the <em>wrapped</em> 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 <em>WRAPPER_ASSIGNMENTS</em> (which assigns to the wrapper
function’s <em>__name__</em>, <em>__module__</em>, <em>__annotations__</em> and <em>__doc__</em>, the
documentation string) and <em>WRAPPER_UPDATES</em> (which updates the wrapper
function’s <em>__dict__</em>, i.e. the instance dictionary).</p>
<p>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"><tt class="xref py py-func docutils literal"><span class="pre">lru_cache()</span></tt></a>), this function
automatically adds a __wrapped__ attribute to the wrapper that refers to
the original function.</p>
<p>The main intended use for this function is in <a class="reference internal" href="../glossary.html#term-decorator"><em class="xref std std-term">decorator</em></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.</p>
<p><a class="reference internal" href="#functools.update_wrapper" title="functools.update_wrapper"><tt class="xref py py-func docutils literal"><span class="pre">update_wrapper()</span></tt></a> may be used with callables other than functions. Any
attributes named in <em>assigned</em> or <em>updated</em> 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"><tt class="xref py py-exc docutils literal"><span class="pre">AttributeError</span></tt></a> is still raised if the
wrapper function itself is missing any attributes named in <em>updated</em>.</p>
<p class="versionadded">
<span class="versionmodified">New in version 3.2: </span>Automatic addition of the <tt class="docutils literal"><span class="pre">__wrapped__</span></tt> attribute.</p>
<p class="versionadded">
<span class="versionmodified">New in version 3.2: </span>Copying of the <tt class="docutils literal"><span class="pre">__annotations__</span></tt> attribute by default.</p>
<p class="versionchanged">
<span class="versionmodified">Changed in version 3.2: </span>Missing attributes no longer trigger an <a class="reference internal" href="exceptions.html#AttributeError" title="AttributeError"><tt class="xref py py-exc docutils literal"><span class="pre">AttributeError</span></tt></a>.</p>
</dd></dl>
<dl class="function">
<dt id="functools.wraps">
<tt class="descclassname">@</tt><tt class="descclassname">functools.</tt><tt class="descname">wraps</tt><big>(</big><em>wrapped</em>, <em>assigned=WRAPPER_ASSIGNMENTS</em>, <em>updated=WRAPPER_UPDATES</em><big>)</big><a class="headerlink" href="#functools.wraps" title="Permalink to this definition">¶</a></dt>
<dd><p>This is a convenience function for invoking <tt class="docutils literal"><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></tt> as a function decorator
when defining a wrapper function. For example:</p>
<div class="highlight-python3"><div class="highlight"><pre><span class="gp">>>> </span><span class="kn">from</span> <span class="nn">functools</span> <span class="k">import</span> <span class="n">wraps</span>
<span class="gp">>>> </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>
<span class="gp">... </span> <span class="nd">@wraps</span><span class="p">(</span><span class="n">f</span><span class="p">)</span>
<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>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s">'Calling decorated function'</span><span class="p">)</span>
<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>
<span class="gp">... </span> <span class="k">return</span> <span class="n">wrapper</span>
<span class="gp">...</span>
<span class="gp">>>> </span><span class="nd">@my_decorator</span>
<span class="gp">... </span><span class="k">def</span> <span class="nf">example</span><span class="p">():</span>
<span class="gp">... </span> <span class="sd">"""Docstring"""</span>
<span class="gp">... </span> <span class="nb">print</span><span class="p">(</span><span class="s">'Called example function'</span><span class="p">)</span>
<span class="gp">...</span>
<span class="gp">>>> </span><span class="n">example</span><span class="p">()</span>
<span class="go">Calling decorated function</span>
<span class="go">Called example function</span>
<span class="gp">>>> </span><span class="n">example</span><span class="o">.</span><span class="n">__name__</span>
<span class="go">'example'</span>
<span class="gp">>>> </span><span class="n">example</span><span class="o">.</span><span class="n">__doc__</span>
<span class="go">'Docstring'</span>
</pre></div>
</div>
<p>Without the use of this decorator factory, the name of the example function
would have been <tt class="docutils literal"><span class="pre">'wrapper'</span></tt>, and the docstring of the original <tt class="xref py py-func docutils literal"><span class="pre">example()</span></tt>
would have been lost.</p>
</dd></dl>
<div class="section" id="partial-objects">
<span id="id1"></span><h2>9.2.1. <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> Objects<a class="headerlink" href="#partial-objects" title="Permalink to this headline">¶</a></h2>
<p><a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> objects are callable objects created by <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-func docutils literal"><span class="pre">partial()</span></tt></a>. They
have three read-only attributes:</p>
<dl class="attribute">
<dt id="functools.partial.func">
<tt class="descclassname">partial.</tt><tt class="descname">func</tt><a class="headerlink" href="#functools.partial.func" title="Permalink to this definition">¶</a></dt>
<dd><p>A callable object or function. Calls to the <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> object will be
forwarded to <a class="reference internal" href="#functools.partial.func" title="functools.partial.func"><tt class="xref py py-attr docutils literal"><span class="pre">func</span></tt></a> with new arguments and keywords.</p>
</dd></dl>
<dl class="attribute">
<dt id="functools.partial.args">
<tt class="descclassname">partial.</tt><tt class="descname">args</tt><a class="headerlink" href="#functools.partial.args" title="Permalink to this definition">¶</a></dt>
<dd><p>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"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> object call.</p>
</dd></dl>
<dl class="attribute">
<dt id="functools.partial.keywords">
<tt class="descclassname">partial.</tt><tt class="descname">keywords</tt><a class="headerlink" href="#functools.partial.keywords" title="Permalink to this definition">¶</a></dt>
<dd><p>The keyword arguments that will be supplied when the <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> object is
called.</p>
</dd></dl>
<p><a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> objects are like <tt class="xref py py-class docutils literal"><span class="pre">function</span></tt> objects in that they are
callable, weak referencable, and can have attributes. There are some important
differences. For instance, the <tt class="xref py py-attr docutils literal"><span class="pre">__name__</span></tt> and <tt class="xref py py-attr docutils literal"><span class="pre">__doc__</span></tt> attributes
are not created automatically. Also, <a class="reference internal" href="#functools.partial" title="functools.partial"><tt class="xref py py-class docutils literal"><span class="pre">partial</span></tt></a> objects defined in
classes behave like static methods and do not transform into bound methods
during instance attribute look-up.</p>
</div>
</div>
</div>
</div>
</div>
<div class="sphinxsidebar">
<div class="sphinxsidebarwrapper">
<h3><a href="../contents.html">Table Of Contents</a></h3>
<ul>
<li><a class="reference internal" href="#">9.2. <tt class="docutils literal"><span class="pre">functools</span></tt> — Higher order functions and operations on callable objects</a><ul>
<li><a class="reference internal" href="#partial-objects">9.2.1. <tt class="docutils literal"><span class="pre">partial</span></tt> Objects</a></li>
</ul>
</li>
</ul>
<h4>Previous topic</h4>
<p class="topless"><a href="itertools.html"
title="previous chapter">9.1. <tt class="docutils literal docutils literal"><span class="pre">itertools</span></tt> — Functions creating iterators for efficient looping</a></p>
<h4>Next topic</h4>
<p class="topless"><a href="operator.html"
title="next chapter">9.3. <tt class="docutils literal docutils literal"><span class="pre">operator</span></tt> — Standard operators as functions</a></p>
<h3>This Page</h3>
<ul class="this-page-menu">
<li><a href="../bugs.html">Report a Bug</a></li>
<li><a href="../_sources/library/functools.txt"
rel="nofollow">Show Source</a></li>
</ul>
<div id="searchbox" style="display: none">
<h3>Quick search</h3>
<form class="search" action="../search.html" method="get">
<input type="text" name="q" size="18" />
<input type="submit" value="Go" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
<p class="searchtip" style="font-size: 90%">
Enter search terms or a module, class or function name.
</p>
</div>
<script type="text/javascript">$('#searchbox').show(0);</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="related">
<h3>Navigation</h3>
<ul>
<li class="right" style="margin-right: 10px">
<a href="../genindex.html" title="General Index"
>index</a></li>
<li class="right" >
<a href="../py-modindex.html" title="Python Module Index"
>modules</a> |</li>
<li class="right" >
<a href="operator.html" title="9.3. operator — Standard operators as functions"
>next</a> |</li>
<li class="right" >
<a href="itertools.html" title="9.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="../index.html">Python v3.2.2 documentation</a> »</li>
<li><a href="index.html" >The Python Standard Library</a> »</li>
<li><a href="functional.html" >9. Functional Programming Modules</a> »</li>
</ul>
</div>
<div class="footer">
© <a href="../copyright.html">Copyright</a> 1990-2011, Python Software Foundation.
<br />
The Python Software Foundation is a non-profit corporation.
<a href="http://www.python.org/psf/donations/">Please donate.</a>
<br />
Last updated on Sep 04, 2011.
<a href="../bugs.html">Found a bug</a>?
<br />
Created using <a href="http://sphinx.pocoo.org/">Sphinx</a> 1.0.7.
</div>
</body>
</html>
distrib
>
Mandriva
>
2010.1
>
x86_64
>
media
>
contrib-backports
>
by-pkgid
>
3ba3bd1608c672ba2129b098a48e9e4d
>
files
>
690
