{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Foundations of Computational Economics #5\n", "\n", "by Fedor Iskhakov, ANU\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "## Python essentials: control flow and functions\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "subslide" } }, "source": [ "\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.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": [ "
" ] }, "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 }