Chapter3_Effective_functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "informational-employer",
   "metadata": {},
   "source": [
    "# Chapter 3 - Effective Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "criminal-founder",
   "metadata": {},
   "source": [
    "## 3.1 Python's Functions are First-Class"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fifteen-suspect",
   "metadata": {},
   "source": [
    "* **Everything in Python is an object**, including functions. You can\n",
    "assign them to variables, store them in data structures, and pass\n",
    "or return them to and from other functions (first-class functions.)\n",
    "* First-class functions allow you to abstract away and pass\n",
    "around behavior in your programs.\n",
    "* Functions can be nested and they can capture and carry some\n",
    "of the parent function’s state with them. Functions that do this\n",
    "are called closures.\n",
    "* **Objects can be made callable**. In many cases this allows you to\n",
    "treat them like functions.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "nearby-writing",
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for use in this section\n",
    "def yell(text):\n",
    "    return text.upper()+ '!'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sixth-maintenance",
   "metadata": {},
   "source": [
    "### functions and references"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "governmental-viewer",
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can make a reference that copies the function object\n",
    "bark = yell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "russian-poster",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'WOOF!'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bark('woof')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "immediate-platform",
   "metadata": {},
   "outputs": [],
   "source": [
    "del yell"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "technical-recall",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'yell' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-5-43e68f5b93d9>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0myell\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'hello'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'yell' is not defined"
     ]
    }
   ],
   "source": [
    "yell('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "mental-czech",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HEY!'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bark('hey')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "modular-silly",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'yell'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# string identifier at creation time\n",
    "bark.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "scheduled-rating",
   "metadata": {},
   "source": [
    "### functions can be stored in data structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "logical-culture",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<function __main__.yell(text)>,\n",
       " <method 'lower' of 'str' objects>,\n",
       " <method 'capitalize' of 'str' objects>]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcs = [bark, str.lower, str.capitalize]\n",
    "\n",
    "funcs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "rubber-bulgaria",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function yell at 0x0000017404D66280> HEY THERE!\n",
      "<method 'lower' of 'str' objects> hey there\n",
      "<method 'capitalize' of 'str' objects> Hey there\n"
     ]
    }
   ],
   "source": [
    "# accessing functions inside data structures\n",
    "for f in funcs:\n",
    "    print(f, f('hey there'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "rolled-senator",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'YO!'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "funcs[0]('yo')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "molecular-recovery",
   "metadata": {},
   "source": [
    "### functions can be passed to other functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "radical-bulletin",
   "metadata": {},
   "source": [
    "* Functions that accept other functions as arguments are also called higher-order functions\n",
    "* the ```map``` function is an example of a higher order function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "southwest-subject",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['HELLO!', 'HEY!', 'HI!']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(bark,['hello', 'hey','hi']))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "artistic-metadata",
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(func):\n",
    "    greeting = func('Hi, I am a Python program')\n",
    "    print(greeting)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "herbal-record",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HI, I AM A PYTHON PROGRAM!\n"
     ]
    }
   ],
   "source": [
    "# pass bark to greet function\n",
    "greet(bark)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "spanish-aviation",
   "metadata": {},
   "outputs": [],
   "source": [
    "def whisper(text):\n",
    "    return text.lower() + '...'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "medieval-rochester",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi, i am a python program...\n"
     ]
    }
   ],
   "source": [
    "greet(whisper)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "equivalent-heather",
   "metadata": {},
   "source": [
    "### functions can be nested\n",
    "\n",
    "* Notice that ```whisper``` does not exist outside ```speak```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "desirable-provincial",
   "metadata": {},
   "outputs": [],
   "source": [
    "def speak(text):\n",
    "    def whisper(t):\n",
    "        return t.lower()+'...'\n",
    "    return whisper(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "framed-dining",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello, world...'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speak('Hello, World')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "chicken-reporter",
   "metadata": {},
   "source": [
    "### functions can return behaviours!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "focal-livestock",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_speak_func(volume):\n",
    "    def whisper(text):\n",
    "        return text.lower() + '...'\n",
    "    def yell(text):\n",
    "        return text.upper() + '!'\n",
    "    \n",
    "    if volume > 0.5:\n",
    "        return yell\n",
    "    else:\n",
    "        return whisper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "revolutionary-fitness",
   "metadata": {},
   "outputs": [],
   "source": [
    "speak_func = get_speak_func(0.7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "trying-navigation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO!'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "speak_func('Hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "civic-livestock",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello...'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_speak_func(0.2)('Hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "particular-quest",
   "metadata": {},
   "source": [
    "### functions can capture local state"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "distributed-chancellor",
   "metadata": {},
   "source": [
    "*  Inner functions can capture and carry some of the parent function's state\n",
    "* This means functions can pre-configure returned behaviours"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fuzzy-despite",
   "metadata": {},
   "source": [
    "### lexical closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "missing-lemon",
   "metadata": {},
   "outputs": [],
   "source": [
    "# notice the inner functions don't have any inputs\n",
    "# they look in the parents scope for the variables\n",
    "def get_speak_func(text, volume):\n",
    "    def whisper():\n",
    "        return text.lower() + '...'\n",
    "    def yell():\n",
    "        return text.upper() + '!'\n",
    "    if volume > 0.5:\n",
    "        return yell\n",
    "    else:\n",
    "        return whisper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "universal-friendship",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO WORLD!'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_speak_func('Hello world', 0.7)()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "commercial-breach",
   "metadata": {},
   "source": [
    "#### preconfigured behaviour "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "handed-parker",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_adder(n):\n",
    "    def add(x):\n",
    "        # nested function captures the\n",
    "        # state of the parent variable n         \n",
    "        return x + n\n",
    "    return add"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "naughty-cisco",
   "metadata": {},
   "outputs": [],
   "source": [
    "plus_3 = make_adder(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "designed-report",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plus_3(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "first-toddler",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plus_5 = make_adder(5)\n",
    "plus_5(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intimate-gambling",
   "metadata": {},
   "source": [
    "### Objects can behave like functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dried-catalyst",
   "metadata": {},
   "source": [
    "* All functions are objects in Python\n",
    "* The reverse is not true!\n",
    "* However, __objects can be made callable__ which allows you to treat them like functions in many cases\n",
    "\n",
    "We do this through the use of the ```__call__``` dunder method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "finnish-photograph",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# define a class Adder and use the __call__ dunder to make it callable\n",
    "# this is a good illustration were lexical closure is more efficient\n",
    "\n",
    "class Adder:\n",
    "    def __init__(self,n):\n",
    "        self.n = n\n",
    "    \n",
    "    # the dunder method allows us to call this object\n",
    "    def __call__(self,x):\n",
    "        return self.n + x\n",
    "    \n",
    "# instantiate the class Adder\n",
    "plus_3 = Adder(3)\n",
    "# call the object like a function\n",
    "plus_3(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "blessed-flexibility",
   "metadata": {},
   "source": [
    "* Note, not all objects will be callable, so we can check with the ```callable``` check"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "greatest-wednesday",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(plus_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "engaging-scanner",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable('string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "faced-colors",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "callable(bark)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numerical-parade",
   "metadata": {},
   "source": [
    "___\n",
    "## 3.2 Lambdas are Single-Expression Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "recreational-astronomy",
   "metadata": {},
   "source": [
    "* Lambda functions are **single-expression functions** that are not\n",
    "necessarily bound to a name (anonymous).\n",
    "* Lambda functions can’t use regular Python statements and **always include an implicit return statement**.\n",
    "* Always ask yourself: Would using a regular (named) function\n",
    "or a list comprehension offer more clarity?\n",
    "* Saving a few keystrokes won’t matter in the long run, but your colleagues (and your future self) will **appreciate clean and readable code\n",
    "more than terse wizardry.**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "ongoing-gasoline",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add = lambda x, y: x + y\n",
    "add(5,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "correct-budapest",
   "metadata": {},
   "source": [
    "* this is equivalent to the more verbose..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "national-moisture",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add(x,y):\n",
    "    return x + y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "historic-weight",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(5,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fourth-packing",
   "metadata": {},
   "source": [
    "### the power of lambda functions - function expressions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "registered-maker",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# function expressions - inline function definitions\n",
    "\n",
    "(lambda x, y: x + y)(5,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "electrical-officer",
   "metadata": {},
   "source": [
    "### lambdas you can use"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "exposed-runner",
   "metadata": {},
   "source": [
    "#### sorting keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "exotic-action",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(4, 'a'), (2, 'b'), (3, 'c'), (1, 'd')]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuples = [(1, 'd'), (2, 'b'), (4, 'a'), (3, 'c')]\n",
    "sorted(tuples, key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "according-finder",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, -1, 1, -2, 2, -3, 3, -4, 4, -5, 5]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(range(-5, 6), key=lambda x: x * x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "rotary-tuning",
   "metadata": {},
   "source": [
    "#### they work as lexical closures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "japanese-twelve",
   "metadata": {},
   "outputs": [],
   "source": [
    "def make_adder(n):\n",
    "    # the state of the parent function (n) is captured by the lambda function     \n",
    "    return lambda x: x + n \n",
    "\n",
    "plus_3 = make_adder(3)\n",
    "plus_5 = make_adder(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "tribal-secretary",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plus_3(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "casual-capture",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "plus_5(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decreased-choice",
   "metadata": {},
   "source": [
    "### Take care writing lambdas functions because there are some pitfalls"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "crucial-merchant",
   "metadata": {},
   "source": [
    "* Ask yourself does this lambda function **make your code maintainable and reusable**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "bridal-maldives",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Wroom!\n",
      "Boom!\n"
     ]
    }
   ],
   "source": [
    "# harmful\n",
    "# this will be confusing as a way to write class methods\n",
    "class Car:\n",
    "    rev = lambda self: print('Wroom!')\n",
    "    crash = lambda self: print('Boom!')\n",
    "my_car = Car()\n",
    "\n",
    "my_car.rev()\n",
    "my_car.crash()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "departmental-dubai",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boom!\n"
     ]
    }
   ],
   "source": [
    "# better\n",
    "class Car:\n",
    "    def rev(self):\n",
    "        print('Wroom!')\n",
    "    def crash(self):\n",
    "        print('Boom!')\n",
    "        \n",
    "my_car = Car()\n",
    "my_car.crash()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "interesting-hazard",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# harmful\n",
    "list(filter(lambda x: x % 2 == 0, range(16)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "automatic-message",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8, 10, 12, 14]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# better\n",
    "[x for x in range(16) if x % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "computational-loading",
   "metadata": {},
   "source": [
    "___\n",
    "## 3.3 The Power of Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spatial-package",
   "metadata": {},
   "source": [
    "At their core, Python’s **decorators allow you to extend and modify the\n",
    "behavior of a callable** (functions, methods, and classes) without permanently modifying the callable itself. \n",
    "\n",
    "**A decorator is a callable that takes a callable as input and\n",
    "returns another callable**\n",
    "\n",
    "\n",
    "### Key summary\n",
    "\n",
    "* Decorators define reusable building blocks you can apply to a\n",
    "callable to modify its behavior without permanently modifying\n",
    "the callable itself. It also let's you call the functions by their original name. \n",
    "* The ```@``` syntax is just a shorthand for calling the decorator on\n",
    "an input function. Multiple decorators on a single function are\n",
    "applied **bottom to top (decorator stacking)**.\n",
    "* As a debugging best practice, use the ```functools.wraps``` helper\n",
    "in your own decorators to **carry over metadata from the undecorated callable to the decorated one**.\n",
    "* Just like any other tool in the software development toolbox,\n",
    "decorators are not a cure-all and they should not be overused.\n",
    "It’s important to balance the need to “get stuff done” with the\n",
    "goal of “not getting tangled up in a horrible, unmaintainable\n",
    "mess of a code base.”\n",
    "They \"decorate\" another function and let you execute code before and after the wrapped function runs. \n",
    "\n",
    "### Uses of decorators\n",
    "\n",
    "* logging\n",
    "* enforcing access control and authentication\n",
    "* instrumentation and timing functions\n",
    "* rate-limiting\n",
    "* caching, and more\n",
    "\n",
    "### Why use decorators? \n",
    "\n",
    "They allow you to define reusable building blocks that can change or extend the behavior of other functions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "novel-emperor",
   "metadata": {},
   "outputs": [],
   "source": [
    "# very simple decorator ie. it does nothing\n",
    "\n",
    "# we take a callable as input\n",
    "def null_decorator(func):\n",
    "    # we need to return a callable \n",
    "    return func\n",
    "\n",
    "def greet():\n",
    "    return 'hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "sporting-whale",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hello'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet = null_decorator(greet)\n",
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "durable-turning",
   "metadata": {},
   "source": [
    "Instead of explicitly calling ```null_decorator``` on ```greet``` you can make use of Python's ```@``` syntax for decorating a function more conveniently. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "identical-coordinate",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# the @null_decorator is just syntactic sugar\n",
    "@null_decorator\n",
    "def greet():\n",
    "    return 'HELLO'\n",
    "\n",
    "greet()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "partial-british",
   "metadata": {},
   "source": [
    "### Decorators can modify behavior \n",
    "\n",
    "* The original callable isn't permanently modified - it's behavior changes only when decorated\n",
    "* This let's you **add reusable building blocks** to existing functions and classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "treated-consciousness",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A general decorator\n",
    "\n",
    "# a callable that accepts and returns a callable\n",
    "def uppercase(func):     \n",
    "    def wrapper(word):\n",
    "        original_result = func(word)\n",
    "        modified_result = func(word).upper()\n",
    "        return modified_result \n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "divided-values",
   "metadata": {},
   "outputs": [],
   "source": [
    "# remember this is syntactic sugar for uppercase(greet())\n",
    "@uppercase \n",
    "def greet(word):\n",
    "    return word + '!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "conservative-couple",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'HELLO!'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet('hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "future-drink",
   "metadata": {},
   "source": [
    "### Applying Multiple Decorators to a Function \n",
    "\n",
    "* You can apply more then one decorator\n",
    "* This is what makes decorators so powerful"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "restricted-section",
   "metadata": {},
   "outputs": [],
   "source": [
    "def strong(func):\n",
    "    def wrapper(text):\n",
    "        return '<strong>' + func(text) + '</strong>'\n",
    "    return wrapper\n",
    "\n",
    "def emphasis(func):\n",
    "    def wrapper(text):\n",
    "        return '<em>' + func(text) + '</em>'\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "athletic-poverty",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<strong><em>Hello James</em></strong>'"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# conventional function wrapping\n",
    "def greet(text):\n",
    "    return 'Hello ' + text\n",
    "\n",
    "decorated_greet = strong(emphasis(greet))\n",
    "decorated_greet('James')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "green-growing",
   "metadata": {},
   "outputs": [],
   "source": [
    "# decorator stacking is more readible\n",
    "@strong\n",
    "@emphasis\n",
    "def greet(text):\n",
    "    return 'Hello ' + text"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "material-grave",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<strong><em>Hello Timothy</em></strong>'"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calling this decorated function clearly shows the order of application\n",
    "greet('Timothy')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dense-volunteer",
   "metadata": {},
   "source": [
    "### Decorating functions that accept a variable number of arguments\n",
    "\n",
    "* Python's ```*args``` and ```**kwargs``` are great for use with decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "usual-category",
   "metadata": {},
   "outputs": [],
   "source": [
    "# It is better to use the *args, **kwargs instead of being explicit\n",
    "def proxy(func):\n",
    "    def wrap(*args, **kwargs):\n",
    "        return func(*args, **kwargs)\n",
    "    return wrap"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "reasonable-seattle",
   "metadata": {},
   "source": [
    "Below is a decorator that is very versatile because of the use of ```*args``` and ```**kwargs```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "median-geology",
   "metadata": {},
   "outputs": [],
   "source": [
    "def trace(func):\n",
    "    def wrapper(*args, **kwargs):\n",
    "        function_result = func(*args,**kwargs)\n",
    "        \n",
    "        print(f'TRACE: calling {func.__name__}()  '\n",
    "              f'with {args}, {kwargs}\\n'\n",
    "              f'returned {function_result!r}')\n",
    "    \n",
    "        return function_result\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "alone-integration",
   "metadata": {},
   "outputs": [],
   "source": [
    "@trace \n",
    "def say(name, line):\n",
    "    return f'{name}: {line}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "returning-royal",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRACE: calling say()  with ('Jane', 'says hello world'), {}\n",
      "returned 'Jane: says hello world'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Jane: says hello world'"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "say('Jane', 'says hello world')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "spread-cotton",
   "metadata": {},
   "outputs": [],
   "source": [
    "@trace \n",
    "def add(a,b):\n",
    "    return f'The result of {a} + {b} is {a+b}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "correct-injection",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TRACE: calling add()  with (3, 4), {}\n",
      "returned 'The result of 3 + 4 is 7'\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'The result of 3 + 4 is 7'"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "disabled-shade",
   "metadata": {},
   "source": [
    "### Writing Debuggable Decorators\n",
    "\n",
    "When you use a decorator, really what you’re doing is replacing one\n",
    "function with another. One downside of this process is that it “hides”\n",
    "some of the metadata attached to the original (undecorated) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "prospective-seeking",
   "metadata": {},
   "outputs": [],
   "source": [
    "# A general decorator\n",
    "def uppercase(func):     \n",
    "    def wrapper():\n",
    "        original_result = func()\n",
    "        modified_result = original_result.upper()\n",
    "        return modified_result \n",
    "    return wrapper\n",
    "\n",
    "def greet():\n",
    "    \"\"\"Return a friendly greeting.\"\"\"\n",
    "    return 'Hello!'\n",
    "\n",
    "decorated_greet = uppercase(greet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "limiting-citation",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'greet'"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "infectious-injury",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Return a friendly greeting.'"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "center-benefit",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'wrapper'"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "decorated_greet.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "intelligent-sleeve",
   "metadata": {},
   "outputs": [],
   "source": [
    "# this doesn't return anything\n",
    "decorated_greet.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "accepted-conflict",
   "metadata": {},
   "source": [
    "The work around is the ```functools.wraps``` decorator included in Python's standard library. This will **copy over the lost metadata from the undecorated function to the decorator closure**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "fourth-requirement",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools \n",
    "\n",
    "def uppercase(func):\n",
    "    @functools.wraps(func)\n",
    "    def wrapper():\n",
    "        return func().upper()\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "alpha-simpson",
   "metadata": {},
   "outputs": [],
   "source": [
    "@uppercase\n",
    "def greet():\n",
    "    \"\"\"Introduction message\"\"\"\n",
    "    return 'Hello!'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "tested-burden",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'greet'"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# we retain the original name of the function\n",
    "greet.__name__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "twenty-society",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Introduction message'"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# now we get the wrapped functions doc string\n",
    "greet.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "understanding-virus",
   "metadata": {},
   "source": [
    "___\n",
    "## 3.4 Fun with ```*args``` and ```**kwargs```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "collaborative-government",
   "metadata": {},
   "source": [
    "### Summary \n",
    "* ```*args``` and ```**kwargs``` let you write functions with a **variable\n",
    "number of arguments** in Python.\n",
    "* ```*args``` collects extra positional arguments as a **tuple**. ```**kwargs```\n",
    "collects the extra keyword arguments as a **dictionary**.\n",
    "* The actual syntax is * and **. Calling them args and kwargs is\n",
    "just a convention (and one you should stick to).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "critical-universe",
   "metadata": {},
   "outputs": [],
   "source": [
    "# required variable is a compulsary input\n",
    "# the following positional arguments and keyword arguments are optional\n",
    "def foo(required, *args, **kwargs):\n",
    "    print(required)\n",
    "    if args:\n",
    "        print(args)\n",
    "    if kwargs:\n",
    "        print(kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "thorough-murder",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "foo('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "surgical-david",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "foo('hello', 1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "legal-vegetation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "(1, 2, 3)\n",
      "{'k1': 'car', 'k2': 10}\n"
     ]
    }
   ],
   "source": [
    "foo('hello', 1, 2, 3, k1 = 'car', k2 = 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sacred-airport",
   "metadata": {},
   "source": [
    "### Forwarding Optional or Keyword Arguments\n",
    "\n",
    "It's possible to pass optional or keyword parameters from one function to another. You can do this by unpacking ```*args``` and ```**kwargs```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "annoying-perfume",
   "metadata": {},
   "outputs": [],
   "source": [
    "def bar(x, *args, **kwargs):\n",
    "    print(x)\n",
    "    if args: \n",
    "        print(args)\n",
    "    if kwargs:\n",
    "        print(kwargs)\n",
    "\n",
    "# kwargs and args are forwarded to bar\n",
    "def foo(x, *args, **kwargs):\n",
    "    kwargs['name'] = 'Alice'\n",
    "    new_args = args + ('extra', )\n",
    "    bar(x, *new_args, **kwargs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "convertible-microphone",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "(1, 2, 3, 'extra')\n",
      "{'key1': 'car', 'key2': 'bus', 'name': 'Alice'}\n"
     ]
    }
   ],
   "source": [
    "foo('x', 1, 2, 3, key1='car', key2='bus')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "located-simple",
   "metadata": {},
   "source": [
    "### Subclassing\n",
    "\n",
    "__NOTE__ : this is a common design pattern in tkinter\n",
    "\n",
    "You can use it to **extend the behavior of a parent class** without having to replicate the full signature of its constructor in the child class. We pass on the ```args``` and ```kwargs``` to the parent constructor. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "suffering-kingston",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Car:\n",
    "    def __init__(self, color, mileage):\n",
    "        self.color = color\n",
    "        self.mileage = mileage\n",
    "\n",
    "class AlwaysBlueCar(Car):\n",
    "    def __init__(self, *args, **kwargs):\n",
    "        # we pass on all arguments to the parent class\n",
    "        super().__init__(*args, **kwargs)\n",
    "        self.color = 'blue'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "frozen-grenada",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'blue'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "car = AlwaysBlueCar('red', 28392)\n",
    "car.color"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "everyday-sullivan",
   "metadata": {},
   "source": [
    "**TAKE CARE :** However, you should be careful as the child class has an *unhelpful signature* since we don't know what arguments it expects without looking up the parent class!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "variable-bearing",
   "metadata": {},
   "source": [
    "### Wrapper functions\n",
    "\n",
    "Ideal use case as you typically **want to pass an arbitrary number of arguments** to the wrapped function. \n",
    "\n",
    "You need to **walk the line** between: \n",
    "\n",
    "**EXPLICIT VS DRY (DON'T REPEAT YOURSELF)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "dirty-current",
   "metadata": {},
   "outputs": [],
   "source": [
    "import functools\n",
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "chinese-consortium",
   "metadata": {},
   "outputs": [],
   "source": [
    "# decorators\n",
    "def trace(f):\n",
    "    @functools.wraps(f)\n",
    "    def decorated_function(*args,**kwargs):\n",
    "        print('[trace]', f, args, kwargs)\n",
    "        return f(*args, **kwargs)\n",
    "        \n",
    "    return decorated_function\n",
    "\n",
    "def timer(f):\n",
    "    @functools.wraps(f)\n",
    "    def decorated_function(*args,**kwargs):\n",
    "        print('[timer]', datetime.now())\n",
    "        return f(*args, **kwargs)\n",
    "    \n",
    "    return decorated_function  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "oriented-recommendation",
   "metadata": {},
   "outputs": [],
   "source": [
    "@trace\n",
    "def greet(greeting,name, *args, **kwargs):\n",
    "    \"\"\"Prints a greeting\"\"\"\n",
    "    return '{}, {}!'.format(greeting, name)\n",
    "\n",
    "@trace\n",
    "@timer\n",
    "def logger(name, *args, **kwargs):\n",
    "    \"\"\"Logs information\"\"\"\n",
    "    return f'Please wait {name}, logging information...'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "oriented-confidentiality",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[trace] <function greet at 0x0000017404EBD9D0> ('Hello', 'Bob') {'age': 21}\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Hello, Bob!'"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "greet('Hello', 'Bob', age = 21)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "gross-orbit",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[trace] <function logger at 0x0000017404EBD280> ('Thomas', 20, '6292-2907') {'postcode': '2904', 'city': 'New York'}\n",
      "[timer] 2021-05-09 18:12:13.838426\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Please wait Thomas, logging information...'"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logger('Thomas', 20,'6292-2907', postcode = '2904', city = 'New York')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "prompt-equilibrium",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Logs information'"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "logger.__doc__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "descending-orange",
   "metadata": {},
   "source": [
    "___\n",
    "## 3.5 Function Argument Unpacking\n",
    "\n",
    "### Summary\n",
    "* We can use the ```*``` and ```**``` operators to unpack function arguments from sequences and dictionaries\n",
    "*  Using argument unpacking effectively can help you write more flexible interfaces for your modules and functions\n",
    "* They can help **reduce complexity** by removing the need to build custom data structures"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "corporate-assignment",
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple example to work with\n",
    "def print_vector(x,y,z):\n",
    "    print('<%s, %s, %s>' % (x,y,z))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "id": "radio-glance",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<0, 1, 0>\n"
     ]
    }
   ],
   "source": [
    "print_vector(0,1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "id": "patient-coalition",
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple_vector = (0,1,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "future-chicken",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<0, 1, 0>\n"
     ]
    }
   ],
   "source": [
    "# making use of the splat operator\n",
    "print_vector(*tuple_vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "seasonal-savings",
   "metadata": {},
   "source": [
    "### Use with generators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "permanent-cincinnati",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<0, 1, 4>\n"
     ]
    }
   ],
   "source": [
    "g = (x*x for x in range(3))\n",
    "\n",
    "# we can use this splat operator with generators\n",
    "# fully unpacking a generator\n",
    "print_vector(*g)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "horizontal-healthcare",
   "metadata": {},
   "source": [
    "### Use with dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "announced-apple",
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_vec = { 'x' : 1, 'y' : 5, 'z' : -10}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "annoying-india",
   "metadata": {},
   "source": [
    "#### ```* operator```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "powered-operations",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<x, y, z>\n"
     ]
    }
   ],
   "source": [
    "# keys will get passed in a random order\n",
    "print_vector(*dict_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "binary-target",
   "metadata": {},
   "source": [
    "#### ```** operator```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "least-stuff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<1, 5, -10>\n"
     ]
    }
   ],
   "source": [
    "# the kwargs are passed to the function print_vector\n",
    "# within print_vector's scope x, y and z map to the keys of the dictionary \n",
    "print_vector(**dict_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "chronic-norway",
   "metadata": {},
   "source": [
    "#### Subtle differences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "sublime-baseball",
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_vals(*args, **kwargs):\n",
    "    if args:\n",
    "        for arg in args:\n",
    "            print(arg)\n",
    "            \n",
    "    if kwargs:\n",
    "        for kwarg in kwargs:\n",
    "            print(f'{kwarg} : {kwargs[kwarg]}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "genuine-pulse",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': 1, 'y': 5, 'z': -10}\n"
     ]
    }
   ],
   "source": [
    "# an object\n",
    "print_vals(dict_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "id": "driven-commonwealth",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x\n",
      "y\n",
      "z\n"
     ]
    }
   ],
   "source": [
    "# unpack keywords\n",
    "print_vals(*dict_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "tight-guitar",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x : 1\n",
      "y : 5\n",
      "z : -10\n"
     ]
    }
   ],
   "source": [
    "# unpack kwargs\n",
    "print_vals(**dict_vec)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "collected-giant",
   "metadata": {},
   "source": [
    "___\n",
    "## 3.6 Nothing to Return Here\n",
    "\n",
    "### Summary \n",
    "\n",
    "* **Rule of thumb: leave out return statement if the encapsulated code doesn't actually return anything**. Another case where we would leave out the return statement is when we are only interested in the side effects.\n",
    "* Other languages name an encapsulated portion of code a *procedure* if there is **no return statement**\n",
    "* If a function doesn't specify a return value, it returns ```None```. Whether to return ```None``` is a stylistic decision\n",
    "* This is a core Python feature but your code might communicate its intent more clearly with an explicit ```return None``` statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "marked-transport",
   "metadata": {},
   "outputs": [],
   "source": [
    "# all 3 imply the same behavior\n",
    "def foo1(value):\n",
    "    if value:\n",
    "        return value\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "# gravitate towards this function definition\n",
    "def foo2(value):\n",
    "    \"\"\"Bare return statement implies 'return None'\"\"\"\n",
    "    if value:\n",
    "        return value \n",
    "    else:\n",
    "        return \n",
    "    \n",
    "# can be considered a procedure\n",
    "def foo3(value):\n",
    "    \"\"\"Missing return statement\"\"\"\n",
    "    if value:\n",
    "        return value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "anticipated-litigation",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n",
      "<class 'NoneType'>\n",
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "# passing falsy values\n",
    "print(type(foo1(0)))\n",
    "print(type(foo2(0)))\n",
    "print(type(foo3(0)))"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}