003-control-flow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is part of the [G2S3 2019 Python Bootcamp](https://github.com/hpcgarage/pyboot-g2s3).\n",
    "\n",
    "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/hpcgarage/pyboot-g2s3/blob/master/001-vals-vars-ds.ipynb)\n",
    "\n",
    "\n",
    "# Control flow\n",
    "\n",
    "In earlier parts of this bootcamp, \"code\" consists of a linear sequence of statements, and the program executes each line one after the other. But the \"flow\" of execution from one statement to the next need not obey a strict linear path. The term _control flow_ (or control structures, as opposed to data structures) refers to code constructs—like \"if\" statements, \"for\" loops, and \"function calls\"—that cause statements to execute in a nonlinear order.\n",
    "\n",
    "Key concepts:\n",
    "* Functions\n",
    "* Conditionals (`if`-`elif`-`else`; inline `if`-`else`)\n",
    "* For-loops and iterators\n",
    "* While-loops and other loop constructs (`break`, `continue`)\n",
    "\n",
    "For more detailed information, see Vanderplas or the [Python tutorial on control structures](https://docs.python.org/3/tutorial/controlflow.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aside: Assertions\n",
    "\n",
    "With more complex forms of program execution, writing correct programs and debugging incorrect ones becomes much harder. Therefore, we may want to check that variables have certain values or that objects meet certain conditions, or to impose simplifying assumptions on our code so that we can start building working pieces. For example, if you are writing a program to compute $n!$ (the factorial of $n$), perhaps you want to restrict the input values of $n$ that you wish to consider to be non-negative. A useful code construct in that case is an `assert` statement, which has the form,\n",
    "\n",
    "```python\n",
    "    assert boolean_condition, error_string\n",
    "```\n",
    "\n",
    "which does nothing if `boolean_condition` is `True` or, if it is `False`, aborts the execution and prints the message `error_string`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 0  # Try changing `0` to `-3`\n",
    "assert n >= 0, f\"`n` must be non-negative but instead has the value {n}.\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Defining functions.** Consider this example and note the following:\n",
    "- `def` statement, which names the function, declares its arguments, and ends in a `:`\n",
    "- An optional document string, which can be retrieved by \"help\" queries\n",
    "- Indentation: In Python, indentation is significant and strictly enforced. Blocks of code must be indented consistently (see [Lexical analysis](https://docs.python.org/3/reference/lexical_analysis.html) in the Python documentation)\n",
    "- The `return` statement, which specifies the value that the function returns to the caller"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evens(a, b):\n",
    "    \"\"\"Returns a list of even integers in `[a, b)`, given integers `a` and `b`.\"\"\"\n",
    "    assert isinstance(a, int) and isinstance(b, int), \\\n",
    "           f\"One of `a:{type(a)}` or `b:{type(b)}` is not an integer.\"\n",
    "    return [x for x in range(a, b) if (x % 2) == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "?evens"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "evens(-7, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`None` returns.** A function that lacks a return statement still produces a value, namely, `None` (of type `NoneType`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def no_op():\n",
    "    pass\n",
    "\n",
    "print(no_op(), type(no_op()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Functions are objects.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(evens, type(evens))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_two_param_function(fun, x, y):\n",
    "    assert callable(fun), f\"First arg is not callable; it's a {type(fun)}).\"\n",
    "    return fun(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(run_two_param_function(evens, 3, 12))\n",
    "print(run_two_param_function(divmod, 13, 3))  # `divmod` is a built-in function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Anonymous, or _lambda_, functions.** Occasionally, you need to define a short, single-use function that returns a value. In such cases, the `lambda` construct gives you a succint way to do so.\n",
    "\n",
    "In this first example, the `lambda` defines a two-parameter function that, given arguments named $x$ and $y$, returns $2x - y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "run_two_param_function(lambda x, y: 2*x - y,\n",
    "                       7, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is another example. First, consider Python's built-in [`sorted` function](https://docs.python.org/3/howto/sorting.html), which returns a sorted instance of an input collection."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted([8, 3, 2, -7, 10, 11, 4, 1 -4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, suppose our list has more complex values, like this list of dictionaries:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = [{'first':'Guido', 'last':'Van Rossum', 'YOB':1956},\n",
    "        {'first':'Grace', 'last':'Hopper',     'YOB':1906},\n",
    "        {'first':'Alan',  'last':'Turing',     'YOB':1912}]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Suppose we wish to sort this list by year-of-birth. The `sorted` function takes an optional parameter that allows us to define the sort key. The key is given by a function that, given a list element, returns the value to use for sorting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sorted(data, key=lambda x: x['YOB'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Conceptually, the following are equivalent:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_year_of_birth__v1(x):\n",
    "    return x['YOB']\n",
    "\n",
    "get_year_of_birth__v2 = lambda x: x['YOB']\n",
    "\n",
    "print(get_year_of_birth__v1(data[0]),\n",
    "      get_year_of_birth__v2(data[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Under the hood, these are not equivalent. In particular, the lambda function has no _name_. When debugging and tracing through a program, it may be harder to know where you are."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def a_girl_has_a_name():\n",
    "    return None\n",
    "    \n",
    "print(a_girl_has_a_name.__name__, ':', type(a_girl_has_a_name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a_girl_has_no_name = lambda: None\n",
    "\n",
    "print(a_girl_has_no_name.__name__, ':', type(a_girl_has_no_name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Default arguments.** The `sorted` example was a function that took an _optional_ parameter, which allowed you to customize the key. Your functions can have a similar feature if you supply _default_ arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mul_add_pow(base, factor=1, offset=0, power=1):\n",
    "    \"\"\"`mul_add_pow(b, f, o, p)`: returns `(b*f + o)**p`.\"\"\"\n",
    "    return (base*factor + offset)**power\n",
    "\n",
    "print(mul_add_pow(5))              # (5*1 + 0)**1\n",
    "print(mul_add_pow(5, 2, 3))        # (5*2 + 3)**1\n",
    "print(mul_add_pow(5, 2, power=2))  # (5*2 + 0)**2\n",
    "print(mul_add_pow(5, 2, 4, -1))    # (5*2 + 4)**(-1) ~ 0.07\n",
    "print(mul_add_pow(5, power=-1, factor=2, offset=4))  # Same as above; named args in any order"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Order of arguments: Optional arguments must appear _after_ required arguments. At the call-site, unnamed optional arguments are assigned in the order of the definition; named arguments must appear after unnamed arguments, but may appear in any order."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Flexible arguments.** Per the note above, you can think of the arguments to a function as being two groups: _required arguments_, which do not have names, and _optional arguments_, which are named. Indeed, you can write functions where you do not know these in advance but leave placeholders for them:\n",
    "\n",
    "```python\n",
    "    def func(*req, **opt):\n",
    "        ...\n",
    "```\n",
    "\n",
    "These are available in the body of the function as a tuple (`req`) and dictionary (`opt`), as the next example illustrates."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def catch_all(*req, **opt):\n",
    "    print(\"req =\", req)\n",
    "    print(\"opt = \", opt)\n",
    "    return list(req) + list(opt.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "catch_all(1, 2, 3, a=4, b=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "catch_all('a', keyword=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "inputs = (1, 2, 3)\n",
    "keywords = {'pi': 3.14}\n",
    "catch_all(*inputs, **keywords)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Variable scoping.** Like most other languages, there is a notion of the _scope_ of a variable, which refers to what parts of the program is a variable name visible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(y):\n",
    "    print(y + z_outside)  # `z` must refer to a global variable\n",
    "\n",
    "z_outside = 2\n",
    "foo(-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bar(x):  # \"Hides\" any global `x`\n",
    "    x = x**3\n",
    "    print(x)\n",
    "\n",
    "x = 5\n",
    "bar(2)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def baz(x):  # \"Hides\" any global `x`\n",
    "    global x_global\n",
    "    x_global = x**3\n",
    "    print(x)\n",
    "    \n",
    "x_global = 5\n",
    "baz(2)\n",
    "print(x_global)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Modifying arguments.** If an argument is a mutable type, the function can change it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_nothing(s):\n",
    "    assert isinstance(s, int) # recall: `int` is immutable\n",
    "    s += 3\n",
    "    print('add_nothing:', s)\n",
    "    \n",
    "s0 = 5\n",
    "add_nothing(s0)\n",
    "print(s0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_abcs(s):\n",
    "    assert isinstance(s, list) # recall: `list` is mutable\n",
    "    s += ['a', 'b', 'c']\n",
    "    print('add_abcs:', s)    \n",
    "    \n",
    "s1 = [1, 2, 3]\n",
    "add_abcs(s1)\n",
    "print(s1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Nesting functions.** You can also enclose a function definition within a function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_dict_by_key(d, k):\n",
    "    def get_key(x):\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals\n",
    "\n",
    "Your basic `if-then-else` statement. `:D`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = -15   # Try `float('nan')`, `float('inf')`\n",
    "\n",
    "if x == 0:\n",
    "    print(x, \"is zero\")\n",
    "elif x > 0:\n",
    "    print(x, \"is positive\")\n",
    "elif x < 0:\n",
    "    print(x, \"is negative\")\n",
    "else:\n",
    "    print(x, \"is unlike anything I've ever seen...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For short conditionals, there is also an \"inline\" version (`if`-`else` only, though these can be nested):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 5, 10\n",
    "msg = 'lt' if a < b else 'geq'\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = 10, 10\n",
    "msg = 'lt' if a < b else ('gt' if a > b else 'eq')\n",
    "print(msg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "There are two main types of loops: `for` loops and `while` loops."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`for` loops.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for N in [2, 3, 5, 7]:\n",
    "    print(N, end=' ') # print all on same line"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Other common iterators.** The subexpression to the right of the `in`, above, should be an _iterator_, which is a special type of object that produces a sequence of values. Indeed, what you see above is actually a shortcut for the following:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "I = iter([2, 3, 5, 7])\n",
    "print(I, \"\\n\")\n",
    "\n",
    "for N in I:\n",
    "    print(N, end=' ') # print all on same line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(range(10), \"\\n\")\n",
    "\n",
    "for i in range(10):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Aside:** An iterator can be converted into an argument tuple using the `*i` syntax you saw above under the section on functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(*range(5))  # same as print(0, 1, 2, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`enumerate(x)`**: an iterator that produces the elements of `x` along with a \"running count\" that starts at 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i, s in enumerate('alsdfkj'):\n",
    "    print(f'{i}: {s}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`zip`**: an iterator that produces tuples of elements taken from its input iterators."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for a, b in zip(range(3), ['a', 'b', 'c']):\n",
    "    print(a, \"=>\", b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> This example suggests that a possible implementation of `enumerate(x)` is\n",
    ">\n",
    "> ```python\n",
    ">     def enumerate(x):\n",
    ">         return zip(range(len(x)), x)\n",
    "> ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`map`**: an iterator that first applies a given function to each value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find the first 10 square numbers\n",
    "square = lambda x: x ** 2\n",
    "for val in map(square, range(10)):\n",
    "    print(val, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`filter`**: an iterator that only yields values for which a given predicate function evalutes to `True`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# find values up to 10 for which x % 2 is zero\n",
    "is_even = lambda x: x % 2 == 0\n",
    "print(is_even(4), is_even(7), \"\\n\")\n",
    "\n",
    "for val in filter(is_even, range(10)):\n",
    "    print(val, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`itertools` and generators**. There are many other interesting iterators; see the [`itertools`](https://docs.python.org/3/library/itertools.html) module for a bunch more, as well as the [Python Functional Programming How-To](https://docs.python.org/3/howto/functional.html) for how to create your own iterators.\n",
    "\n",
    "Here is one example from `itertools`: producing combinations of a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "zoo = {'cat', 'dog', 'emu', 'zebra'}  # a set of animals\n",
    "\n",
    "from itertools import combinations    # Try also: `permutations`\n",
    "for x in combinations(zoo, 3):      \n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Set iterators.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for s in {1, 2, 3}:\n",
    "    print(s, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Iterating over dictionaries.** By default, using a dictionary as the iterator will yield keys. To get values or key-value pairs, use `.values()` and `.items()`, respectively."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D = {k: v for v, k in enumerate('abcdef')}\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in D:             # or, `for k in D.keys(): ...`\n",
    "    print(k, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for v in D.values():\n",
    "    print(v, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"==> Version 1:\")\n",
    "for p in D.items(): # (key, value) pairs\n",
    "    print(p, end=' ')\n",
    "    \n",
    "print(\"\\n==> Version 2:\")\n",
    "for k, v in D.items(): # Unpack the pairs into `k` and `v` variables\n",
    "    print(f'{k}:{v}', end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`while` loops.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i, end=' ')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**`break` and `continue`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print odd integers in [0, 20)\n",
    "for n in range(20):\n",
    "    if n % 2 == 0:\n",
    "        continue\n",
    "    print(n, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Print Fibonacci sequence for values <= 100\n",
    "a, b = 0, 1\n",
    "amax = 100\n",
    "L = []\n",
    "\n",
    "while True:\n",
    "    (a, b) = (b, a + b)\n",
    "    if a > amax:\n",
    "        break\n",
    "    L.append(a)\n",
    "\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}