05_python_flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Foundations of Computational Economics #5\n",
    "\n",
    "by Fedor Iskhakov, ANU\n",
    "\n",
    "<img src=\"_static/img/dag3logo.png\" style=\"width:256px;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Python essentials: control flow and functions\n",
    "\n",
    "<img src=\"_static/img/lecture.png\" style=\"width:64px;\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"_static/img/youtube.png\" style=\"width:65px;\">\n",
    "\n",
    "[https://youtu.be/KDOH2R-Ambk](https://youtu.be/KDOH2R-Ambk)\n",
    "\n",
    "Description: Flow control, user defined functions. Sieve of Eratosthenes example."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Plan for the lecture\n",
    "\n",
    "1. Flow control  \n",
    "1. User defined functions  \n",
    "\n",
    "\n",
    "📖 Kevin Sheppard “Introduction to Python for Econometrics, Statistics\n",
    "and Data Analysis.” *Chapters: 3, 5, 10, 11, 13, 18, 22*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Flow control: conditional expression and loops\n",
    "\n",
    "Branch the program depending on a condition\n",
    "\n",
    "- if  \n",
    "- if .. else  \n",
    "- if .. elif  \n",
    "- if .. elif .. else  \n",
    "\n",
    "\n",
    "**Remember about indentation!**- Should be 4 spaces according to PEP8 - Better not use Tab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Examples of if-then-else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Condition 1\n"
     ]
    }
   ],
   "source": [
    "x = 2\n",
    "y = 2.0\n",
    "z = [1, 2.1, 3.0, 0.0]\n",
    "\n",
    "if y==2 and z[-1] >= 0.0:\n",
    "    print(\"Condition 1\")\n",
    "elif y<2:\n",
    "    print(\"Condition 2\")\n",
    "else:\n",
    "    print(\"Condition 3\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Condition 2\n"
     ]
    }
   ],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "if x and y:\n",
    "    print(\"Condition 1\")\n",
    "elif x and not y:\n",
    "    print(\"Condition 2\")\n",
    "elif not x and y:\n",
    "    print(\"Condition 3\")\n",
    "elif not x and not y:\n",
    "    print(\"Condition 4\")\n",
    "else:\n",
    "    print(\"Condition 5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Pass statement\n",
    "\n",
    "Do nothing, but have correct indent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    pass\n",
    "else:\n",
    "    print(\"check\")\n",
    "print(\"done\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Ternary conditional operator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "a, b, condition = 1, 3, True\n",
    "\n",
    "a if condition else b      # expression, not a statement\n",
    "\n",
    "c = a if condition else b  # therefore this is possible"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Flow control: loops\n",
    "\n",
    "- for  \n",
    "- while  \n",
    "- break  \n",
    "- continue  \n",
    "- for .. else, while .. else  \n",
    "\n",
    "\n",
    "**Remember about indent**- Should be 4 spaces according to PEP8 - Better not use Tab"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Examples of for"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A iteration 0\n",
      "A iteration 1\n",
      "A iteration 2\n",
      "A iteration 3\n",
      "A iteration 4\n",
      "A iteration 5\n",
      "\n",
      "B iteration 0\n",
      "B iteration 1\n",
      "B iteration 2\n",
      "B iteration 3\n",
      "B iteration 4\n"
     ]
    }
   ],
   "source": [
    "for i in [0,1,2,3,4,5]:\n",
    "    print(\"A iteration %d\" % i)\n",
    "print()\n",
    "\n",
    "for i in range(5):\n",
    "    print(\"B iteration %d\" % i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### List comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['item 0', 'item 3', 'item 6', 'item 9', 'item 12']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = []\n",
    "for i in range(15):\n",
    "    if i%3==0:\n",
    "        x.append(\"item %d\"%i)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['item 0', 'item 3', 'item 6', 'item 9', 'item 12']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [\"item %d\"%i for i in range(15) if i%3==0]\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Multiple indexes in list comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i=0 j=a\n",
      "i=1 j=b\n",
      "i=2 j=c\n",
      "i=3 j=d\n"
     ]
    }
   ],
   "source": [
    "for i,j in zip(range(4),[\"a\",\"b\",\"c\",\"d\"]):\n",
    "    print(\"i=%d j=%s\"%(i,j))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 8, 16, 1, 3, 9, 27, 81, 1, 5, 25, 125, 625]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p= [x**y for x in  (2,3,5) for y in range(5)] #three power series\n",
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### For .. else\n",
    "\n",
    "Very useful to check if for loop did not **break**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loop complete with k=16 i=76\n"
     ]
    }
   ],
   "source": [
    "k=0\n",
    "for i in range(100):\n",
    "    if k>15:\n",
    "        break\n",
    "    if i%5==0:\n",
    "        k+=1\n",
    "else:\n",
    "    print(\"i went all the way up to %d\"%i) #only runs if loop completed\n",
    "print(\"loop complete with k=%d i=%d\"%(k,i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### While .. break .. continue example\n",
    "\n",
    "**Sieve of Eratosthenes** to find prime numbers up to a certain value\n",
    "\n",
    "Algorithm:\n",
    "- initialize the list of primes with all integers\n",
    "- go through a list of divisors (have to be in the list of primes)\n",
    "- cross all candidates divisible by the considered divisor\n",
    "- stop when all divisors up to the boundary are considered\n",
    "\n",
    "Exercise: how can the algorithm be improved?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "divisor 2: [1, 2, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23]\n",
      "divisor 3: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 5: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 7: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 11: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 13: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 17: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 19: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "divisor 23: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n",
      "Primes up to 23 are: [1, 2, 3, 5, 7, 11, 13, 17, 19, 23]\n"
     ]
    }
   ],
   "source": [
    "upper = 23\n",
    "primes = list(range(1,upper+1))  # all numbers between 1 and upper\n",
    "divisor = 1  # initial divisor\n",
    "while True:\n",
    "    divisor+=1  # next divisor\n",
    "    if divisor>upper:  # checked all divisors (?)\n",
    "        break\n",
    "    if not divisor in primes:\n",
    "        continue  # skip divisor which is not itself prime\n",
    "    i=0\n",
    "    while i<len(primes):\n",
    "        if primes[i]!=divisor and primes[i]%divisor==0:\n",
    "            primes.remove(primes[i])  # remove, next is with the same index\n",
    "        else:\n",
    "            i+=1 # skip to go to next\n",
    "    print(\"divisor %d:\"%divisor,primes)\n",
    "print(\"Primes up to %d are:\" % upper,primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### User defined functions\n",
    "\n",
    "- particular function in the code  \n",
    "- inputs and outputs  \n",
    "- can occur in the same file as the main program  \n",
    "- docstrings **!!!**  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Defining a custom function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.0\n",
      "Help on function my_function in module __main__:\n",
      "\n",
      "my_function()\n",
      "    This is docstring for my function which explains what the function does:\n",
      "    This function simply returns zero\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def my_function():\n",
    "    '''This is docstring for my function which explains what the function does:\n",
    "       This function simply returns zero\n",
    "    '''\n",
    "    return 0.0\n",
    "\n",
    "# call from the main program\n",
    "x=my_function()\n",
    "print(x)\n",
    "\n",
    "# see docs\n",
    "help(my_function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Input arguments\n",
    "\n",
    "Python supports **named arguments** as well as **positional arguments**\n",
    "\n",
    "Functions can have default values for optional arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 'test', 5]\n",
      "['one', 'two', 3]\n"
     ]
    }
   ],
   "source": [
    "def my_function(a,b,c = 5):\n",
    "    '''Build a list from three input arguments'''\n",
    "    return [a,b,c]\n",
    "\n",
    "# call from the main program\n",
    "x=my_function(0,\"test\")\n",
    "print(x)\n",
    "y=my_function(a=\"one\", c=3, b=\"two\")\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Variable scope"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_function variables are:\n",
      "    a=10 \n",
      "    b=2 \n",
      "    my_nested_function=<function my_function.<locals>.my_nested_function at 0x7fe220357dd0> \n",
      "my_nested_function variables:\n",
      "    c=10 \n",
      "    d=2 \n",
      "The output from my function is  240\n"
     ]
    }
   ],
   "source": [
    "def my_function(a, b):\n",
    "\n",
    "    def my_nested_function(c, d):\n",
    "        print(\"my_nested_function variables:\")    # printing all variables in the scope of the function\n",
    "        for symbol, value in locals().items():    # printing all variables in the scope of the function\n",
    "            print (\"    %s=%r \"%(symbol,value))   # printing all variables in the scope of the function\n",
    "        return c + d\n",
    "\n",
    "    print(\"my_function variables are:\")           # printing all variables in the scope of the function\n",
    "    for symbol, value in locals().items():        # printing all variables in the scope of the function\n",
    "        print (\"    %s=%r \"%(symbol,value))       # printing all variables in the scope of the function\n",
    "\n",
    "    x = a * b * my_nested_function(a,b)\n",
    "    return x\n",
    "\n",
    "# call from the main program\n",
    "x=10\n",
    "y=2\n",
    "print('The output from my function is ',my_function(x,y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Lambda functions (inline functions)\n",
    "\n",
    "Short way to define simple functions, useful in bigger language constructs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f(5)=125.000000\n",
      "y(3)=27.000000\n"
     ]
    }
   ],
   "source": [
    "def f(x):\n",
    "    return x**3\n",
    "\n",
    "y = lambda x: x**3\n",
    "\n",
    "print(\"f(5)=%f\"%f(5))\n",
    "print(\"y(3)=%f\"%y(3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "#### Example of user defined function: memory usage\n",
    "\n",
    "First, plotting function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def my_plot(d):\n",
    "    '''Makes a nice plot using passed data'''\n",
    "    import matplotlib.pyplot as plt\n",
    "    plt.plot(d[\"x\"],d[\"y\"])\n",
    "    plt.axis([min(d[\"x\"]),max(d[\"x\"]),0,max(d[\"y\"])+1])\n",
    "    plt.ylabel('size in memory, bytes')\n",
    "    plt.xlabel('steps of variable update')\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "def memory_usage(var,grow,steps=10):\n",
    "    '''Returns data on memory usage when var is grown using supplied function for given number of steps'''\n",
    "    d={\"x\":[],\"y\":[],\"v\":[]} # dictionary for x, y data, and values\n",
    "    for i in range(steps):\n",
    "        var=grow(var) # next value\n",
    "        d[\"v\"].append(var)\n",
    "        d[\"x\"].append(i+1) # start with step 1 rather than 0\n",
    "        d[\"y\"].append(sys.getsizeof(var))\n",
    "    return d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hide-output": false,
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last value: ['*******', '********', '*********', '**********', '***********']\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "d=memory_usage(var='*',grow=lambda x: x+\"*\",steps=10)\n",
    "# d=memory_usage(var='*',grow=lambda x: x*2,steps=10)\n",
    "# d=memory_usage(var=1,grow=lambda x: x*2,steps=200)\n",
    "# d=memory_usage(var=1e249,grow=lambda x: x*2,steps=200)\n",
    "print(\"Last value: %r\"%d[\"v\"][-5:])\n",
    "my_plot(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Further learning resources\n",
    "\n",
    "- Python book: Kevin Sheppard “Introduction to Python for Econometrics,\n",
    "  Statistics and Data Analysis.” 3rd Edition University of Oxford\n",
    "  Thursday 1st February, 2018  \n",
    "- Coding style\n",
    "  [https://docs.python-guide.org/writing/style/#idioms](https://docs.python-guide.org/writing/style/#idioms)  \n",
    "- Formatting output\n",
    "  [https://pyformat.info/](https://pyformat.info/)  \n",
    "- Python inbuilt functions\n",
    "  [https://docs.python.org/3/library/functions.html](https://docs.python.org/3/library/functions.html)  "
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "date": 1612589584.466432,
  "download_nb": false,
  "filename": "05_python_flow.rst",
  "filename_with_path": "05_python_flow",
  "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.7.6"
  },
  "title": "Foundations of Computational Economics #5"
 },
 "nbformat": 4,
 "nbformat_minor": 4
}