chapter-3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3 Effective Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Python’s Functions Are First-Class Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Returning nested functions\n",
    "\n",
    "Return behaviours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_minus(which):\n",
    "    def minus_one(num):\n",
    "        return num - 1\n",
    "    def minus_two(num):\n",
    "        return num -2\n",
    "    if which == 1:\n",
    "        return minus_one\n",
    "    else:\n",
    "        return minus_two\n",
    "\n",
    "    \n",
    "fun = get_minus(2)\n",
    "fun(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Higher-order functions\n",
    "\n",
    "Accept behaviours through arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def higher_minus(num, minus_fun):\n",
    "    return minus_fun(num)\n",
    "\n",
    "\n",
    "higher_minus(0, fun)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### (Lexical) Closures\n",
    "\n",
    "Remembers values from enclosing lexical scope to pre-configure behaviours"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def get_minus_closure(num, minus_num):\n",
    "    def minus_one():\n",
    "        return num - minus_num\n",
    "    return minus_one\n",
    "\n",
    "\n",
    "fun = get_minus_closure(2, 3)\n",
    "fun()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making objects callable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class Minus:\n",
    "    def __init__(self, num):\n",
    "        self.num = num\n",
    "    \n",
    "    def __call__(self, other):\n",
    "        return self.num - other\n",
    "    \n",
    "\n",
    "m = Minus(2)\n",
    "m(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Lambdas are single-expression functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- can be anonymous\n",
    "- single expression with implicit return\n",
    "- don't make them too complicated\n",
    "\n",
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3, 1), (2, 2), (1, 3)]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([(1, 3), (2, 2), (3, 1)], key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def make_minus(x):\n",
    "    return lambda y: y - x\n",
    "\n",
    "make_minus(2)(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 The Power of Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorate/wrap an existing callable to add generic functionality, e.g., logging."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Automatic decoration with stacked decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executing wrapper with (3,) and {}.\n",
      "Returned 6\n"
     ]
    }
   ],
   "source": [
    "def logged(fun):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        print(f'Executing {fun.__name__} with {args} and {kwargs}.')\n",
    "        result = fun(*args, **kwargs)\n",
    "        print(f'Returned {result}')\n",
    "    return wrapper\n",
    "            \n",
    "def add_two(fun):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        return fun(*args, **kwargs) + 2\n",
    "    return wrapper\n",
    "\n",
    "@logged\n",
    "@add_two\n",
    "def add_one(num):\n",
    "    return num + 1\n",
    "\n",
    "add_one(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manual decoration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Executing wrapper with (3,) and {}.\n",
      "Returned 6\n"
     ]
    }
   ],
   "source": [
    "def add_one(num):\n",
    "    return num + 1\n",
    "\n",
    "logged(add_two(add_one))(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Best practice: Copying metadata from wrapped functions\n",
    "\n",
    "```python\n",
    "import functools\n",
    "\n",
    "\n",
    "def logged(fun):\n",
    "    #@functools.wraps\n",
    "    def wrapper():\n",
    "        ...\n",
    "``` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 Fun with `*args` and `**kwargs`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2?\n"
     ]
    }
   ],
   "source": [
    "class Adder:\n",
    "    def __init__(self, added, prefix):\n",
    "        self.added = added\n",
    "        self.prefix = prefix\n",
    "        \n",
    "    def add_prefix_print(self, num):\n",
    "        print(str(num + self.added) + self.prefix)\n",
    "        \n",
    "class QuestionAdder(Adder):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        super().__init__(*args, **kwargs)\n",
    "        self.prefix = '?'\n",
    "\n",
    "        \n",
    "QuestionAdder(1, '!').add_prefix_print(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 Function argument unpacking"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add_three(x, y, z):\n",
    "    return x + y + z\n",
    "\n",
    "l = [1, 2, 3]  # could by any iterable \n",
    "add_three(*l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = {\n",
    "    'x': 1,\n",
    "    'y': 2,\n",
    "    'z': 3,\n",
    "}\n",
    "add_three(**d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6 Nothing to return here"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If no return value is specified, a function always returns `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo(x):\n",
    "    if x == 1:\n",
    "        return x\n",
    "\n",
    "type(foo(3))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}