11_Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Functions\n",
    "\n",
    "```\n",
    "def <name>(<arguments>):\n",
    "    [body]\n",
    "    [return [value]]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is function?\n",
    "\n",
    "Function is...\n",
    "\n",
    "* From Math: a relation between terms. Every input term has exactly one output term (**pure** function).\n",
    "* a **reusable** piece of code\n",
    "* a method of **abstraction** and facade for a complex mechanics\n",
    "* a method for problem **decomposition**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "def nothing_speshal():\n",
    "    pass\n",
    "\n",
    "nothing_speshal()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.nothing_speshal>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nothing_speshal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(nothing_speshal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions have it's own scope. In example below a new variable 'x' is created and then destroyed on exit.\n",
    "\n",
    "> In computer programming, **variable shadowing** occurs when a variable declared within a certain scope (decision block, method, or inner class) has the same name as a variable declared in an outer scope."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In function: Boo!\n",
      "Outside: Blah\n"
     ]
    }
   ],
   "source": [
    "x = 'Blah'\n",
    "\n",
    "def fun1():\n",
    "    x = 'Boo!'\n",
    "    print(\"In function: \" + x)\n",
    "\n",
    "fun1()\n",
    "print(\"Outside: \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "However, functions have access to outer scope.\n",
    "\n",
    "Outer scope has no access to inner scope (except closures, will talk about it later)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In function: Blah\n",
      "Outside: Blah\n"
     ]
    }
   ],
   "source": [
    "x = 'Blah'\n",
    "\n",
    "def outer_scope_accessor():\n",
    "    print(\"In function: \" + x)\n",
    "\n",
    "outer_scope_accessor()\n",
    "print(\"Outside: \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "But! If you try to change outer scope variable from function scope, a new variable in function scope will be created!\n",
    "\n",
    "Use **global**, but it is considered a bad practice. If function changes anything in outer scope it is called \"side effect\" and is an error prone tactics."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "In function (before): Blah\n",
      "In function (after): Boo!\n",
      "Outside: Boo!\n"
     ]
    }
   ],
   "source": [
    "x = 'Blah'\n",
    "\n",
    "def global_mess_maker():\n",
    "    global x\n",
    "    \n",
    "    print(\"In function (before): \" + x)\n",
    "    x = 'Boo!'\n",
    "    print(\"In function (after): \" + x)\n",
    "    \n",
    "global_mess_maker()\n",
    "print(\"Outside: \" + x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "One more time, there's no variable declaration, not per block like for example in ES6:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "{\n",
    "    let x = 1;\n",
    "    {\n",
    "        let x = 2;\n",
    "        console.log(x);\n",
    "    }\n",
    "    console.log(x);\n",
    "}\n",
    "\n",
    "Output:\n",
    "2\n",
    "1\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python new variable scope is created on function enter and destroyed on exit. Outer scopes are read-only accessible unless access type (such as global) is specified. Write access creates new scope variable or updates variable in outer scope in access type scpecified."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## LEGB rule\n",
    "\n",
    "[Sebastian Rashka's article](https://sebastianraschka.com/Articles/2014_python_scope_and_namespaces.html)\n",
    "\n",
    "Local -> Enclosed -> Global -> Built-in,\n",
    "\n",
    "where the arrows should denote the direction of the namespace-hierarchy search order.\n",
    "\n",
    "* __Local__ can be inside a function or class method, for example.\n",
    "* __Enclosed__ can be its enclosing function, e.g., if a function is wrapped inside another function.\n",
    "* __Global__ refers to the uppermost level of the executing script itself, and\n",
    "* __Built-in__ are special names that Python reserves for itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local value\n"
     ]
    }
   ],
   "source": [
    "a_var = 'global value'\n",
    "\n",
    "def outer():\n",
    "    a_var = 'enclosed value'\n",
    "\n",
    "    def inner():\n",
    "        a_var = 'local value'\n",
    "        print(a_var)\n",
    "\n",
    "    inner()\n",
    "\n",
    "outer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## A rule of thumb\n",
    "\n",
    "> In practice, it is usually a bad idea to modify global variables inside the function scope, since it often be the cause of confusion and weird errors that are hard to debug.\n",
    ">\n",
    "> If you want to modify a global variable via a function, it is recommended to pass it as an argument and reassign the return-value.\n",
    ">\n",
    "> For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "a_var = 2\n",
    "\n",
    "def a_func(some_var):\n",
    "    return 2 ** 3\n",
    "\n",
    "a_var = a_func(a_var)\n",
    "print a_var"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions usualy return results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Here, I'm done\""
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def return_report():\n",
    "    return \"Here, I'm done\"\n",
    "\n",
    "x = return_report()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If function is missing a `return` statement, it returns `None`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def nothing_doer():\n",
    "    pass\n",
    "\n",
    "print nothing_doer()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Empty `return` also returns `None` and immidiately exists function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "def nothing_returner():\n",
    "    return\n",
    "\n",
    "print nothing_returner()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "It's ok to ignore function's return value if you don't need it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def the_11_returner():\n",
    "    return 11\n",
    "\n",
    "# here return value is unused an silenced\n",
    "the_11_returner()\n",
    "\n",
    "pass # this to make Jupyter produce no output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "It's ok to return earlier and in several places. Often used to check for input constraints:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def between_10_and_100_checker(number):\n",
    "    if number < 10:\n",
    "        return False\n",
    "\n",
    "    if number > 100:\n",
    "        return False\n",
    "    \n",
    "    return True\n",
    "\n",
    "assert between_10_and_100_checker(9) == False\n",
    "assert between_10_and_100_checker(1000) == False\n",
    "assert between_10_and_100_checker(50) == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "If you need to return several values, this is what tuple()'s are for:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "def return_multuple():\n",
    "    return (1, 'a')\n",
    "\n",
    "x, y = return_multuple()\n",
    "print x\n",
    "print y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "a\n",
      "b\n"
     ]
    }
   ],
   "source": [
    "def return_multuple_tuple():\n",
    "    return 1, ('a', 'b')\n",
    "\n",
    "x, (a, b) = return_multuple_tuple()\n",
    "\n",
    "print(x)\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions accept arguments. Arguments are declared within a function definition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def multiply(arg1, arg2):\n",
    "    return arg1 * arg2\n",
    "\n",
    "multiply(4, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python3 type hinting is also avaiable:\n",
    "```\n",
    "def greeting(name: str) -> str:\n",
    "    return 'Hello ' + name\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Arguments may have default values (in case if missed in a call):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Petya + Masha = LOVE <3'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def note_on_a_fence(name1, name2, feeling=\"LOVE <3\"):\n",
    "    return \"{} + {} = {}\".format(name1, name2, feeling)\n",
    "\n",
    "note_on_a_fence(\"Petya\", \"Masha\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Default argument is used only if missed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Masha + Natasha = HATE'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "note_on_a_fence(\"Masha\", \"Natasha\", \"HATE\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### PEP 8: Spaces for keyword arguments\n",
    "\n",
    "Don't use spaces around the = sign when used to indicate a keyword argument or a default parameter value.\n",
    "\n",
    "Yes:\n",
    "\n",
    "```\n",
    "def complex(real, imag=0.0):\n",
    "    return magic(r=real, i=imag)\n",
    "```\n",
    "\n",
    "No:\n",
    "\n",
    "```\n",
    "def complex(real, imag = 0.0):\n",
    "    return magic(r = real, i = imag) \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You can mix the order of arguments as long as you provide its names (but please don't):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python + You = Curiosity'"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# def note_on_a_fence(name1, name2, feeling=\"LOVE <3\"):\n",
    "    \n",
    "note_on_a_fence(feeling=\"Curiosity\", name2=\"You\", name1=\"Python\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "BUT! Default arguments are instantiated only once! This is where you love the immutability."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Element']\n",
      "['Element', 'Element']\n",
      "['Element', 'Element', 'Element']\n"
     ]
    }
   ],
   "source": [
    "def buggy_default(arr=[]):\n",
    "    arr.append('Element')\n",
    "    return arr\n",
    "    \n",
    "print(buggy_default())\n",
    "print(buggy_default())\n",
    "print(buggy_default())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "You better achieve the desired result this way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Element']\n",
      "['Element']\n",
      "['Element']\n"
     ]
    }
   ],
   "source": [
    "def buggy_default(arr=None):\n",
    "    if arr is None:\n",
    "        arr = []\n",
    "    \n",
    "    arr.append('Element')\n",
    "    return arr\n",
    "\n",
    "print(buggy_default())\n",
    "print(buggy_default())\n",
    "print(buggy_default())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Since everything is an object and objects are passed by reference, a function can have side effects even without accessing the outer scope!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [2, 3]]\n"
     ]
    }
   ],
   "source": [
    "def list_appender(arr):\n",
    "    arr2 = arr[:]\n",
    "    arr2.append('Appended')\n",
    "    \n",
    "mylist = [[1, 2], [2, 3]]\n",
    "\n",
    "list_appender(mylist)\n",
    "list_appender(mylist)\n",
    "list_appender(mylist)\n",
    "\n",
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions can define functions in it's own scope:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def outer_function(number):\n",
    "    def multiply(arg1, arg2):\n",
    "        return arg1 * arg2\n",
    "\n",
    "    return multiply(number, 10)\n",
    "\n",
    "outer_function(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Better example (names starting with undescore never imported):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def _multiply(arg1, arg2):\n",
    "    return arg1 * arg2\n",
    "\n",
    "def outer_function(number):\n",
    "    return _multiply(number, 10)\n",
    "\n",
    "outer_function(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions can even return functions whose scope is not destroyed, this is called a **closure**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function exponent at 0x11233a578>\n",
      "1000\n"
     ]
    }
   ],
   "source": [
    "def closure_factory(number):\n",
    "    def exponent(power):\n",
    "        return number ** power\n",
    "\n",
    "    return exponent\n",
    "\n",
    "closure = closure_factory(10)\n",
    "\n",
    "# now closure contains function 'exponent' with '10' remembered in it's scope\n",
    "print closure\n",
    "print closure(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "closure_factory(10)(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Functions can be passed in arguments:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "call_me_now\n",
      "call_me_later\n"
     ]
    }
   ],
   "source": [
    "def call_me_later():\n",
    "    print(\"call_me_later\")\n",
    "    \n",
    "def call_me_now(f):\n",
    "    print(\"call_me_now\")\n",
    "    f()\n",
    "    \n",
    "x = call_me_later\n",
    "call_me_now(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "How functional programming can help in problem decomposition:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ". x . x . x . x . x .\n",
      "x . x . x . x . x . x\n",
      ". x . x . x . x . x .\n",
      "x . x . x . x . x . x\n",
      ". x . x . x . x . x .\n",
      "x . x . x . x . x . x\n",
      ". x . x . x . x . x .\n",
      "x . x . x . x . x . x\n",
      ". x . x . x . x . x .\n",
      "x . x . x . x . x . x\n",
      ". x . x . x . x . x .\n"
     ]
    }
   ],
   "source": [
    "# generic grid drawing function, accepts function with signature f(x, y) -> bool as an argument\n",
    "def draw_grid(f):\n",
    "    for y in range(11):\n",
    "        for x in range(11):\n",
    "            # please notice f(x, y) is called here\n",
    "            print 'x' if f(x, y) else '.', # notice the comma at the end of the line - it suppresses \"\\n\"\n",
    "\n",
    "        # empty print prints just a newline \"\\n\"\n",
    "        print\n",
    "\n",
    "# a function that returns Boolean is called \"predicate\"\n",
    "def my_drawing(x, y):\n",
    "    return (x + y) % 2\n",
    "\n",
    "draw_grid(my_drawing)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Another example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ". . . . . . . . . . .\n",
      ". . . . . x . . . . .\n",
      ". . . . x x x . . . .\n",
      ". . . x x x x x . . .\n",
      ". . x x x x x x x . .\n",
      ". x x x x x x x x x .\n",
      ". . x x x x x x x . .\n",
      ". . . x x x x x . . .\n",
      ". . . . x x x . . . .\n",
      ". . . . . x . . . . .\n",
      ". . . . . . . . . . .\n"
     ]
    }
   ],
   "source": [
    "def draw_diamond(x, y):\n",
    "    return abs(5 - x) + abs(5 - y) < 5\n",
    "\n",
    "draw_grid(draw_diamond)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Function can accept variable number of arguments. Syntax:\n",
    "```\n",
    "def fun(*args):\n",
    "   # args is a tuple now:\n",
    "   # args = (arg1, arg2, ..., argN,)\n",
    "   ...\n",
    "\n",
    "fun(arg1, arg2, ..., argN)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('1',)\n"
     ]
    }
   ],
   "source": [
    "# args is a tuple\n",
    "def many_arguments(*args):\n",
    "    print args\n",
    "    \n",
    "many_arguments(\"1\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('1', 'a', 'b', 'c')\n"
     ]
    }
   ],
   "source": [
    "many_arguments(\"1\", \"a\", \"b\", \"c\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "This is different from passing a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first\n"
     ]
    }
   ],
   "source": [
    "def return_first_argument(*args):\n",
    "    print args[0]\n",
    "    \n",
    "return_first_argument(\"first\", \"a\", \"third\", \"c\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['first', 'a', 'third', 'c']\n"
     ]
    }
   ],
   "source": [
    "return_first_argument([\"first\", \"a\", \"third\", \"c\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "To make a list compatible with function with variable number of arguments, provide asterisk before the list-argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(-17, 23, -39, -3, 44, 36, 7, 19, -3)\n"
     ]
    }
   ],
   "source": [
    "my_numbers = [-17, 23, -39, -3, 44, 36, 7, 19, -3]\n",
    "many_arguments(*my_numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "So, function defined with variable arguments `*args` can be called like:\n",
    "\n",
    "`fun(arg1, arg2, ..., argN)`\n",
    "\n",
    "or\n",
    "\n",
    "`fun(*[arg1, arg2, ..., argN])`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Variable and required arguments can be combined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "must have\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "def required_and_variable(req1, req2, *args):\n",
    "    print req1, req2\n",
    "    print args\n",
    "\n",
    "required_and_variable('must', 'have')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "must have\n",
      "('but', 'all', 'of', 'these', 'are', 'optional')\n"
     ]
    }
   ],
   "source": [
    "required_and_variable('must', 'have', 'but', 'all', 'of', 'these', 'are', 'optional')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Required, optional and default arguments can also be combined:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "must the_default\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "def required_default_and_variable(req1, req2='the_default', *args):\n",
    "    print req1, req2\n",
    "    print args\n",
    "\n",
    "required_default_and_variable('must')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "must have\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "required_default_and_variable('must', 'have')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "must have\n",
      "('optional',)\n"
     ]
    }
   ],
   "source": [
    "required_default_and_variable('must', 'have', 'optional')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Similarly to variable number of positional arguments, function can be declared to accept an arbitrary number of named arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Director:\n",
      "{'position': 'CEO', 'surname': 'Jobs', 'name': 'Steve'}\n"
     ]
    }
   ],
   "source": [
    "# kwargs is a dict\n",
    "def many_named_arguments(required_arg, **kwargs):\n",
    "    print required_arg\n",
    "    print kwargs\n",
    "    \n",
    "many_named_arguments(\"Director:\", name=\"Steve\", surname=\"Jobs\", position=\"CEO\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Most common case. Python will collect all unknown unnamed arguments to `*args`, and keyword arguments to `**kwargs`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required 1: First\n",
      "Required 2: Second\n",
      "\n",
      "Optional 0: Third\n",
      "Optional 1: Fourth\n",
      "\n",
      "Keyword 'yet_another': Sixth\n",
      "Keyword 'another': Fifth\n"
     ]
    }
   ],
   "source": [
    "def common_case(arg1, arg2, *args, **kwargs):\n",
    "    print \"Required 1: \" + arg1\n",
    "    print \"Required 2: \" + arg2\n",
    "    print\n",
    "    \n",
    "    for i, v in enumerate(args):\n",
    "        print \"Optional {}: {}\".format(i, v)\n",
    "        \n",
    "    print\n",
    "    \n",
    "    for k, v in kwargs.items():\n",
    "        print \"Keyword '{}': {}\".format(k, v)\n",
    "        \n",
    "common_case(\"First\", \"Second\", \"Third\", \"Fourth\", another=\"Fifth\", yet_another=\"Sixth\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Opposite trick, you can expand list and dict to function ```*args``` and ```**kwargs``` like so:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Required 1: R1\n",
      "Required 2: R2\n",
      "\n",
      "Optional 0: Obama\n",
      "Optional 1: Franklin\n",
      "Optional 2: Lincoln\n",
      "\n",
      "Keyword 'mr': Holmes\n",
      "Keyword 'lady': Gaga\n",
      "Keyword 'mrs': Hudson\n"
     ]
    }
   ],
   "source": [
    "mylist = [\n",
    "    'Franklin',\n",
    "    'Lincoln'\n",
    "]\n",
    "\n",
    "mydict = {\n",
    "    'lady': 'Gaga',\n",
    "    'mr': 'Holmes'\n",
    "}\n",
    "\n",
    "# 'Obama' will be merged with *args, and 'mrs=Hudson' with **kwargs\n",
    "common_case('R1', 'R2', 'Obama', mrs='Hudson', *mylist, **mydict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### PEP 257: Documentation Strings\n",
    "\n",
    "[PEP 257](https://www.python.org/dev/peps/pep-0257/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mycomplex(real=0.0, imag=0.0):\n",
    "    \"\"\"Form a complex number.\n",
    "\n",
    "    Keyword arguments:\n",
    "    real -- the real part (default 0.0)\n",
    "    imag -- the imaginary part (default 0.0)\n",
    "    \"\"\"\n",
    "    return complex(real, imag)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lambda\n",
    "\n",
    "> In computer programming, an anonymous function (function literal, lambda abstraction) is a function definition that is not bound to an identifier. Anonymous functions are often:\n",
    "* arguments being passed to higher-order functions, or\n",
    "* used for constructing the result of a higher-order function that needs to return a function.\n",
    "\n",
    "in other words\n",
    "__lamdas are anonymous functions__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Lambda is a function for short chunks of code, e.g.:\n",
    "\n",
    "```\n",
    "my_fun = lambda x: x ** 2\n",
    "```\n",
    "\n",
    "is exactly the same as:\n",
    "\n",
    "```\n",
    "def my_fun(x):\n",
    "    return x ** 2\n",
    "```\n",
    "\n",
    "But:\n",
    "  * no brackets `()` for arguments\n",
    "  * no `return` statement\n",
    "  * not more then one expression (e.g. it's a one-liner)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "square = lambda x: x ** 2\n",
    "square(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "256"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mypower = lambda x, y: x ** y\n",
    "mypower(2, 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### PEP 8: Lambdas must remain anonymous\n",
    "\n",
    "Always use a def statement instead of an assignment statement that binds a lambda expression directly to an identifier.\n",
    "\n",
    "Yes:\n",
    "\n",
    "```\n",
    "def f(x): return 2*x\n",
    "```\n",
    "\n",
    "No:\n",
    "\n",
    "```\n",
    "f = lambda x: 2*x\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "In Python lambdas usually used to pass small computable blocks to other functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'name': 'Max', 'surname': 'Born'},\n",
       " {'name': 'Albert', 'surname': 'Einstein'},\n",
       " {'name': 'Michael', 'surname': 'Faraday'},\n",
       " {'name': 'Sigmund', 'surname': 'Freud'}]"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "scientists = [\n",
    "    {'name': 'Albert', 'surname': 'Einstein'},\n",
    "    {'name': 'Sigmund', 'surname': 'Freud'},\n",
    "    {'name': 'Max', 'surname': 'Born'},\n",
    "    {'name': 'Michael', 'surname': 'Faraday'}\n",
    "]\n",
    "\n",
    "sorted(scientists, key=lambda d: d['surname'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Documentation on [sorting](https://docs.python.org/2/howto/sorting.html): \n",
    "> Starting with Python 2.4, both list.sort() and sorted() added a key parameter to specify a function to be called on each list element prior to making comparisons.\n",
    "\n",
    "> The value of the key parameter should be a function that takes a single argument and returns a key to use for sorting purposes. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Another useful example of lambdas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ". . x x . . x x . . x\n",
      ". . x x . . x x . . x\n",
      "x x . . x x . . x x .\n",
      "x x . . x x . . x x .\n",
      ". . x x . . x x . . x\n",
      ". . x x . . x x . . x\n",
      "x x . . x x . . x x .\n",
      "x x . . x x . . x x .\n",
      ". . x x . . x x . . x\n",
      ". . x x . . x x . . x\n",
      "x x . . x x . . x x .\n"
     ]
    }
   ],
   "source": [
    "def draw_grid(f):\n",
    "    for y in range(11):\n",
    "        for x in range(11):\n",
    "            # please notice f(x, y) is called here\n",
    "            print 'x' if f(x, y) else '.', # notice the comma at the end of the line - it suppresses \"\\n\"\n",
    "\n",
    "        # empty print prints just a newline \"\\n\"\n",
    "        print\n",
    "\n",
    "\n",
    "#draw_grid(lambda x, y: (x + y) % 2)\n",
    "#draw_grid(lambda x, y: x % 2 or y % 2)\n",
    "#draw_grid(lambda x, y: abs(x - 4) + abs(y - 4) <= 4)\n",
    "#draw_grid(lambda x, y: (x == y) or ((x + y) == 8))\n",
    "\n",
    "draw_grid(lambda x, y: (x / 2 + y / 2) % 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Miscelaneous\n",
    "### Recursion\n",
    "\n",
    "> In order to understand recursion you must first understand recursion."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1]\n",
      "[2, 1]\n",
      "[3, 2, 1]\n",
      "[4, 3, 2, 1]\n",
      "[5, 4, 3, 2, 1]\n",
      "[6, 5, 4, 3, 2, 1]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[6, 5, 4, 3, 2, 1]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def recursive(result, x):\n",
    "    if x > 0:  \n",
    "        result = [x] + recursive(result, x - 1)\n",
    "        print(result)\n",
    "    \n",
    "    return result\n",
    "        \n",
    "recursive([], 6)"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Attachments",
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.16"
  },
  "livereveal": {
   "theme": "white",
   "transition": "fast"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}