04-data-structures-and-for-loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Programming Design\n",
    "\n",
    "> Data Structures and For Loops in Python\n",
    "\n",
    "Yao-Jen Kuo <yaojenkuo@ntu.edu.tw> from [DATAINPOINT](https://www.datainpoint.com/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## What is a data structure?\n",
    "\n",
    "> In computer science, a data structure is a data organization, management, and storage format that enables efficient access and modification. More precisely, a data structure is a collection of data values, the relationships among them, and the functions or operations that can be applied to the data.\n",
    "\n",
    "Source: <https://en.wikipedia.org/wiki/Data_structure>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Why data structure?\n",
    "\n",
    "As a software engineer, the main job is to perform operations on data, we can simplify that operation into: \n",
    "\n",
    "1. Take some input\n",
    "2. Process it\n",
    "3. Return the output\n",
    "\n",
    "Quite similar to what we've got from the definition of a function."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## To make the process efficient, we need to optimize it via data structure\n",
    "\n",
    "Data structure decides how and where we put the data to be processed. A good choice of data structure can enhance our efficiency."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## We will talk about 4 built-in data structures in Python\n",
    "\n",
    "- `list`\n",
    "- `tuple`\n",
    "- `dict` as in dictionary\n",
    "- `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Built-in data structures refer to those need no self-definition or importing\n",
    "\n",
    "Quite similar to the comparison of built-in functions vs. self-defined/third party functions."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `list`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lists\n",
    "\n",
    "Lists are the basic ordered and mutable data collection type in Python. They can be defined with comma-separated values between brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "print(type(primes)) # use type() to check type\n",
    "print(len(primes))  # use len() to check how many elements are stored in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lists have a number of useful methods\n",
    "\n",
    "- `.append()`\n",
    "- `.pop()`\n",
    "- `.remove()`\n",
    "- `.insert()`\n",
    "- `.sort()`\n",
    "- ...etc.\n",
    "\n",
    "We can use `TAB` and `SHIFT - TAB` for documentation prompts in a notebook environment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Different ways to update an object\n",
    "\n",
    "- **Return** a new object that has been updated.\n",
    "- **Update** the object itself and return `None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The difference between `sorted()` function and a list's `sort()` method\n",
    "\n",
    "- Return a new list containing all items from the iterable in ascending order.\n",
    "- Sort the list in ascending order and return None."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 11, 13]\n",
      "[2, 3, 5, 7, 11]\n",
      "[3, 5, 7, 11]\n",
      "[2, 3, 5, 7, 11]\n",
      "[11, 7, 5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "primes.append(13) # appending an element to the end of a list\n",
    "print(primes)\n",
    "primes.pop() # popping out the last element of a list\n",
    "print(primes)\n",
    "primes.remove(2) # removing the first occurance of an element within a list\n",
    "print(primes)\n",
    "primes.insert(0, 2) # inserting certain element at a specific index\n",
    "print(primes)\n",
    "primes.sort(reverse=True) # sorting a list, reverse=False => ascending order; reverse=True => descending order\n",
    "print(primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python provides access to elements in compound types through\n",
    "\n",
    "- **indexing** for a single element\n",
    "- **slicing** for multiple elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python uses zero-based indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "primes.sort()\n",
    "print(primes[0]) # the first element\n",
    "print(primes[1]) # the second element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Elements at the end of the list can be accessed with negative numbers, starting from -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "print(primes[-1]) # the last element\n",
    "print(primes[-2]) # the second last element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## While indexing means fetching a single value from the list, slicing means accessing multiple values in sub-lists\n",
    "\n",
    "- start(inclusive)\n",
    "- stop(non-inclusive)\n",
    "- step\n",
    "\n",
    "```python\n",
    "# slicing syntax\n",
    "LIST[start:stop:step]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n",
      "[5, 7, 11]\n",
      "[2, 5, 11]\n"
     ]
    }
   ],
   "source": [
    "print(primes[0:3:1]) # slicing the first 3 elements\n",
    "print(primes[-3:len(primes):1]) # slicing the last 3 elements \n",
    "print(primes[0:len(primes):2]) # slicing every second element"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## If leaving out, it defaults to\n",
    "\n",
    "- start: 0\n",
    "- stop: `len(list)`\n",
    "- step: 1\n",
    "\n",
    "So we can do the same slicing with defaults."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5]\n",
      "[5, 7, 11]\n",
      "[2, 5, 11]\n",
      "[11, 7, 5, 3, 2]\n"
     ]
    }
   ],
   "source": [
    "print(primes[:3]) # slicing the first 3 elements\n",
    "print(primes[-3:]) # slicing the last 3 elements \n",
    "print(primes[::2]) # slicing every second element\n",
    "print(primes[::-1]) # a particularly useful tip is to specify a negative step"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `tuple`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tuples\n",
    "\n",
    "Tuples are in many ways similar to lists, but they are defined with parentheses rather than brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "primes = (2, 3, 5, 7, 11)\n",
    "print(type(primes)) # use type() to check type\n",
    "print(len(primes))  # use len() to check how many elements are stored in the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The main distinguishing feature of tuples is that they are immutable\n",
    "\n",
    "Once they are created, their size and contents cannot be changed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 5, 7, 13]\n"
     ]
    }
   ],
   "source": [
    "primes = [2, 3, 5, 7, 11]\n",
    "primes[-1] = 13\n",
    "print(primes)\n",
    "primes = tuple(primes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'tuple' object does not support item assignment\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    primes[-1] = 11\n",
    "except TypeError as e:\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tuples are often used in a Python program; like functions that have multiple return values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Taiwan', 'Taipei')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def get_locale(country: str, city: str) -> str:\n",
    "    return country, city\n",
    "\n",
    "print(get_locale(\"Taiwan\", \"Taipei\"))\n",
    "print(type(get_locale(\"Taiwan\", \"Taipei\")))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Multiple return values can also be individually assigned"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Taiwan\n",
      "Taipei\n"
     ]
    }
   ],
   "source": [
    "my_country, my_city = get_locale(\"Taiwan\", \"Taipei\")\n",
    "print(my_country)\n",
    "print(my_city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `dict`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Dictionaries\n",
    "\n",
    "Dictionaries are extremely flexible mappings of keys to values, and form the basis of much of Python's internal implementation. They can be created via a comma-separated list of `key:value` pairs within braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "boston_celtics = {\n",
    "    'isNBAFranchise': True,\n",
    "    'city': \"Boston\",\n",
    "    'fullName': \"Boston Celtics\",\n",
    "    'tricode': \"BOS\",\n",
    "    'nickname': \"Celtics\",\n",
    "    'confName': \"East\",\n",
    "    'divName': \"Atlantic\"\n",
    "}\n",
    "\n",
    "print(type(boston_celtics))\n",
    "print(len(boston_celtics))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Elements are accessed through valid key rather than zero-based order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Boston\n",
      "East\n",
      "Atlantic\n"
     ]
    }
   ],
   "source": [
    "print(boston_celtics['city'])\n",
    "print(boston_celtics['confName'])\n",
    "print(boston_celtics['divName'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## New key:value pair can be set smoothly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'isNBAFranchise': True, 'city': 'Boston', 'fullName': 'Boston Celtics', 'tricode': 'BOS', 'nickname': 'Celtics', 'confName': 'East', 'divName': 'Atlantic', 'isMyFavorite': True}\n"
     ]
    }
   ],
   "source": [
    "boston_celtics['isMyFavorite'] = True\n",
    "print(boston_celtics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Use `del` to remove a key:value pair from a dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'isNBAFranchise': True, 'city': 'Boston', 'fullName': 'Boston Celtics', 'tricode': 'BOS', 'nickname': 'Celtics', 'confName': 'East', 'divName': 'Atlantic'}\n"
     ]
    }
   ],
   "source": [
    "del boston_celtics['isMyFavorite']\n",
    "print(boston_celtics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Common mehtods called on dictionaries\n",
    "\n",
    "- `.keys()`\n",
    "- `.values()`\n",
    "- `.items()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['isNBAFranchise', 'city', 'fullName', 'tricode', 'nickname', 'confName', 'divName'])\n",
      "dict_values([True, 'Boston', 'Boston Celtics', 'BOS', 'Celtics', 'East', 'Atlantic'])\n",
      "dict_items([('isNBAFranchise', True), ('city', 'Boston'), ('fullName', 'Boston Celtics'), ('tricode', 'BOS'), ('nickname', 'Celtics'), ('confName', 'East'), ('divName', 'Atlantic')])\n"
     ]
    }
   ],
   "source": [
    "print(boston_celtics.keys())\n",
    "print(boston_celtics.values())\n",
    "print(boston_celtics.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in Data Structure: `set`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sets\n",
    "\n",
    "The fourth basic collection is the set, which contains unordered collections of unique items. They are defined much like lists and tuples, except they use the braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'set'>\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "primes = {2, 3, 5, 7, 11}\n",
    "odds = {1, 3, 5, 7, 9}\n",
    "print(type(primes))\n",
    "print(len(odds))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Python's sets have all of the operations like union, intersection, difference, and symmetric difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Set operators\n",
    "\n",
    "- `|`: Union operator.\n",
    "- `&`: Intersection operator.\n",
    "- `-`: Difference operator.\n",
    "- `^`: Symmetric difference operator."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Union: elements appearing in either sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 5, 7, 9, 11}\n",
      "{1, 2, 3, 5, 7, 9, 11}\n"
     ]
    }
   ],
   "source": [
    "print(primes | odds)      # with an operator\n",
    "print(primes.union(odds)) # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Intersection: elements appearing in both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3, 5, 7}\n",
      "{3, 5, 7}\n"
     ]
    }
   ],
   "source": [
    "print(primes & odds)             # with an operator\n",
    "print(primes.intersection(odds)) # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Difference: elements in primes but not in odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 11}\n",
      "{2, 11}\n"
     ]
    }
   ],
   "source": [
    "print(primes - odds)           # with an operator\n",
    "print(primes.difference(odds)) # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Symmetric difference: items appearing in only one set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 9, 11]\n",
      "{1, 2, 9, 11}\n",
      "{1, 2, 9, 11}\n"
     ]
    }
   ],
   "source": [
    "print(sorted((primes - odds) | (odds - primes))) # union two differences\n",
    "print(primes ^ odds)                             # with an operator\n",
    "print(primes.symmetric_difference(odds))         # equivalently with a method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## An overview of when to use parentheses, brackets, or braces\n",
    "\n",
    "- Parentheses `()`\n",
    "- Brackets `[]`\n",
    "- Braces `{}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Parentheses `()`\n",
    "\n",
    "- Precedence of operation.\n",
    "- Calling a function.\n",
    "- Calling a method.\n",
    "- To form a `tuple`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Brackets `[]`\n",
    "\n",
    "- To form a `list`.\n",
    "- Indexing/Slicing element(s) from a data structure."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Braces `{}`\n",
    "\n",
    "- To be inserted in strings as placeholders in `.format()` or f-strings.\n",
    "- To form a `dict` with `key: value` pairs.\n",
    "- To form a `set`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##  One of the powerful features of Python's compound objects is that they can contain objects of any type, or even a mix of types"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "##  Take cdn.nba.com for example\n",
    "\n",
    "The official API of NBA is a bunch of compound dictionaries contained other dictionaries/lists as values.\n",
    "\n",
    "Source: <https://cdn.nba.com/static/json/liveData/scoreboard/todaysScoreboard_00.json>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## For Loops"
   ]
  },
  {
   "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 `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": [
    "## Printing out the first 5 integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Printing out the first 5 odds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": 24,
   "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",
      " |      True if self else False\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": [
    "## 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": 25,
   "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": 26,
   "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": 27,
   "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": 28,
   "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": 29,
   "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": 30,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['isNBAFranchise', 'city', 'fullName', 'tricode', 'nickname', 'confName', 'divName'])\n",
      "dict_values([True, 'Boston', 'Boston Celtics', 'BOS', 'Celtics', 'East', 'Atlantic'])\n",
      "dict_items([('isNBAFranchise', True), ('city', 'Boston'), ('fullName', 'Boston Celtics'), ('tricode', 'BOS'), ('nickname', 'Celtics'), ('confName', 'East'), ('divName', 'Atlantic')])\n"
     ]
    }
   ],
   "source": [
    "the_celtics = {\n",
    "    'isNBAFranchise': True,\n",
    "    'city': \"Boston\",\n",
    "    'fullName': \"Boston Celtics\",\n",
    "    'tricode': \"BOS\",\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": 31,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "isNBAFranchise\n",
      "city\n",
      "fullName\n",
      "tricode\n",
      "nickname\n",
      "confName\n",
      "divName\n"
     ]
    }
   ],
   "source": [
    "for k in the_celtics.keys():\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "Boston\n",
      "Boston Celtics\n",
      "BOS\n",
      "Celtics\n",
      "East\n",
      "Atlantic\n"
     ]
    }
   ],
   "source": [
    "for v in the_celtics.values():\n",
    "    print(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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",
      "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": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[11, 13, 17, 19, 23, 29]"
      ]
     },
     "execution_count": 34,
     "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": 35,
   "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": 36,
   "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": 37,
   "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": 38,
   "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": 39,
   "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": 40,
   "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": 41,
   "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": 42,
   "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": 43,
   "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": 44,
   "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": 45,
   "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.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}