04-control-flow-in-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming and Data Analysis\n",
    "\n",
    "> Control Flow in Python.\n",
    "\n",
    "Kuo, Yao-Jen <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control Flow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is control flow?\n",
    "\n",
    "> In computer science, control flow (or flow of control) is the order in which individual statements, instructions or function calls of an imperative program are executed or evaluated. The emphasis on explicit control flow distinguishes an imperative programming language from a declarative programming language.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Control_flow>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Control flow in short\n",
    "\n",
    "- Conditional executions\n",
    "- Iterations\n",
    "    - `while` loop\n",
    "    - `for` loop\n",
    "- Handling exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional Executions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a conditional execution?\n",
    "\n",
    "> In computer science, conditional statements are features of a programming language, which perform different computations or actions depending on whether a programmer-specified boolean condition evaluates to true or false.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Conditional_(computer_programming)>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use condition and indentation to create a conditional execution\n",
    "\n",
    "- A condition is an expression that can be evaluated as `bool`.\n",
    "- Indentation is necessary since Python does not use curly braces for code blocks.\n",
    "\n",
    "```python\n",
    "if CONDITION:\n",
    "    # statements to be executed if CONDITION is evaluated as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Most programming languages use braces `{ }` to define a code block\n",
    "\n",
    "- Python, however, uses **indentation**.\n",
    "- A code block starts with indentation and ends with the first unindented line.\n",
    "- The amount of indentation is flexible, but it must be consistent throughout that block."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use relational or logical operators to produce a `bool` for condition\n",
    "\n",
    "- `==`, `!=`, `>`, `<`, `>=`, `<=`, `in`, `not in`\n",
    "- `and`, `or`, `not`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `if` for conditional executions\n",
    "\n",
    "```python\n",
    "if CONDITION:\n",
    "    # statements to be executed if CONDITION is evaluated as True.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use a code-visualization tool to help you understand the behavior of conditional executions\n",
    "\n",
    "We can use [pythontutor.com](https://www.pythontutor.com) to explore the execution of our code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "def return_msg_if_positive(x: int) -> str:\n",
    "    if x > 0:\n",
    "        return \"{} is positive.\".format(x)\n",
    "\n",
    "print(return_msg_if_positive(5566))\n",
    "print(return_msg_if_positive(-5566))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `if` and `else` to perform alternative executions\n",
    "\n",
    "Since the condition must be true or false, exactly one of the alternatives will run.\n",
    "\n",
    "```python\n",
    "if CONDITION:\n",
    "    # statements to be executed if CONDITION is evaluated as True.\n",
    "else:\n",
    "    # statements to be executed if CONDITION is evaluated as False.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is not positive.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_or_not(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = \"{} is positive.\".format(x)\n",
    "    else:\n",
    "        msg = \"{} is not positive.\".format(x)\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_or_not(5566))\n",
    "print(return_msg_whether_positive_or_not(-5566))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `if`, `elif`, and `else` to perform chained conditionals\n",
    "\n",
    "The `else` clause makes our conditionals collectively exhaustive.\n",
    "\n",
    "```python\n",
    "if CONDITION_A:\n",
    "    # statements to be executed if CONDITION_A is evaluated as True.\n",
    "elif CONDITION_B:\n",
    "    # statements to be executed if CONDITION_A is evaluated as False and CONDITION_B is evaluated as True.\n",
    "elif CONDITION_C:\n",
    "    # statements to be executed if CONDITION_A and CONDITION_B are both evaluated as False and CONDITION_C is evaluated as True.\n",
    "else:\n",
    "    # statements to be executed if CONDITION_A, CONDITION_B, and CONDITION_C are all evaluated as False.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_negative_or_neutral(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = \"{} is positive.\".format(x)\n",
    "    elif x < 0:\n",
    "        msg = \"{} is negative.\".format(x)\n",
    "    else:\n",
    "        msg = \"{} is neutral.\".format(x)\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_negative_or_neutral(5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(-5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We can break down alternative/chained conditionals once our conditions are mutually exclusive"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_negative_or_neutral(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = \"{} is positive.\".format(x)\n",
    "    if x < 0:\n",
    "        msg = \"{} is negative.\".format(x)\n",
    "    if x == 0:\n",
    "        msg = \"{} is neutral.\".format(x)\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_negative_or_neutral(5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(-5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We can also nest conditionals within other conditionals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5566 is positive.\n",
      "-5566 is negative.\n",
      "0 is neutral.\n"
     ]
    }
   ],
   "source": [
    "def return_msg_whether_positive_negative_or_neutral(x: int) -> str:\n",
    "    if x > 0:\n",
    "        msg = \"{} is positive.\".format(x)\n",
    "    else:\n",
    "        if x < 0:\n",
    "            msg = \"{} is negative.\".format(x)\n",
    "        else:\n",
    "            msg = \"{} is neutral.\".format(x)\n",
    "    return msg\n",
    "\n",
    "print(return_msg_whether_positive_negative_or_neutral(5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(-5566))\n",
    "print(return_msg_whether_positive_negative_or_neutral(0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If conditions are NOT mutually exclusive in a chained condition\n",
    "\n",
    "- Still, exactly one of the alternatives will run.\n",
    "- But order matters."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Take the famous `FizzBuzz` for example\n",
    "\n",
    "Fizz buzz (often spelled FizzBuzz in this context) has been used as an interview screening device for computer programmers. Writing a program to output the first 100 FizzBuzz numbers is a trivial problem for any would-be computer programmer, so interviewers can easily filter out those with insufficient programming ability.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Fizz_buzz>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fizz Buzz'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# chained conditionals\n",
    "def fizz_buzz(x: int) -> str:\n",
    "    if x % 15 == 0:\n",
    "        ans = \"Fizz Buzz\"\n",
    "    elif x % 3 == 0:\n",
    "        ans = \"Fizz\"\n",
    "    elif x % 5 == 0:\n",
    "        ans = \"Buzz\"\n",
    "    else:\n",
    "        ans = x\n",
    "    return ans\n",
    "\n",
    "fizz_buzz(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Fizz Buzz'"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# non-chained conditionals\n",
    "def fizz_buzz(x: int) -> str:\n",
    "    if x % 3 == 0:\n",
    "        ans = \"Fizz\"\n",
    "    if x % 5 == 0:\n",
    "        ans = \"Buzz\"\n",
    "    if x % 15 == 0:\n",
    "        ans = \"Fizz Buzz\"\n",
    "    if (x % 15 != 0) and (x % 3 != 0) and (x % 5 != 0):\n",
    "        ans = x\n",
    "    return ans\n",
    "\n",
    "fizz_buzz(15)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The essense of iterations\n",
    "\n",
    "Like the slicing syntax of lists:\n",
    "\n",
    "- start: when does the iteration start?\n",
    "- stop: when does the iteration stop?\n",
    "- step: how does the iteration go from start to stop?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We can utilize two kinds of iteration\n",
    "\n",
    "- `while` loop\n",
    "- `for` loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The `while` loop is used to repeat one or more code statements as long as the condition is evaluated as `True`\n",
    "\n",
    "```python\n",
    "i = 0 # start\n",
    "while CONDITION: # stop\n",
    "    # repeated statements\n",
    "    i += 1 # step\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Assignment operators are commonly used in writing loops\n",
    "\n",
    "- `i += 1` as in `i = i + 1` \n",
    "- `i -= 1` as in `i = i - 1` \n",
    "- `i *= 1` as in `i = i * 1` \n",
    "- `i /= 1` as in `i = i / 1` \n",
    "- ...etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Imgur](https://i.imgur.com/KNhPttU.png?1)\n",
    "\n",
    "Source: [A Beginners Guide to Python 3 Programming](https://www.amazon.com/Beginners-Programming-Undergraduate-Computer-Science-ebook/dp/B07W4THQB6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The `for` loop is used to step an element through an iterable until the end is reached\n",
    "\n",
    "```python\n",
    "for i in ITERABLE: # start/stop/step\n",
    "    # repeated statements\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Imgur](https://i.imgur.com/K4MRRcC.png?1)\n",
    "\n",
    "Source: [A Beginners Guide to Python 3 Programming](https://www.amazon.com/Beginners-Programming-Undergraduate-Computer-Science-ebook/dp/B07W4THQB6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use a code-visualization tool to help you understand the behavior of loops\n",
    "\n",
    "We can use [pythontutor.com](https://www.pythontutor.com) to explore the execution of our code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Retrieving the first 5 odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 1 # start\n",
    "while i < 11: # stop\n",
    "    print(i)\n",
    "    i += 2 # step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10, 2): # start/stop/step => help(range)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `range()` function to create a sequence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class range in module builtins:\n",
      "\n",
      "class range(object)\n",
      " |  range(stop) -> range object\n",
      " |  range(start, stop[, step]) -> range object\n",
      " |  \n",
      " |  Return an object that produces a sequence of integers from start (inclusive)\n",
      " |  to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
      " |  start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
      " |  These are exactly the valid indices for a list of 4 elements.\n",
      " |  When step is given, it specifies the increment (or decrement).\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __bool__(self, /)\n",
      " |      self != 0\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __reduce__(...)\n",
      " |      Helper for pickle.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(...)\n",
      " |      Return a reverse iterator.\n",
      " |  \n",
      " |  count(...)\n",
      " |      rangeobject.count(value) -> integer -- return number of occurrences of value\n",
      " |  \n",
      " |  index(...)\n",
      " |      rangeobject.index(value) -> integer -- return index of value.\n",
      " |      Raise ValueError if the value is not present.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  start\n",
      " |  \n",
      " |  step\n",
      " |  \n",
      " |  stop\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(range)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Retrieving the first 5 primes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "i = 0 # start\n",
    "while i < len(primes): # stop\n",
    "    print(primes[i])\n",
    "    i += 1 # step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "for i in primes: # start/stop/step\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## `while` versus `for` when dealing with iterations?\n",
    "\n",
    "- Use `for` to iterate over lists, dictionaries, and other iterables\n",
    "- Use `while` if our operations involve randomness or uncertainty"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(85, [50, 76, 89, 82, 86, 84, 86, 85])\n",
      "(14, [50, 25, 13, 20, 16, 14])\n",
      "(92, [50, 76, 89, 95, 92])\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "def binary_search(low: int=1, high: int=100) -> list:\n",
    "    guess = (low + high) // 2\n",
    "    rand_int = randint(low, high)\n",
    "    guess_history = [guess]\n",
    "    while guess != rand_int:\n",
    "        if guess > rand_int:\n",
    "            high = guess\n",
    "            guess = (low + high) // 2\n",
    "        elif guess < rand_int:\n",
    "            low = guess\n",
    "            guess = (low + high) // 2 + 1\n",
    "        guess_history.append(guess)\n",
    "    return rand_int, guess_history\n",
    "\n",
    "print(binary_search())\n",
    "print(binary_search())\n",
    "print(binary_search())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "11\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "def int_to_bin_str(x: int) -> str:\n",
    "    if x < 2:\n",
    "        return str(x)\n",
    "    binary_str = \"\"\n",
    "    while x > 0:\n",
    "        modulo = x % 2\n",
    "        binary_str = str(modulo) + binary_str\n",
    "        x //= 2\n",
    "    return binary_str\n",
    "\n",
    "print(int_to_bin_str(2)) # bin(2)\n",
    "print(int_to_bin_str(3)) # bin(3)\n",
    "print(int_to_bin_str(4)) # bin(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We've been talking about ITERABLE for quite a few times, so what is a iterable?\n",
    "\n",
    "An iterable is any Python object capable of returning its elements one at a time, permitting it to be iterated over in a `for` loop. Familiar examples of iterables include lists, tuples, and strings."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Iterate over a `str`\n",
    "\n",
    "Using built-in functions to explore iterations.\n",
    "\n",
    "- `iter()`\n",
    "- `next()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function iter in module builtins:\n",
      "\n",
      "iter(...)\n",
      "    iter(iterable) -> iterator\n",
      "    iter(callable, sentinel) -> iterator\n",
      "    \n",
      "    Get an iterator from an object.  In the first form, the argument must\n",
      "    supply its own iterator, or be a sequence.\n",
      "    In the second form, the callable is called until it returns the sentinel.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(iter)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function next in module builtins:\n",
      "\n",
      "next(...)\n",
      "    next(iterator[, default])\n",
      "    \n",
      "    Return the next item from the iterator. If default is given and the iterator\n",
      "    is exhausted, it is returned instead of raising StopIteration.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(next)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L\n",
      "u\n",
      "k\n",
      "e\n"
     ]
    }
   ],
   "source": [
    "may4th = \"Luke, use the Force!\"\n",
    "I = iter(may4th)\n",
    "print(next(I))\n",
    "print(next(I))\n",
    "print(next(I))\n",
    "print(next(I))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Iterate over a `int`, `float`, or `bool`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'int' object is not iterable\n",
      "'float' object is not iterable\n",
      "'bool' object is not iterable\n",
      "'bool' object is not iterable\n"
     ]
    }
   ],
   "source": [
    "def is_x_iterable(x) -> str:\n",
    "    try:\n",
    "        I = iter(x)\n",
    "        return True\n",
    "    except TypeError as e:\n",
    "        return e\n",
    "\n",
    "print(is_x_iterable(5566))\n",
    "print(is_x_iterable(5566.0))\n",
    "print(is_x_iterable(False))\n",
    "print(is_x_iterable(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Iterate over a list/tuple is quite straight-forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "7\n",
      "11\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "for i in primes:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How about iterating over a dictionary?\n",
    "\n",
    "Use `.keys()`, `.values()`, and `.items()` to help us iterate over a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['isNBAFranchise', 'city', 'fullName', 'tricode', 'teamId', 'nickname', 'confName', 'divName'])\n",
      "dict_values([True, 'Boston', 'Boston Celtics', 'BOS', 1610612738, 'Celtics', 'East', 'Atlantic'])\n",
      "dict_items([('isNBAFranchise', True), ('city', 'Boston'), ('fullName', 'Boston Celtics'), ('tricode', 'BOS'), ('teamId', 1610612738), ('nickname', 'Celtics'), ('confName', 'East'), ('divName', 'Atlantic')])\n"
     ]
    }
   ],
   "source": [
    "the_celtics = {\n",
    "    'isNBAFranchise': True,\n",
    "    'city': \"Boston\",\n",
    "    'fullName': \"Boston Celtics\",\n",
    "    'tricode': \"BOS\",\n",
    "    'teamId': 1610612738,\n",
    "    'nickname': \"Celtics\",\n",
    "    'confName': \"East\",\n",
    "    'divName': \"Atlantic\"\n",
    "}\n",
    "print(the_celtics.keys())\n",
    "print(the_celtics.values())\n",
    "print(the_celtics.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isNBAFranchise\n",
      "city\n",
      "fullName\n",
      "tricode\n",
      "teamId\n",
      "nickname\n",
      "confName\n",
      "divName\n"
     ]
    }
   ],
   "source": [
    "for k in the_celtics.keys():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Boston\n",
      "Boston Celtics\n",
      "BOS\n",
      "1610612738\n",
      "Celtics\n",
      "East\n",
      "Atlantic\n"
     ]
    }
   ],
   "source": [
    "for v in the_celtics.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isNBAFranchise: True\n",
      "city: Boston\n",
      "fullName: Boston Celtics\n",
      "tricode: BOS\n",
      "teamId: 1610612738\n",
      "nickname: Celtics\n",
      "confName: East\n",
      "divName: Atlantic\n"
     ]
    }
   ],
   "source": [
    "for k, v in the_celtics.items():\n",
    "    print(\"{}: {}\".format(k, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common tasks using iteration\n",
    "\n",
    "- Simply `print()`\n",
    "- Combinations\n",
    "- Summations/Counts\n",
    "- Iterating over a nested data structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common tasks: combinations\n",
    "\n",
    "- Combining elements as a `list`.\n",
    "- Combining elements as a `str`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Combining elements as a `list`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 13, 17, 19, 23, 29]"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def collecting_two_digit_integers(x: list) -> list:\n",
    "    out = []\n",
    "    for elem in x:\n",
    "        if 10 <= elem <= 99:\n",
    "            out.append(elem)\n",
    "    return out\n",
    "\n",
    "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 101, 103]\n",
    "collecting_two_digit_integers(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Combining elements as a `str`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pythn\n",
      "ncnd\n"
     ]
    }
   ],
   "source": [
    "def collecting_non_vowels(x: str) -> str:\n",
    "    out = \"\"\n",
    "    for char in x:\n",
    "        char_lower = char.lower()\n",
    "        if char_lower not in {'a', 'e', 'i', 'o', 'u'}:\n",
    "            out += char # out = out + char\n",
    "    return out\n",
    "\n",
    "print(collecting_non_vowels(\"Python\"))\n",
    "print(collecting_non_vowels(\"Anaconda\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common tasks: summations/counts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "333\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 101, 103]\n",
    "summation = 0\n",
    "counts = 0\n",
    "for i in primes:\n",
    "    summation += i  # summation = summation + 1\n",
    "    counts += 1     # counts = counts + 1\n",
    "\n",
    "print(summation)\n",
    "print(counts)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common tasks: summations/counts\n",
    "\n",
    "Built-in functions `sum()` and `len()` work like a charm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "333\n",
      "12\n"
     ]
    }
   ],
   "source": [
    "print(sum(primes))\n",
    "print(len(primes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common tasks: Iterating over a nested data structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Batman Begins\n",
      "The Dark Knight\n",
      "The Dark Knight Rises\n",
      "June 15, 2005\n",
      "July 18, 2008\n",
      "July 20, 2012\n",
      "Christopher Nolan\n",
      "Christopher Nolan\n",
      "Christopher Nolan\n"
     ]
    }
   ],
   "source": [
    "batman_trilogy = {\n",
    "    \"titles\": [\"Batman Begins\", \"The Dark Knight\", \"The Dark Knight Rises\"],\n",
    "    \"release_dates\": [\"June 15, 2005\", \"July 18, 2008\", \"July 20, 2012\"],\n",
    "    \"director\": [\"Christopher Nolan\", \"Christopher Nolan\", \"Christopher Nolan\"]\n",
    "}\n",
    "for v in batman_trilogy.values():\n",
    "    for i in v:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Early stop or skipping certain steps in an iteration task\n",
    "\n",
    "- Use keyword `break` to early break an iteration\n",
    "- Use keyword `continue` to skip certain steps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def early_break_if_summation_exceeds_fifty(x: range) -> None:\n",
    "    summation = 0\n",
    "    for i in x:\n",
    "        summation += i\n",
    "        print(i)\n",
    "        if summation >= 50:\n",
    "            break\n",
    "\n",
    "early_break_if_summation_exceeds_fifty(range(100))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "def print_only_evens(x: range) -> None:\n",
    "    summation = 0\n",
    "    for i in x:\n",
    "        if i % 2 == 1:\n",
    "            continue\n",
    "        print(i)\n",
    "\n",
    "print_only_evens(range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Handling Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Coding mistakes are common, they happen all the time\n",
    "\n",
    "![Imgur](https://i.imgur.com/t9sYsyk.jpg?1)\n",
    "\n",
    "Source: Google Search"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## How does a function designer handle errors?\n",
    "\n",
    "Python mistakes come in three basic flavors:\n",
    "\n",
    "- Syntax errors.\n",
    "- Runtime errors.\n",
    "- Semantic errors."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Syntax errors\n",
    "\n",
    "Errors where the code is not valid Python (generally easy to fix).\n",
    "\n",
    "```python\n",
    "# Python does not need braces to create a code block\n",
    "for (i in range(10)) {\n",
    "    print(i)\n",
    "}\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Runtime errors\n",
    "\n",
    "Errors where syntactically valid code fails to execute, perhaps due to invalid user input (sometimes easy to fix)\n",
    "\n",
    "- `NameError`\n",
    "- `TypeError`\n",
    "- `ZeroDivisionError`\n",
    "- `IndexError`\n",
    "- ...etc.\n",
    "\n",
    "Source: <https://docs.python.org/3/library/exceptions.html>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    "# IndexError\n",
    "my_favorite_boy_group = \"5566\"\n",
    "print(my_favorite_boy_group[4])\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Semantic errors\n",
    "\n",
    "Errors in logic: code executes without a problem, but the result is not what you expect (often very difficult to identify and fix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "def product(x: list) -> int:\n",
    "    \"\"\"\n",
    "    x: an iterable.\n",
    "    Return the product values of x.\n",
    "    \"\"\"\n",
    "    prod = 0 # set \n",
    "    for i in x:\n",
    "        prod *= i\n",
    "    return prod\n",
    "\n",
    "print(product([5, 5, 6, 6])) # expecting 900"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Using `try` and `except` to catch exceptions\n",
    "\n",
    "```python\n",
    "try:\n",
    "    # sequence of statements if everything is fine\n",
    "except TYPE_OF_ERROR:\n",
    "    # sequence of statements if something goes wrong\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encountering a IndexError.\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    my_favorite_boy_group = \"5566\"\n",
    "    print(my_favorite_boy_group[4])\n",
    "except IndexError:\n",
    "    print(\"Encountering a IndexError.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "string index out of range\n"
     ]
    }
   ],
   "source": [
    "# Print out error message directly\n",
    "try:\n",
    "    my_favorite_boy_group = \"5566\"\n",
    "    print(my_favorite_boy_group[4])\n",
    "except IndexError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "division by zero\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(5566 / 0)\n",
    "except ZeroDivisionError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Encountering a whatever error.\n"
     ]
    }
   ],
   "source": [
    "# It is optional to specify the type of error\n",
    "try:\n",
    "    print(5566 / 0)\n",
    "except:\n",
    "    print(\"Encountering a whatever error.\")"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}