notebooks/Lecture 13.1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "662f97e6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "cdb42283",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 12.2. (continued)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12620755",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Question. Find Index of Minimum Value, <u> using `for` loops </u>\n",
    "\n",
    "Write a function `find_min` that accepts as input a list of integers and returns the **index** of the list item with the **minimum** value. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40f0c9e6",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_min(numbers):\n",
    "    minimum = 1000\n",
    "    i = 0\n",
    "    for element in numbers:\n",
    "        if element < minimum:\n",
    "            minimum = element\n",
    "            min_index = i    \n",
    "        i = i + 1\n",
    "            \n",
    "    return min_index\n",
    "\n",
    "assert find_min([9, 5, 1]) == 2, \"Test case failed\"\n",
    "print(\"Test case passed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22428b02",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Tuple Assignment and `for` loops"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75b07da3",
   "metadata": {},
   "source": [
    "Recall, **from Lecture 10.3:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0333555c",
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y = 1, 2\n",
    "x, y = y, x\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8630ec7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"From Lab 12\"\"\"\n",
    "\n",
    "emojis = [('😀', \"Grinning Face\"),          ('😁', \"Beaming Face With Smiling Eyes\"), \n",
    "          ('😂', \"Face With Tears of Joy\"), ('🤣', \"Rolling on the Floor Laughing\")]\n",
    "\n",
    "for icon, desc in emojis:\n",
    "    print(desc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4de95db",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Built-in `enumerate`\n",
    "\n",
    "* **Input =>** `list` or `set`, a `tuple` or a `str`\n",
    "\n",
    "* **Output =>** a List of Tuples:\\\n",
    "`[(idx0, val0),  ... ,( idx_len-1, val_len-1 ) ]`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86cbd345",
   "metadata": {},
   "source": [
    "![list](https://i.ibb.co/GJkSBQ7/Screen-Shot-2022-10-27-at-1-21-19-PM.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c100b42c",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "rainbow = [\"Red\", \"Orange\", \"Yellow\", \"Green\", \"Blue\", \"Indigo\", \"Violet\"]\n",
    "print(list(enumerate(rainbow)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69e57269",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `for` loops with `enumerate`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96d2628b",
   "metadata": {},
   "source": [
    "**Problem**: Given a list `sequence` and a value `val`, find index of `val` in `sequence` if present; if not, else return `-1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "00786630",
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def find_val(sequence, val): \n",
    "    \n",
    "    return val_idx\n",
    "\n",
    "assert find_val([1, 2, 3, 4, 5])        ==  0, \"Test case 1 failed\"\n",
    "assert find_val([\"a\", \"b\", \"c\", \"d\"]) ==  2, \"Test case 2 failed\"\n",
    "assert find_val([\"a\", \"b\"], \"c\")           == -1, \"Test case 3 failed\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "593dd954",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Question. Find Index of Minimum Value, <u> using for loops AND enumerate</u>\n",
    "\n",
    "Write a function `find_min` that accepts as input a list of integers and returns the **index** of the list item with the **minimum** value. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61834f06",
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_min(numbers):\n",
    "    minimum = 1000\n",
    "    enum = list(enumerate(numbers))\n",
    "    for idx, num in enum:\n",
    "        if num < minimum:\n",
    "            minimum = num\n",
    "            min_index = idx\n",
    "    return min_index\n",
    "\n",
    "assert find_min([7, 1, 2]) == 1, \"Test case failed\"\n",
    "print(\"Test case passed successfully\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db37e532",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lecture 13.1. \n",
    "\n",
    "# Dictionaries\n",
    "\n",
    "# Friday, Nov 17"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d9fe21d",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "* All of the indexed data structures we have studied so far — strings, lists, and tuples— are **sequence types**, which use **contiguous integers**, starting from 0, **as indices** to access the values they contain within them."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e58c24a3",
   "metadata": {},
   "source": [
    "<center><img width=1100 src=\"https://i.ibb.co/k6J59Nw/Screen-Shot-2022-11-17-at-11-01-06-PM.png\"></center>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa3f3e15",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dictionaries\n",
    "\n",
    "* **Dictionaries** <u>_map_</u> **Keys** to **Values**\n",
    "\n",
    "* **Keys** can be any immutable type: `int`, `str`, `bool`, `float`, `tuples`\n",
    "\n",
    "* **Values** can be of <u>_any_</u> type\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b143a1bf",
   "metadata": {},
   "source": [
    "<img src=\"https://i.ibb.co/h1J1vpR/Screen-Shot-2022-11-17-at-11-28-01-AM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cab926c",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"https://i.ibb.co/ZxMVZd0/Screen-Shot-2022-11-17-at-1-06-23-PM.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f431544",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionaries vs. other Data Structures\n",
    "\n",
    "\n",
    "Type | Collection | Syntax | Ordered | Indexed | Mutable | Passed By | Duplicates Allowed \n",
    ":------------: | :-------------:|:-------------:|:-------------:|:-------------:| :-------------:| :-------------:|:-------------:\n",
    "`strings` | characters | `\"c1c2c3\"` | &check; |&check; | &cross; | value | &check;\n",
    "`list` | any data type | `[v1, v2.. vn]` | &check; |&check; |  &check; | reference | &check;\n",
    "`tuple` | any data type | `(v1, v2.. vn)` | &check; | &check; |  &cross; | value | &check;\n",
    "`set` | immutable types | `{v1, v2.. vn}` | &cross; | &cross; |  &cross; | value | &cross;\n",
    "**`dictionaries`** | **any data type*** | **`{k1:v1,k2:v2.. kn:vn}`** | **&cross;** | **&check;** |  **&check;** | **reference** | **&cross;****"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd4e8ca6",
   "metadata": {},
   "source": [
    "\\* _**keys** can only be immutable type; **values** can be any data type_ \\\n",
    "\\** _**keys** can not be duplicate; **values** can be duplicate_"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc0a73dc",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionaries Syntax"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bab98b7",
   "metadata": {},
   "source": [
    "* Use curly brackets `{}` to **initialize**\n",
    "\n",
    "* Use square brackets `[]` to:\n",
    "    * **insert** keys, and map values to them\n",
    "    * **access** values, using keys\n",
    "    * **update** key-value mappings\n",
    "    \n",
    "* The key-value pairs of a dictionary are seperated by commas `,`\n",
    "* Each pair contains a key and a value separated by a colon `:`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4064406",
   "metadata": {},
   "outputs": [],
   "source": [
    "dictionary = {\"key1\": \"value1\", \"key2\": \"value2\"}\n",
    "\n",
    "dictionary[\"value1\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "900b022e",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Creating Dictionaries, and Inserting Key-Value Pairs\n",
    "* One way to create a dictionary is to start with the empty dictionary and add key-value pairs. The empty dictionary is denoted `{}`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "763daf64",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp        = {}     # a dictionary to translate English words into Spanish\n",
    "eng2sp['one'] = 'uno'  # adding a new key \"one\" and mapping the value \"uno\" to it\n",
    "eng2sp['two'] = 'dos'  # adding yet another key \"one\" and mapping the value \"dos\" to it\n",
    "print(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da5749cd",
   "metadata": {},
   "source": [
    "* Similar to sets, the **order** of the pairs is **unpredictable**. \n",
    "\n",
    "* Another way to create a dictionary is to provide a list of key-value pairs using the same syntax as the previous output:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe2dd782",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "print(eng2sp['three'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0694303",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Accessing Values\n",
    "\n",
    "* The values in a dictionary are **<u><i>accessed with Keys, NOT with Indices</i></u>**. Hence, \n",
    "\n",
    "    * It doesn’t matter what order in which we write the pairs\n",
    "    * There is no need to worry about ordering.\n",
    "\n",
    "Here is how we use a key to look up the corresponding value:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "934e9070",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(eng2sp['two'])  # The key 'two' yields the value 'dos'."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf81ab33",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Deleting Key-Value Pairs\n",
    "\n",
    "* The `del` statement removes a key-value pair from a dictionary. \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1254e660",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "print(eng2sp)\n",
    "\n",
    "del eng2sp['two']\n",
    "\n",
    "print(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "126b2724",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Change value associated with an existing key\n",
    "\n",
    "* Override previous value mapped to the key, using the assignment operator: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc8b834e",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "eng2sp['three'] = 'uno más dos'\n",
    "\n",
    "print(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af41e731",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Getting length of a Dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20c9a9aa",
   "metadata": {},
   "source": [
    "The `len` function also works on dictionaries; it returns the number of key-value pairs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "912512fd",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "len(eng2sp)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9dbf5fe6",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Looping over Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03eb3848",
   "metadata": {},
   "source": [
    "* You can loop through a dictionary by using a `for` loop.\n",
    "\n",
    "* When looping through a dictionary, the **target variable** of the for loop is **set to `keys`** of the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be617afd",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "for key in eng2sp: \n",
    "    value = eng2sp[1]\n",
    "    print(key)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2261f60",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Dictionary methods\n",
    "\n",
    "* Dictionaries have a number of useful built-in methods.\n",
    "\n",
    "* As we saw earlier with `strings` and `lists`, dictionary **methods** use **dot notation**, which specifies the name of the method to the right of the dot and the name of the object on which to apply the method immediately to the left of the dot.\n",
    "\n",
    "**1.** `dictionary`**`.keys()`**\n",
    "\n",
    "* The `keys` method takes a dictionary and returns the **list of its keys**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a3ba1595",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(eng2sp.keys())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a32ed512",
   "metadata": {},
   "source": [
    "**2.** `dictionary`**`.values()`**\n",
    "\n",
    "* The `values` method takes a dictionary and returns the **list of its values**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ebfa14",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(eng2sp.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "239c9641",
   "metadata": {},
   "source": [
    "**3.** `dictionary`**`.items()`**\n",
    "\n",
    "* The `items` method takes a dictionary and returns the **list of key-value pairs**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "47f1d1a2",
   "metadata": {},
   "outputs": [],
   "source": [
    "list(eng2sp.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1597f1a2",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Membership operator `in` with Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc63a746",
   "metadata": {},
   "source": [
    "* The `in` operator checks if **<u>a Key</u>** (_NOT VALUE_) **exists** in the dictionary \n",
    "    * returns `True` if the key is present in the dictionary and `False` otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d484fd94",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'}\n",
    "\n",
    "\n",
    "'one' in eng2sp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c43ab914",
   "metadata": {},
   "outputs": [],
   "source": [
    "'deux' in eng2sp"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f40de7b9",
   "metadata": {},
   "source": [
    "* This method can be very useful, since looking up a non-existant key in a dictionary causes a runtime error:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38df7dd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "eng2esp['dog']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c764df24",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Aliasing and copying\n",
    "* Because dictionaries are mutable, you need to be aware of aliasing. \n",
    "\n",
    "* Whenever two variables refer to the same object, changes to one affect the other.\n",
    "\n",
    "If you want to modify a dictionary and keep a copy of the original, use the copy method. For example, opposites is a dictionary that contains pairs of opposites:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b06f8771",
   "metadata": {},
   "outputs": [],
   "source": [
    "opposites = {'up': 'down', 'right': 'wrong', 'true': 'false'}\n",
    "alias = opposites\n",
    "copy = opposites.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe9b005e",
   "metadata": {},
   "outputs": [],
   "source": [
    "alias['right'] = 'left'\n",
    "opposites['right']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a06df3",
   "metadata": {},
   "source": [
    "* If we modify copy, opposites is unchanged:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "53223b05",
   "metadata": {},
   "outputs": [],
   "source": [
    "copy['right'] = 'privilege'\n",
    "opposites['right']"
   ]
  }
 ],
 "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.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}