02-Python-functions.ipynb

   1 {
   2  "cells": [
   3   {
   4    "cell_type": "markdown",
   5    "metadata": {
   6     "id": "cB27OQ9zJ5iV"
   7    },
   8    "source": [
   9     "# Python Tutorial II: Logic, functions, and loops\n",
  10     "In this lecture, we will explore how to control workflow in a code using conditionals and loops.,\n",
  11     "For more information, we recommend reviewing some of the online documentation available at https://docs.python.org/3/tutorial/controlflow.html.\n",
  12     "We will also see how to make code more modular by creating user-defined functions and modules."
  13    ]
  14   },
  15   {
  16    "cell_type": "code",
  17    "execution_count": null,
  18    "metadata": {
  19     "id": "fF56Sh5TKVPS"
  20    },
  21    "outputs": [],
  22    "source": [
  23     "import numpy as np #We will use numpy in this lecture"
  24    ]
  25   },
  26   {
  27    "cell_type": "markdown",
  28    "metadata": {
  29     "id": "V35daS7t7Ry3"
  30    },
  31    "source": [
  32     "## Conditionals & Comparisons in Python\n",
  33     "    \n",
  34     "### Conditionals in Python    \n",
  35     "0. In Python, there are no \"case\" or \"switch\" options that are available in other languages, but we can get the same functionality by using dictionary mappings. However, this is beyond the scope of this tutorial. \n",
  36     "1. You will find that most things can be done using the if/elif/else syntax:\n",
  37     "```\n",
  38     "if condition:\n",
  39     "    #do stuff\n",
  40     "elif condition: #elif is interpreted as \"else if\"\n",
  41     "    #do stuff\n",
  42     "else:\n",
  43     "    #do stuff\n",
  44     "```       \n",
  45     "\n",
  46     "***All parts of the conditional are indented.*** \n",
  47     "Unlike other languages that use terms like \"end\" or \"end if\" (or perhaps make use of brackets like \"{ }\") to signify the block of code corresponding to an if-elseif-else, ***Python interprets everything in terms of indenting.*** \n",
  48     "This is also true in for-loops as we will see below.\n",
  49     "       \n",
  50     "### Comparison operators  (*LET a=3, b=5*)\n",
  51     "==:\tIf the values of two operands are equal, then the condition becomes true.\t*(a == b) is not true.*\n",
  52     "\n",
  53     "!=:\tIf values of two operands are not equal, then condition becomes true.  *(a != b) is true.* (Alternatively, one could use `<>` in place of `!=`, but this is not very common.)\n",
  54     "\n",
  55     " \">\":\tIf the value of left operand is greater than the value of right operand, then condition becomes true.\t*(a > b) is not true.*\n",
  56     "\n",
  57     "\"<\": If the value of left operand is less than the value of right operand, then condition becomes true.\t*(a < b) is true.*\n",
  58     "\n",
  59     "\">=\":\tIf the value of left operand is greater than or equal to the value of right operand, then condition becomes true.\t*(a >= b) is not true.*\n",
  60     "\n",
  61     "\"<=\":\tIf the value of left operand is less than or equal to the value of right operand, then condition becomes true.\t*(a <= b) is true.*\n",
  62     "\n",
  63     "We can use **and** and **or** to combine sets of comparison operators and **not** to negate a statement. \n",
  64     "\n",
  65     "Try changing different values of `x` in the code snippets below and see what happens."
  66    ]
  67   },
  68   {
  69    "cell_type": "code",
  70    "execution_count": null,
  71    "metadata": {
  72     "id": "sLnaOL497Ry4"
  73    },
  74    "outputs": [],
  75    "source": [
  76     "x = 1.3 # Try different values\n",
  77     "\n",
  78     "if x >= 0 and not(x == 2 or x == 3):\n",
  79     "    f = np.power(x,.5)/((x-2.0)*(x-3.0))\n",
  80     "    print( f )\n",
  81     "elif x < 0:\n",
  82     "    print( 'Square root of negative number' )\n",
  83     "    f = np.nan\n",
  84     "elif x == 2.0:\n",
  85     "    print( 'Division by zero with different limits' )\n",
  86     "    f = np.nan"
  87    ]
  88   },
  89   {
  90    "cell_type": "markdown",
  91    "metadata": {
  92     "id": "sgeBfQnlNi4D"
  93    },
  94    "source": [
  95     "nan is a special value to signal the result of an invalid operation:"
  96    ]
  97   },
  98   {
  99    "cell_type": "code",
 100    "execution_count": null,
 101    "metadata": {
 102     "id": "-rBzNQEMN59I"
 103    },
 104    "outputs": [],
 105    "source": [
 106     "a = np.float('inf')\n",
 107     "b = a - a\n",
 108     "print(b) "
 109    ]
 110   },
 111   {
 112    "cell_type": "markdown",
 113    "metadata": {
 114     "id": "2UYghRWEPq2d"
 115    },
 116    "source": [
 117     "Note that nan does not equal to anything, not even itself!"
 118    ]
 119   },
 120   {
 121    "cell_type": "markdown",
 122    "metadata": {
 123     "id": "Mb7Pb2nY7Ry4"
 124    },
 125    "source": [
 126     "## Mini-exercise 1\n",
 127     "\n",
 128     "Complete the code below to evaluate\n",
 129     "$$\n",
 130     "    f(x) = \\begin{cases}\n",
 131     "                1 + x, & x\\in[-1,0], \\\\\n",
 132     "                1 - x, & x\\in(0, 1], \\\\\n",
 133     "                0, & \\text{else}.\n",
 134     "            \\end{cases}\n",
 135     "$$"
 136    ]
 137   },
 138   {
 139    "cell_type": "code",
 140    "execution_count": null,
 141    "metadata": {
 142     "id": "mp7duS5g7Ry5"
 143    },
 144    "outputs": [],
 145    "source": [
 146     "x = -.25 # Try different values\n",
 147     "\n",
 148     "if -1 <= x and :\n",
 149     "    f = \n",
 150     "elif :\n",
 151     "    f = \n",
 152     "else: \n",
 153     "    f = \n",
 154     "    \n",
 155     "print(f)"
 156    ]
 157   },
 158   {
 159    "cell_type": "markdown",
 160    "metadata": {
 161     "id": "mc7hbS_y7Ry5"
 162    },
 163    "source": [
 164     "## Functions in Python (Motivation) \n",
 165     "In the code snippets above, a value of `x` serves as the input into a conditional statement that determines what output value `f` should be assigned based on the value of `x`. If we wish to use this functionality many times in the code, we would probably like to avoid writing the if/elif/else structure at each point where it is to be used for a variety of reasons including, but not limited to, the following:\n",
 166     "\n",
 167     "- If we ever decide to change how `f` is computed, then we would have to find/replace every instance of it within the code (likely leading to errors, or worse yet, code that does not crash but gives wrong outputs).\n",
 168     "\n",
 169     "- Even the most terse scientific code can easily become hundreds (if not thousands) of lines long, and we want to avoid making the code more difficult to read, use, and debug than is absolutely necessary. \n",
 170     "\n",
 171     "This motivates the development of user-defined functions in Python. The basic syntax is shown below.\n",
 172     "\n",
 173     "```\n",
 174     "def functionname( parameters ):\n",
 175     "   \"\"\"function_docstring\"\"\"\n",
 176     "   function_suite\n",
 177     "   return [expression]\n",
 178     "```"
 179    ]
 180   },
 181   {
 182    "cell_type": "markdown",
 183    "metadata": {
 184     "id": "Ydlx0oxj7Ry5"
 185    },
 186    "source": [
 187     "### A brief discussion on docstrings and commenting in code\n",
 188     "The (triple) quotes is where you put in a documentation string for your function.  It is entirely optional, but it is always a good idea to document your code even when it is entirely in the developmental/testing phase. There are some best practices that you can read about at https://docs.python.org/devguide/documenting.html or http://docs.python-guide.org/en/latest/writing/documentation/. \n",
 189     "\n",
 190     "Good tools such as Sphinx http://www.sphinx-doc.org/en/1.4.8/ can turn properly documented code into easy to read/navigate html files to help expand the community of users for any code you develop. For example, see http://ut-chg.github.io/BET/ where Sphinx was used to generate the documentation. These tools are outside the scope of this tutorial, but we highly recommend that you learn a bit about them before attemping to make very sophisticated software packages. "
 191    ]
 192   },
 193   {
 194    "cell_type": "markdown",
 195    "metadata": {
 196     "id": "gKOkw45i7Ry6"
 197    },
 198    "source": [
 199     "### parameters and keyword arguments in a function\n",
 200     "Notice that in the definition of the function, there is a `parameters` variable, which is often a list of parameters (as shown below). These are normally ordered **UNLESS** you supplement them with *keyword args* in the function call (i.e., when you actually use the function you may specify which argument corresponds to which parameter).  \n",
 201     "The next few code snippet illustrates this."
 202    ]
 203   },
 204   {
 205    "cell_type": "code",
 206    "execution_count": null,
 207    "metadata": {
 208     "id": "zRuLDNcD7Ry6"
 209    },
 210    "outputs": [],
 211    "source": [
 212     "def myfun1(x,y):\n",
 213     "    if x < y:\n",
 214     "        z = x + 2*y\n",
 215     "    else:\n",
 216     "        z = x - 2*y\n",
 217     "    return z"
 218    ]
 219   },
 220   {
 221    "cell_type": "code",
 222    "execution_count": null,
 223    "metadata": {
 224     "id": "wjWARWJG7Ry6"
 225    },
 226    "outputs": [],
 227    "source": [
 228     "print( myfun1(2,3) )"
 229    ]
 230   },
 231   {
 232    "cell_type": "code",
 233    "execution_count": null,
 234    "metadata": {
 235     "id": "-3PI8qG47Ry7"
 236    },
 237    "outputs": [],
 238    "source": [
 239     "print( myfun1(2.0,3.0) )"
 240    ]
 241   },
 242   {
 243    "cell_type": "code",
 244    "execution_count": null,
 245    "metadata": {
 246     "id": "qsddAV8t7Ry7"
 247    },
 248    "outputs": [],
 249    "source": [
 250     "print( myfun1(3.0,2.0) ) #switching order of inputs"
 251    ]
 252   },
 253   {
 254    "cell_type": "code",
 255    "execution_count": null,
 256    "metadata": {
 257     "id": "tbN2OfgN7Ry7"
 258    },
 259    "outputs": [],
 260    "source": [
 261     "print( myfun1(x=2,y=3.0) ) #keyword argument"
 262    ]
 263   },
 264   {
 265    "cell_type": "code",
 266    "execution_count": null,
 267    "metadata": {
 268     "id": "reJ_p3OS7Ry7"
 269    },
 270    "outputs": [],
 271    "source": [
 272     "print( myfun1(y=3.0,x=2.0) ) #switching the order of inputs of keyword arguments does nothing"
 273    ]
 274   },
 275   {
 276    "cell_type": "code",
 277    "execution_count": null,
 278    "metadata": {
 279     "id": "3sPqNB4d7Ry7"
 280    },
 281    "outputs": [],
 282    "source": [
 283     "# Try printing myfun1(x=2,3.0). \n",
 284     "\n",
 285     "print( myfun1(x=2,3.0) )\n",
 286     "\n",
 287     "# The take home message? \n",
 288     "# Once you commit to using keywords in a function call, \n",
 289     "# then you better be all in."
 290    ]
 291   },
 292   {
 293    "cell_type": "code",
 294    "execution_count": null,
 295    "metadata": {
 296     "id": "W1b9fA5i7Ry8"
 297    },
 298    "outputs": [],
 299    "source": [
 300     "print( myfun1('silly ','test') )"
 301    ]
 302   },
 303   {
 304    "cell_type": "code",
 305    "execution_count": null,
 306    "metadata": {
 307     "id": "Fmaao6zV7Ry8"
 308    },
 309    "outputs": [],
 310    "source": [
 311     "z = myfun1(2,3)\n",
 312     "print( z )"
 313    ]
 314   },
 315   {
 316    "cell_type": "markdown",
 317    "metadata": {
 318     "id": "0lr7DblQ7Ry8"
 319    },
 320    "source": [
 321     "Obviously Python does not use type-checking for functions, but it allows useful types of polymorphism.\n",
 322     "\n",
 323     "Python also allows to set defaults within the parameter list of a function call.  Let's tweak `myfun1` a little.\n",
 324     "\n",
 325     "Defaults need to **come after** functions parameters with non-default values."
 326    ]
 327   },
 328   {
 329    "cell_type": "code",
 330    "execution_count": null,
 331    "metadata": {
 332     "id": "V0fmd8bM7Ry9"
 333    },
 334    "outputs": [],
 335    "source": [
 336     "def myfun2(x=1,y=2):\n",
 337     "    if x<y:\n",
 338     "        z = x + 2*y\n",
 339     "    else:\n",
 340     "        z = x - 2*y\n",
 341     "    return z"
 342    ]
 343   },
 344   {
 345    "cell_type": "code",
 346    "execution_count": null,
 347    "metadata": {
 348     "id": "t1-p00wP7Ry9",
 349     "scrolled": true
 350    },
 351    "outputs": [],
 352    "source": [
 353     "print( myfun2() )\n",
 354     "print( myfun2(1.0) )\n",
 355     "print( myfun2(y=3) )"
 356    ]
 357   },
 358   {
 359    "cell_type": "markdown",
 360    "metadata": {
 361     "id": "Ct3aGTUN7Ry9"
 362    },
 363    "source": [
 364     "**We can even pass the output of a function to another function!**"
 365    ]
 366   },
 367   {
 368    "cell_type": "code",
 369    "execution_count": null,
 370    "metadata": {
 371     "id": "gsphIvVU7Ry9"
 372    },
 373    "outputs": [],
 374    "source": [
 375     "print( myfun1( myfun2(), myfun2(y=3) ) )"
 376    ]
 377   },
 378   {
 379    "cell_type": "markdown",
 380    "metadata": {
 381     "id": "flQ3Y8kIRFkd"
 382    },
 383    "source": [
 384     "is the same as"
 385    ]
 386   },
 387   {
 388    "cell_type": "code",
 389    "execution_count": null,
 390    "metadata": {
 391     "id": "NK4_9jO1Q8mH"
 392    },
 393    "outputs": [],
 394    "source": [
 395     "a = myfun2()\n",
 396     "b = myfun2(y=3)\n",
 397     "print( myfun1( a, b ) )"
 398    ]
 399   },
 400   {
 401    "cell_type": "markdown",
 402    "metadata": {
 403     "id": "QzP8GGw07Ry9"
 404    },
 405    "source": [
 406     "## Mini-exercise 2\n",
 407     "\n",
 408     "Complete the code below that either converts a temperature given in Celsius to Fahrenheit, a temperature given in Fahrenheit to Celsius, or if two temperatures are given (one in Celsius and one in Fahrenheit) will check if they are the same."
 409    ]
 410   },
 411   {
 412    "cell_type": "code",
 413    "execution_count": null,
 414    "metadata": {
 415     "colab": {
 416      "base_uri": "https://localhost:8080/",
 417      "height": 132
 418     },
 419     "id": "PuuNBNdU7Ry-",
 420     "outputId": "39079b42-99db-4e8b-97d3-cd6a5936c102"
 421    },
 422    "outputs": [],
 423    "source": [
 424     "def tempFunc(F=None, C=None):\n",
 425     "    if F == None and C == None:\n",
 426     "        print('You want nothing?')\n",
 427     "    elif F == None: #So C is given\n",
 428     "        print( str(C) + ' Celsius = ' \n",
 429     "              + str(C * 9/5 + 32) + ' Fahrenheit' )\n",
 430     "    elif : #So F is given\n",
 431     "        print( )\n",
 432     "    else: #So F and C are both given\n",
 433     "        if np.abs(F - (C*9/5+32)) < np.finfo(np.float32).eps:\n",
 434     "            print('Those temperatures are the same!')\n",
 435     "        else:\n",
 436     "            print('Those temperatures are different!')"
 437    ]
 438   },
 439   {
 440    "cell_type": "code",
 441    "execution_count": null,
 442    "metadata": {
 443     "id": "3B68cpRh7Ry-"
 444    },
 445    "outputs": [],
 446    "source": [
 447     "tempFunc(F=212, C = 100)\n",
 448     "tempFunc(C = 100)"
 449    ]
 450   },
 451   {
 452    "cell_type": "markdown",
 453    "metadata": {
 454     "id": "cMXndh-u7Ry-"
 455    },
 456    "source": [
 457     "## Python uses passing by reference OR passing by value\n",
 458     "\n",
 459     "First, we want to say that it is okay if this does not make perfect sense the first (ten) time(s) you work through this. \n",
 460     "For more information on this, we encourage you to do some searching online (the answers provided here: https://stackoverflow.com/questions/373419/whats-the-difference-between-passing-by-reference-vs-passing-by-value are a good place to start) and playing around with the simple code below to build intuition.\n",
 461     "***Basically, there is very little substitute for some time and patience in learning this correctly. Here, we seek to just build some basic intuition about what is going on so that you can be aware of some potential pitfalls.***\n",
 462     "\n",
 463     "### If you know C or C++...\n",
 464     "Passing by reference is similar passing a pointer to a variable instead of copying the value of the variable. But in Python, passing by reference can occur without creating the pointer explicitly, as it is done in C or C++. \n",
 465     "\n",
 466     "### Metaphorically speaking...\n",
 467     "Passing by reference or by value frequently occurs in calling functions. Suppose you are the function and I am passing you information metaphorically in terms of information written on paper:\n",
 468     "\n",
 469     "   * Call by value is where I copy something from one piece of paper onto another piece of paper and hand the copy to you. Maybe the information includes that `x=5`. This information is now on a piece of paper which I have given to you, so now it is effectively your piece of paper. You are now free to write on that piece of paper to use that information however you please. Maybe you decide to act upon this information by multiplying the variable `x` by 2, so that you write that now `x=10` on your piece of paper. Suppose you return that piece of paper to me. Does this change what was written on my piece of paper? No! However, I may choose to use your information to then update the information on my original paper.\n",
 470     "   \n",
 471     "   * Call by reference is when I give you my original paper which has something written down in it like `x=5`. Now, if you decide that the value of `x` should be double so that you erase and replace `x=5` with `x=10` and then give me the paper back, my paper now contains this updated information about `x` regardless if I wanted it to or not. I guess if I did not want that information to be there, then I should have passed by value.\n",
 472     "\n",
 473     "### Technically speaking...\n",
 474     "####  *Passing by reference*\n",
 475     "This means Python passes the reference to the variable, not just the value.  This can cause some different behavior when certain *in place* operators are used.  Classes, numpy arrays, etc. are passed by reference.\n",
 476     "\n",
 477     "#### *Passing by value* \n",
 478     "This means Python passes the value and creates a new copy. Variables that are strings, floats, and ints are passed by value (*they are immutable data types* meaning that the value is left unchanged).\n",
 479     "\n",
 480     "Python variables created within a function also have local *scope*.\n",
 481     "- *scope* usually refers to the visibility of variables. In other words, which parts of your program can see or use it.  ***Local scope*** means visible only within the function. "
 482    ]
 483   },
 484   {
 485    "cell_type": "code",
 486    "execution_count": null,
 487    "metadata": {
 488     "id": "vFjx8bOi7Ry-"
 489    },
 490    "outputs": [],
 491    "source": [
 492     "def scope_test(var):\n",
 493     "    print()\n",
 494     "    print( 'The variable passed to scope_test is ' +\n",
 495     "           '\\n var = ', var)\n",
 496     "    var *= 4 #if var is mutable, replaces in place (pass-by-reference) by var*4\n",
 497     "    print()\n",
 498     "    print( 'Within scope_test, the passed variable is ' +\n",
 499     "          'changed to \\n var = ', var)\n",
 500     "    a = 3\n",
 501     "    print()\n",
 502     "    print('Within scope_test, we set the variable \\n a =', a)\n",
 503     "    return"
 504    ]
 505   },
 506   {
 507    "cell_type": "code",
 508    "execution_count": null,
 509    "metadata": {
 510     "id": "YUuo05L07Ry_"
 511    },
 512    "outputs": [],
 513    "source": [
 514     "a = 2 #An integer is an immutable data type\n",
 515     "\n",
 516     "print( 'Before scope_test,\\n a =', a )\n",
 517     "scope_test(a)\n",
 518     "print()\n",
 519     "print( 'After scope_test,\\n a =', a )"
 520    ]
 521   },
 522   {
 523    "cell_type": "markdown",
 524    "metadata": {
 525     "id": "EnI57L8WWXqu"
 526    },
 527    "source": [
 528     "You see that even if variable a was passed to the function and changed inside, and a variable with the same name a was referred to in the function, the value of the variable a outside of the function **did not change**. This happened because the variable a was integer, which is in Python **immutable** (like a constant). But numpy arrays behave differently."
 529    ]
 530   },
 531   {
 532    "cell_type": "code",
 533    "execution_count": null,
 534    "metadata": {
 535     "id": "BRSCU1JN7Ry_"
 536    },
 537    "outputs": [],
 538    "source": [
 539     "a = np.ones([2,2]) # numpy arrays are mutable\n",
 540     "\n",
 541     "print( 'Before scope_test, \\n a =', a )\n",
 542     "scope_test(a)\n",
 543     "print()\n",
 544     "print( 'After scope_test, \\n a =', a )"
 545    ]
 546   },
 547   {
 548    "cell_type": "code",
 549    "execution_count": null,
 550    "metadata": {
 551     "id": "KKrrjJ4n7Ry_"
 552    },
 553    "outputs": [],
 554    "source": [
 555     "a = np.ones([2,2]) # numpy arrays are mutable\n",
 556     "\n",
 557     "print( 'Before scope_test, \\n a =', a )\n",
 558     "scope_test(2*a)\n",
 559     "print()\n",
 560     "print( 'After scope_test(2*a), \\n a =', a )"
 561    ]
 562   },
 563   {
 564    "cell_type": "markdown",
 565    "metadata": {
 566     "id": "6gnwRcrt7Ry_"
 567    },
 568    "source": [
 569     "### Wait a minute...\n",
 570     "\n",
 571     "What if I want to do local work to a *mutable* data type (i.e. a numpy array) but not have the change reflected back after function exit?  \n",
 572     "\n",
 573     "The answer is to ***not*** use *in place* operators like +=, \\*=, etc.  `var = var*2` creates a local copy of var and multiplies by 2 every entry."
 574    ]
 575   },
 576   {
 577    "cell_type": "code",
 578    "execution_count": null,
 579    "metadata": {
 580     "id": "kNGYu7TJ7Ry_"
 581    },
 582    "outputs": [],
 583    "source": [
 584     "def scope_test2(var):\n",
 585     "    var = var * 2  #if mutable, creates local copy of var.\n",
 586     "    print('Inside scope_test2,\\n',var)\n",
 587     "    return "
 588    ]
 589   },
 590   {
 591    "cell_type": "code",
 592    "execution_count": null,
 593    "metadata": {
 594     "colab": {
 595      "base_uri": "https://localhost:8080/"
 596     },
 597     "id": "jFAWgBT07RzA",
 598     "outputId": "0c160997-9676-4c21-a8ae-26c22dc05f18"
 599    },
 600    "outputs": [],
 601    "source": [
 602     "a = np.eye(3) # creates 3x3 array with a_ii = 1, 0 otherwise.\n",
 603     "print('Before scope_test2,\\n a =', a)\n",
 604     "scope_test2(a)\n",
 605     "print()\n",
 606     "print('After scope_test2,\\n a =', a)"
 607    ]
 608   },
 609   {
 610    "cell_type": "markdown",
 611    "metadata": {
 612     "id": "f3kpFsvV7RzA"
 613    },
 614    "source": [
 615     "## Looping in Python\n",
 616     "\n",
 617     "### For loops\n",
 618     "\n",
 619     "**Syntax** \n",
 620     "```\n",
 621     "for iterator in list:\n",
 622     "    #indent for the loop\n",
 623     "    #do cool stuff in the loop\n",
 624     "#noindent to close the loop'\n",
 625     "```\n",
 626     "The list can be strings, for example:\n",
 627     "```\n",
 628     "for string in ('Alpha','Romeo','Sailor','Foxtrot'):\n",
 629     "    #string takes on values 'Alpha', 'Romeo', etc. in order.\n",
 630     "    print string\n",
 631     "```\n",
 632     "    \n",
 633     "\n",
 634     "You will commonly use the ``range`` command to build lists of numbers for iterating (see https://docs.python.org/3/library/functions.html#func-range).\n",
 635     "\n",
 636     "**SYNTAX** \n",
 637     "```\n",
 638     "range(stop)  #assumes start=0\n",
 639     "range(start, stop[, step])\n",
 640     "```\n",
 641     "\n",
 642     "Note that it **DOES NOT** execute the stop value.\n",
 643     "\n",
 644     "Let's  sum the first 20 terms of the geometric series corresponding to $2^{-n}$"
 645    ]
 646   },
 647   {
 648    "cell_type": "code",
 649    "execution_count": null,
 650    "metadata": {
 651     "colab": {
 652      "base_uri": "https://localhost:8080/"
 653     },
 654     "id": "VSSaHx817RzA",
 655     "outputId": "99cd8174-90b4-42d8-b94f-368341b47e10"
 656    },
 657    "outputs": [],
 658    "source": [
 659     "# You may want to create a new code block above this one to print out what the range function is doing\n",
 660     "\n",
 661     "partial_sum = 0\n",
 662     "for n in range(20):   #identical to range(0,20) or range(0,20,1)\n",
 663     "    partial_sum += 2**(-n)\n",
 664     "    print( 'Sum from n=0 to ' + str(n) + ' of 2^{-n} = ', partial_sum )"
 665    ]
 666   },
 667   {
 668    "cell_type": "code",
 669    "execution_count": null,
 670    "metadata": {
 671     "colab": {
 672      "base_uri": "https://localhost:8080/"
 673     },
 674     "id": "ozMNxBrD7RzA",
 675     "outputId": "c607ba0d-3c23-477d-8ffd-f8dbad39571b"
 676    },
 677    "outputs": [],
 678    "source": [
 679     "print( 'Now start subtracting from the sum' )\n",
 680     "    \n",
 681     "for n in range(19,-1,-1): \n",
 682     "    partial_sum -= 2**(-n)  \n",
 683     "    print( 'Sum from n=0 to ' + str(n-1) + ' of 2^{-n} = ', partial_sum )"
 684    ]
 685   },
 686   {
 687    "cell_type": "markdown",
 688    "metadata": {
 689     "id": "cQKO5rcD7RzA"
 690    },
 691    "source": [
 692     "### While loops \n",
 693     "\n",
 694     "We often use ***while*** loops for iterative methods, such as fixed-point iterations. These are typically used when we are unsure exactly how many iterations a process should take.\n",
 695     "\n",
 696     "```\n",
 697     "while condition:   #this condition is true\n",
 698     "    do something cool\n",
 699     "    update condition, or use break or continue for loop control\n",
 700     "#no indent as at end of loop\n",
 701     "```\n",
 702     "If the the ``condition`` never becomes false, then this will result in an infinite loop, so be careful. It is therefore fairly common practice to include some type of counter which tracks the number of iterations, and negating the condition if the counter reaches a specified value.\n",
 703     "\n",
 704     "You can also exit from any for loop by using ``break`` to exit the innermost loop, and ``continue`` to continue to the next iteration of this loop\n",
 705     "\n",
 706     "Let's look at an example where we are trying to iterate a logistic equation \n",
 707     "$$\n",
 708     "    x_{n+1}=a\\cdot x_n (1-x_n)\n",
 709     "$$\n",
 710     "until we arrive at a fixed point."
 711    ]
 712   },
 713   {
 714    "cell_type": "code",
 715    "execution_count": null,
 716    "metadata": {
 717     "colab": {
 718      "base_uri": "https://localhost:8080/"
 719     },
 720     "id": "a9S4BAC67RzB",
 721     "outputId": "6ef072be-9722-43fc-fd7c-621dd9610e28"
 722    },
 723    "outputs": [],
 724    "source": [
 725     "import math as m\n",
 726     "\n",
 727     "a = 2.0\n",
 728     "xnew = .1\n",
 729     "tol = 1E-8\n",
 730     "doit = True  #boolean True and False \n",
 731     "it = 1\n",
 732     "while doit and it <= 5:\n",
 733     "    it += 1\n",
 734     "    xold = xnew\n",
 735     "    xnew *= a * (1-xnew)\n",
 736     "    if m.fabs(xnew-xold) > tol:\n",
 737     "        print('Iterating, X = ', xnew)\n",
 738     "        continue  #play it again, Sam\n",
 739     "    else:\n",
 740     "        break\n",
 741     "    print('This is skipped if the continue command is not commented out above.')\n",
 742     "print(\"Fixed Point=\",xnew)"
 743    ]
 744   }
 745  ],
 746  "metadata": {
 747   "anaconda-cloud": {},
 748   "colab": {
 749    "collapsed_sections": [],
 750    "name": "02-Python-functions-modules.ipynb",
 751    "provenance": []
 752   },
 753   "kernelspec": {
 754    "display_name": "Python 3",
 755    "language": "python",
 756    "name": "python3"
 757   },
 758   "language_info": {
 759    "codemirror_mode": {
 760     "name": "ipython",
 761     "version": 3
 762    },
 763    "file_extension": ".py",
 764    "mimetype": "text/x-python",
 765    "name": "python",
 766    "nbconvert_exporter": "python",
 767    "pygments_lexer": "ipython3",
 768    "version": "3.8.5"
 769   }
 770  },
 771  "nbformat": 4,
 772  "nbformat_minor": 1
 773 }