functools_python36_docs.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div class=\"section\" id=\"module-functools\">\n",
    "<span id=\"functools-higher-order-functions-and-operations-on-callable-objects\"></span><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\"><span class=\"pre\">functools</span></code></a> — Higher-order functions and operations on callable objects<a class=\"headerlink\" href=\"#module-functools\" title=\"Permalink to this headline\">¶</a></h1>\n",
    "<p><strong>Source code:</strong> <a class=\"reference external\" href=\"https://github.com/python/cpython/tree/3.6/Lib/functools.py\">Lib/functools.py</a></p>\n",
    "<hr class=\"docutils\"/>\n",
    "<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\"><span class=\"pre\">functools</span></code></a> module is for higher-order functions: functions that act on\n",
    "or return other functions. In general, any callable object can be treated as a\n",
    "function for the purposes of this module.</p>\n",
    "<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\"><span class=\"pre\">functools</span></code></a> module defines the following functions:</p>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.cmp_to_key\">\n",
    "<code class=\"descclassname\">functools.</code><code class=\"descname\">cmp_to_key</code><span class=\"sig-paren\">(</span><em>func</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.cmp_to_key\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<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\n",
    "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\"><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\"><span class=\"pre\">min()</span></code></a>,\n",
    "<a class=\"reference internal\" href=\"functions.html#max\" title=\"max\"><code class=\"xref py py-func docutils literal\"><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\"><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\"><span class=\"pre\">heapq.nsmallest()</span></code></a>,\n",
    "<a class=\"reference internal\" href=\"itertools.html#itertools.groupby\" title=\"itertools.groupby\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">itertools.groupby()</span></code></a>).  This function is primarily used as a transition\n",
    "tool for programs being converted from Python 2 which supported the use of\n",
    "comparison functions.</p>\n",
    "<p>A comparison function is any callable that accept two arguments, compares them,\n",
    "and returns a negative number for less-than, zero for equality, or a positive\n",
    "number for greater-than.  A key function is a callable that accepts one\n",
    "argument and returns another value to be used as the sort key.</p>\n",
    "<p>Example:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(iterable, key=cmp_to_key(locale.strcoll))  # locale-aware sort order\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<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 HOW TO</span></a>.</p>\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.2.</span></p>\n",
    "</div>\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.lru_cache\">\n",
    "<code class=\"descclassname\">@</code><code class=\"descclassname\">functools.</code><code class=\"descname\">lru_cache</code><span class=\"sig-paren\">(</span><em>maxsize=128</em>, <em>typed=False</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.lru_cache\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<dd><p>Decorator to wrap a function with a memoizing callable that saves up to the\n",
    "<em>maxsize</em> most recent calls.  It can save time when an expensive or I/O bound\n",
    "function is periodically called with the same arguments.</p>\n",
    "<p>Since a dictionary is used to cache results, the positional and keyword\n",
    "arguments to the function must be hashable.</p>\n",
    "<p>If <em>maxsize</em> is set to <code class=\"docutils literal\"><span class=\"pre\">None</span></code>, the LRU feature is disabled and the cache can\n",
    "grow without bound.  The LRU feature performs best when <em>maxsize</em> is a\n",
    "power-of-two.</p>\n",
    "<p>If <em>typed</em> is set to true, function arguments of different types will be\n",
    "cached separately.  For example, <code class=\"docutils literal\"><span class=\"pre\">f(3)</span></code> and <code class=\"docutils literal\"><span class=\"pre\">f(3.0)</span></code> will be treated\n",
    "as distinct calls with distinct results.</p>\n",
    "<p>To help measure the effectiveness of the cache and tune the <em>maxsize</em>\n",
    "parameter, the wrapped function is instrumented with a <code class=\"xref py py-func docutils literal\"><span class=\"pre\">cache_info()</span></code>\n",
    "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>,\n",
    "<em>maxsize</em> and <em>currsize</em>.  In a multi-threaded environment, the hits\n",
    "and misses are approximate.</p>\n",
    "<p>The decorator also provides a <code class=\"xref py py-func docutils literal\"><span class=\"pre\">cache_clear()</span></code> function for clearing or\n",
    "invalidating the cache.</p>\n",
    "<p>The original underlying function is accessible through the\n",
    "<code class=\"xref py py-attr docutils literal\"><span class=\"pre\">__wrapped__</span></code> attribute.  This is useful for introspection, for\n",
    "bypassing the cache, or for rewrapping the function with a different cache.</p>\n",
    "<p>An <a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/Cache_algorithms#Examples\">LRU (least recently used) cache</a> works\n",
    "best when the most recent calls are the best predictors of upcoming calls (for\n",
    "example, the most popular articles on a news server tend to change each day).\n",
    "The cache’s size limit assures that the cache does not grow without bound on\n",
    "long-running processes such as web servers.</p>\n",
    "<p>Example of an LRU cache for static web content:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for n in 8, 290, 308, 320, 8, 218, 320, 279, 289, 320, 9991:\n",
    "    pep = get_pep(n)\n",
    "    print(n, len(pep))\n",
    "get_pep.cache_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>Example of efficiently computing\n",
    "<a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/Fibonacci_number\">Fibonacci numbers</a>\n",
    "using a cache to implement a\n",
    "<a class=\"reference external\" href=\"https://en.wikipedia.org/wiki/Dynamic_programming\">dynamic programming</a>\n",
    "technique:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[fib(n) for n in range(16)]\n",
    "fib.cache_info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.2.</span></p>\n",
    "</div>\n",
    "<div class=\"versionchanged\">\n",
    "<p><span class=\"versionmodified\">Changed in version 3.3: </span>Added the <em>typed</em> option.</p>\n",
    "</div>\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.total_ordering\">\n",
    "<code class=\"descclassname\">@</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>\n",
    "<dd><p>Given a class defining one or more rich comparison ordering methods, this\n",
    "class decorator supplies the rest.  This simplifies the effort involved\n",
    "in specifying all of the possible rich comparison operations:</p>\n",
    "<p>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\"><span class=\"pre\">__lt__()</span></code></a>, <a class=\"reference internal\" href=\"../reference/datamodel.html#object.__le__\" title=\"object.__le__\"><code class=\"xref py py-meth docutils literal\"><span class=\"pre\">__le__()</span></code></a>,\n",
    "<a class=\"reference internal\" href=\"../reference/datamodel.html#object.__gt__\" title=\"object.__gt__\"><code class=\"xref py py-meth docutils literal\"><span class=\"pre\">__gt__()</span></code></a>, or <a class=\"reference internal\" href=\"../reference/datamodel.html#object.__ge__\" title=\"object.__ge__\"><code class=\"xref py py-meth docutils literal\"><span class=\"pre\">__ge__()</span></code></a>.\n",
    "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\"><span class=\"pre\">__eq__()</span></code></a> method.</p>\n",
    "<p>For example:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@total_ordering\n",
    "class Student:\n",
    "    def _is_valid_operand(self, other):\n",
    "        return (hasattr(other, \"lastname\") and\n",
    "                hasattr(other, \"firstname\"))\n",
    "    def __eq__(self, other):\n",
    "        if not self._is_valid_operand(other):\n",
    "            return NotImplemented\n",
    "        return ((self.lastname.lower(), self.firstname.lower()) ==\n",
    "                (other.lastname.lower(), other.firstname.lower()))\n",
    "    def __lt__(self, other):\n",
    "        if not self._is_valid_operand(other):\n",
    "            return NotImplemented\n",
    "        return ((self.lastname.lower(), self.firstname.lower()) <\n",
    "                (other.lastname.lower(), other.firstname.lower()))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"admonition note\">\n",
    "<p class=\"first admonition-title\">Note</p>\n",
    "<p class=\"last\">While this decorator makes it easy to create well behaved totally\n",
    "ordered types, it <em>does</em> come at the cost of slower execution and\n",
    "more complex stack traces for the derived comparison methods. If\n",
    "performance benchmarking indicates this is a bottleneck for a given\n",
    "application, implementing all six rich comparison methods instead is\n",
    "likely to provide an easy speed boost.</p>\n",
    "</div>\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.2.</span></p>\n",
    "</div>\n",
    "<div class=\"versionchanged\">\n",
    "<p><span class=\"versionmodified\">Changed in version 3.4: </span>Returning NotImplemented from the underlying comparison function for\n",
    "unrecognised types is now supported.</p>\n",
    "</div>\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.partial\">\n",
    "<code class=\"descclassname\">functools.</code><code class=\"descname\">partial</code><span class=\"sig-paren\">(</span><em>func</em>, <em>*args</em>, <em>**keywords</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.partial\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<dd><p>Return a new <a class=\"reference internal\" href=\"#functools.partial\" title=\"functools.partial\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">partial</span></code></a> object which when called will behave like <em>func</em>\n",
    "called with the positional arguments <em>args</em> and keyword arguments <em>keywords</em>. If\n",
    "more arguments are supplied to the call, they are appended to <em>args</em>. If\n",
    "additional keyword arguments are supplied, they extend and override <em>keywords</em>.\n",
    "Roughly equivalent to:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def partial(func, *args, **keywords):\n",
    "    def newfunc(*fargs, **fkeywords):\n",
    "        newkeywords = keywords.copy()\n",
    "        newkeywords.update(fkeywords)\n",
    "        return func(*args, *fargs, **newkeywords)\n",
    "    newfunc.func = func\n",
    "    newfunc.args = args\n",
    "    newfunc.keywords = keywords\n",
    "    return newfunc\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>The <a class=\"reference internal\" href=\"#functools.partial\" title=\"functools.partial\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">partial()</span></code></a> is used for partial function application which “freezes”\n",
    "some portion of a function’s arguments and/or keywords resulting in a new object\n",
    "with a simplified signature.  For example, <a class=\"reference internal\" href=\"#functools.partial\" title=\"functools.partial\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">partial()</span></code></a> can be used to create\n",
    "a callable that behaves like the <a class=\"reference internal\" href=\"functions.html#int\" title=\"int\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">int()</span></code></a> function where the <em>base</em> argument\n",
    "defaults to two:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "basetwo = partial(int, base=2)\n",
    "basetwo.__doc__ = 'Convert base 2 string to an int.'\n",
    "basetwo('10010')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "</dd></dl>\n",
    "<dl class=\"class\">\n",
    "<dt id=\"functools.partialmethod\">\n",
    "<em class=\"property\">class </em><code class=\"descclassname\">functools.</code><code class=\"descname\">partialmethod</code><span class=\"sig-paren\">(</span><em>func</em>, <em>*args</em>, <em>**keywords</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.partialmethod\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<dd><p>Return a new <a class=\"reference internal\" href=\"#functools.partialmethod\" title=\"functools.partialmethod\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">partialmethod</span></code></a> descriptor which behaves\n",
    "like <a class=\"reference internal\" href=\"#functools.partial\" title=\"functools.partial\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">partial</span></code></a> except that it is designed to be used as a method\n",
    "definition rather than being directly callable.</p>\n",
    "<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,\n",
    "like normal functions, are handled as descriptors).</p>\n",
    "<p>When <em>func</em> is a descriptor (such as a normal Python function,\n",
    "<a class=\"reference internal\" href=\"functions.html#classmethod\" title=\"classmethod\"><code class=\"xref py py-func docutils literal\"><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\"><span class=\"pre\">staticmethod()</span></code></a>, <code class=\"xref py py-func docutils literal\"><span class=\"pre\">abstractmethod()</span></code> or\n",
    "another instance of <a class=\"reference internal\" href=\"#functools.partialmethod\" title=\"functools.partialmethod\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">partialmethod</span></code></a>), calls to <code class=\"docutils literal\"><span class=\"pre\">__get__</span></code> are\n",
    "delegated to the underlying descriptor, and an appropriate\n",
    "<a class=\"reference internal\" href=\"#functools.partial\" title=\"functools.partial\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">partial</span></code></a> object returned as the result.</p>\n",
    "<p>When <em>func</em> is a non-descriptor callable, an appropriate bound method is\n",
    "created dynamically. This behaves like a normal Python function when\n",
    "used as a method: the <em>self</em> argument will be inserted as the first\n",
    "positional argument, even before the <em>args</em> and <em>keywords</em> supplied to\n",
    "the <a class=\"reference internal\" href=\"#functools.partialmethod\" title=\"functools.partialmethod\"><code class=\"xref py py-class docutils literal\"><span class=\"pre\">partialmethod</span></code></a> constructor.</p>\n",
    "<p>Example:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cell(object):\n",
    "    def __init__(self):\n",
    "        self._alive = False\n",
    "    @property\n",
    "    def alive(self):\n",
    "        return self._alive\n",
    "    def set_state(self, state):\n",
    "        self._alive = bool(state)\n",
    "    set_alive = partialmethod(set_state, True)\n",
    "    set_dead = partialmethod(set_state, False)\n",
    "c = Cell()\n",
    "c.alive\n",
    "c.set_alive()\n",
    "c.alive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.4.</span></p>\n",
    "</div>\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.reduce\">\n",
    "<code class=\"descclassname\">functools.</code><code class=\"descname\">reduce</code><span class=\"sig-paren\">(</span><em>function</em>, <em>iterable</em><span class=\"optional\">[</span>, <em>initializer</em><span class=\"optional\">]</span><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.reduce\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<dd><p>Apply <em>function</em> of two arguments cumulatively to the items of <em>sequence</em>, from\n",
    "left to right, so as to reduce the sequence to a single value.  For example,\n",
    "<code 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></code> calculates <code class=\"docutils literal\"><span class=\"pre\">((((1+2)+3)+4)+5)</span></code>.\n",
    "The left argument, <em>x</em>, is the accumulated value and the right argument, <em>y</em>, is\n",
    "the update value from the <em>sequence</em>.  If the optional <em>initializer</em> is present,\n",
    "it is placed before the items of the sequence in the calculation, and serves as\n",
    "a default when the sequence is empty.  If <em>initializer</em> is not given and\n",
    "<em>sequence</em> contains only one item, the first item is returned.</p>\n",
    "<p>Roughly equivalent to:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reduce(function, iterable, initializer=None):\n",
    "    it = iter(iterable)\n",
    "    if initializer is None:\n",
    "        value = next(it)\n",
    "    else:\n",
    "        value = initializer\n",
    "    for element in it:\n",
    "        value = function(value, element)\n",
    "    return value\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.singledispatch\">\n",
    "<code class=\"descclassname\">@</code><code class=\"descclassname\">functools.</code><code class=\"descname\">singledispatch</code><span class=\"sig-paren\">(</span><em>default</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.singledispatch\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<dd><p>Transforms 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>\n",
    "<p>To define a generic function, decorate it with the <code class=\"docutils literal\"><span class=\"pre\">@singledispatch</span></code>\n",
    "decorator. Note that the dispatch happens on the type of the first argument,\n",
    "create your function accordingly:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import singledispatch\n",
    "@singledispatch\n",
    "def fun(arg, verbose=False):\n",
    "    if verbose:\n",
    "        print(\"Let me just say,\", end=\" \")\n",
    "    print(arg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>To add overloaded implementations to the function, use the <code class=\"xref py py-func docutils literal\"><span class=\"pre\">register()</span></code>\n",
    "attribute of the generic function.  It is a decorator, taking a type\n",
    "parameter and decorating a function implementing the operation for that\n",
    "type:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@fun.register(int)\n",
    "def _(arg, verbose=False):\n",
    "    if verbose:\n",
    "        print(\"Strength in numbers, eh?\", end=\" \")\n",
    "    print(arg)\n",
    "@fun.register(list)\n",
    "def _(arg, verbose=False):\n",
    "    if verbose:\n",
    "        print(\"Enumerate this:\")\n",
    "    for i, elem in enumerate(arg):\n",
    "        print(i, elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>To enable registering lambdas and pre-existing functions, the\n",
    "<code class=\"xref py py-func docutils literal\"><span class=\"pre\">register()</span></code> attribute can be used in a functional form:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def nothing(arg, verbose=False):\n",
    "    print(\"Nothing.\")\n",
    "fun.register(type(None), nothing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>The <code class=\"xref py py-func docutils literal\"><span class=\"pre\">register()</span></code> attribute returns the undecorated function which\n",
    "enables decorator stacking, pickling, as well as creating unit tests for\n",
    "each variant independently:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@fun.register(float)\n",
    "@fun.register(Decimal)\n",
    "def fun_num(arg, verbose=False):\n",
    "    if verbose:\n",
    "        print(\"Half of your number:\", end=\" \")\n",
    "    print(arg / 2)\n",
    "fun_num is fun"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>When called, the generic function dispatches on the type of the first\n",
    "argument:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun(\"Hello, world.\")\n",
    "fun(\"test.\", verbose=True)\n",
    "fun(42, verbose=True)\n",
    "fun(['spam', 'spam', 'eggs', 'spam'], verbose=True)\n",
    "fun(None)\n",
    "fun(1.23)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>Where there is no registered implementation for a specific type, its\n",
    "method resolution order is used to find a more generic implementation.\n",
    "The original function decorated with <code class=\"docutils literal\"><span class=\"pre\">@singledispatch</span></code> is registered\n",
    "for the base <code class=\"docutils literal\"><span class=\"pre\">object</span></code> type, which means it is used if no better\n",
    "implementation is found.</p>\n",
    "<p>To check which implementation will the generic function choose for\n",
    "a given type, use the <code class=\"docutils literal\"><span class=\"pre\">dispatch()</span></code> attribute:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun.dispatch(float)\n",
    "fun.dispatch(dict)    # note: default implementation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<p>To access all registered implementations, use the read-only <code class=\"docutils literal\"><span class=\"pre\">registry</span></code>\n",
    "attribute:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun.registry.keys()\n",
    "fun.registry[float]\n",
    "fun.registry[object]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.4.</span></p>\n",
    "</div>\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.update_wrapper\">\n",
    "<code class=\"descclassname\">functools.</code><code class=\"descname\">update_wrapper</code><span class=\"sig-paren\">(</span><em>wrapper</em>, <em>wrapped</em>, <em>assigned=WRAPPER_ASSIGNMENTS</em>, <em>updated=WRAPPER_UPDATES</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.update_wrapper\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<dd><p>Update a <em>wrapper</em> function to look like the <em>wrapped</em> function. The optional\n",
    "arguments are tuples to specify which attributes of the original function are\n",
    "assigned directly to the matching attributes on the wrapper function and which\n",
    "attributes of the wrapper function are updated with the corresponding attributes\n",
    "from the original function. The default values for these arguments are the\n",
    "module level constants <code class=\"docutils literal\"><span class=\"pre\">WRAPPER_ASSIGNMENTS</span></code> (which assigns to the wrapper\n",
    "function’s <code class=\"docutils literal\"><span class=\"pre\">__module__</span></code>, <code class=\"docutils literal\"><span class=\"pre\">__name__</span></code>, <code class=\"docutils literal\"><span class=\"pre\">__qualname__</span></code>, <code class=\"docutils literal\"><span class=\"pre\">__annotations__</span></code>\n",
    "and <code class=\"docutils literal\"><span class=\"pre\">__doc__</span></code>, the documentation string) and <code class=\"docutils literal\"><span class=\"pre\">WRAPPER_UPDATES</span></code> (which\n",
    "updates the wrapper function’s <code class=\"docutils literal\"><span class=\"pre\">__dict__</span></code>, i.e. the instance dictionary).</p>\n",
    "<p>To allow access to the original function for introspection and other purposes\n",
    "(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\"><span class=\"pre\">lru_cache()</span></code></a>), this function\n",
    "automatically adds a <code class=\"docutils literal\"><span class=\"pre\">__wrapped__</span></code> attribute to the wrapper that refers to\n",
    "the function being wrapped.</p>\n",
    "<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\n",
    "wrap the decorated function and return the wrapper. If the wrapper function is\n",
    "not updated, the metadata of the returned function will reflect the wrapper\n",
    "definition rather than the original function definition, which is typically less\n",
    "than helpful.</p>\n",
    "<p><a class=\"reference internal\" href=\"#functools.update_wrapper\" title=\"functools.update_wrapper\"><code class=\"xref py py-func docutils literal\"><span class=\"pre\">update_wrapper()</span></code></a> may be used with callables other than functions. Any\n",
    "attributes named in <em>assigned</em> or <em>updated</em> that are missing from the object\n",
    "being wrapped are ignored (i.e. this function will not attempt to set them\n",
    "on the wrapper function). <a class=\"reference internal\" href=\"exceptions.html#AttributeError\" title=\"AttributeError\"><code class=\"xref py py-exc docutils literal\"><span class=\"pre\">AttributeError</span></code></a> is still raised if the\n",
    "wrapper function itself is missing any attributes named in <em>updated</em>.</p>\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.2: </span>Automatic addition of the <code class=\"docutils literal\"><span class=\"pre\">__wrapped__</span></code> attribute.</p>\n",
    "</div>\n",
    "<div class=\"versionadded\">\n",
    "<p><span class=\"versionmodified\">New in version 3.2: </span>Copying of the <code class=\"docutils literal\"><span class=\"pre\">__annotations__</span></code> attribute by default.</p>\n",
    "</div>\n",
    "<div class=\"versionchanged\">\n",
    "<p><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\"><code class=\"xref py py-exc docutils literal\"><span class=\"pre\">AttributeError</span></code></a>.</p>\n",
    "</div>\n",
    "<div class=\"versionchanged\">\n",
    "<p><span class=\"versionmodified\">Changed in version 3.4: </span>The <code class=\"docutils literal\"><span class=\"pre\">__wrapped__</span></code> attribute now always refers to the wrapped\n",
    "function, even if that function defined a <code class=\"docutils literal\"><span class=\"pre\">__wrapped__</span></code> attribute.\n",
    "(see <a class=\"reference external\" href=\"https://bugs.python.org/issue17482\">bpo-17482</a>)</p>\n",
    "</div>\n",
    "</dd></dl>\n",
    "<dl class=\"function\">\n",
    "<dt id=\"functools.wraps\">\n",
    "<code class=\"descclassname\">@</code><code class=\"descclassname\">functools.</code><code class=\"descname\">wraps</code><span class=\"sig-paren\">(</span><em>wrapped</em>, <em>assigned=WRAPPER_ASSIGNMENTS</em>, <em>updated=WRAPPER_UPDATES</em><span class=\"sig-paren\">)</span><a class=\"headerlink\" href=\"#functools.wraps\" title=\"Permalink to this definition\">¶</a></dt>\n",
    "<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\"><span class=\"pre\">update_wrapper()</span></code></a> as a\n",
    "function decorator when defining a wrapper function.  It is equivalent to\n",
    "<code 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></code>.\n",
    "For example:</p>\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import wraps\n",
    "def my_decorator(f):\n",
    "    @wraps(f)\n",
    "    def wrapper(*args, **kwds):\n",
    "        print('Calling decorated function')\n",
    "        return f(*args, **kwds)\n",
    "    return wrapper\n",
    "@my_decorator\n",
    "def example():\n",
    "    \"\"\"Docstring\"\"\"\n",
    "    print('Called example function')\n",
    "example()\n",
    "example.__name__\n",
    "example.__doc__"
   ]
  }
 ],
 "metadata": {},
 "nbformat": 4,
 "nbformat_minor": 2
}