12-13-Python Data Structures(Lists and Tuples).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "init_cell": true
   },
   "source": [
    "<center>\n",
    "    <img src=\"images/logo.jpg\" width=\"150\" alt=\"EPYTHON LAB logo\"  />\n",
    "</center>\n",
    "<hr>\n",
    "\n",
    "<h2 id='string' align='center'>Python Data Structures </h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## What are Data Structures in Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Data structures** are a way of organizing and storing data so that they can be accessed and worked with efficiently. They define the relationship between the data, and the operations that can be performed on the data.\n",
    "\n",
    "\n",
    "> There are many various kinds of data structures defined that make it easier for the **data scientists** and the software engineers, alike to concentrate on the main picture of solving larger problems rather than getting lost in the details of data description and access."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In computer science, data structures are divided in two categories:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Primitive Data Structures\n",
    "\n",
    "- Integers\n",
    "- Float\n",
    "- Strings\n",
    "- Boolean\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Non-Primitive Data Structures\n",
    "\n",
    "- Arrays\n",
    "- Lists\n",
    "- Sets\n",
    "- Tuples\n",
    "- Dictionary\n",
    "- Files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Python data types and structures\n",
    "\n",
    "In Python, **variables** are containers, which we could use to store several different kinds of information in a computer memory. We could store **text, numbers, or truth values**. These different kinds of information correspond with different Python **data types**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 is An object of  <class 'int'> type.\n",
      "3.14 is An object of  <class 'float'> type.\n",
      "Hi there! is An object of  <class 'str'> type.\n",
      "True is An object of  <class 'bool'> type.\n"
     ]
    }
   ],
   "source": [
    "x = 10 # An integer type\n",
    "y = 3.14 # A floating point type\n",
    "text = \"Hi there!\" # a string type\n",
    "is_paid = True # boolean type\n",
    "\n",
    "# Print the type of the above variables\n",
    "print(\"{} is An object of  {} type.\".format(x, type(x)))\n",
    "print(\"{} is An object of  {} type.\".format(y, type(y)))\n",
    "print(\"{} is An object of  {} type.\".format(text, type(text)))\n",
    "print(\"{} is An object of  {} type.\".format(is_paid, type(is_paid)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "**Lists** in Python are used to store collection of **heterogeneous** items in a single variable. \n",
    "\n",
    "- Lists are mutable, which means that you can change their content without changing their identity. \n",
    "- Lists are declared by using square brackets `[]` that holds elements\n",
    "- Elements are separated by comma `,`\n",
    "- Lists are built into Python: you do not need to invoke them separately.\n",
    "- Lists are ordered"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "[]\n"
     ]
    }
   ],
   "source": [
    "# Create empty list\n",
    "empty_list = []\n",
    "# print the type\n",
    "print(type(empty_list))\n",
    "print(empty_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Soak beans in waterDissolve salt in water', 'Heat water and beans to boil', 'Drain beans when done cooking']\n"
     ]
    }
   ],
   "source": [
    "# an example list\n",
    "beans_recipe = ['Soak beans in water',\n",
    "                'Dissolve salt in water',\n",
    "                'Heat water and beans to boil', \n",
    "                'Drain beans when done cooking']\n",
    "\n",
    "# print the list\n",
    "print(beans_recipe)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes we will store information in individual variables, but often we will be working with several pieces of information that we want to group together because of their relationship or similarity. For example, if we were shopping for Fruits, we could store each item we are going to buy in separate variables or we could store all of the items in one list.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# store each fruit in a variable\n",
    "fruit_a = \"Orange\"\n",
    "fruit_b = \"Banana\"\n",
    "fruit_c = \"Mango\"\n",
    "fruit_d = \"Apple\"\n",
    "fruit_e = \"Avocado\"\n",
    "\n",
    "# store list of fruits in a single variable\n",
    "fruits = ['Orange', 'Banana', 'Mango', 'Apple', 'Avocado']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing List elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The most basic data structure in Python is the **sequence**. Each element of a sequence is assigned a number - its **position or index**. The first index is **zero**, the second index is **one**, and so forth."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the square brackets for slicing along with the index or indices to obtain value available at that index. **For example:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mango is the third element in the list.\n",
      "Orange is the first element in the list.\n",
      "Avocado\n"
     ]
    }
   ],
   "source": [
    "# access the third element of fruits\n",
    "third_element = fruits[2]\n",
    "print(\"{} is the third element in the list.\".format(third_element))\n",
    "\n",
    "# access the first element\n",
    "first_element = fruits[0]\n",
    "print(\"{} is the first element in the list.\".format(first_element))\n",
    "print(fruits[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** Print the last element using negative indexing."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also retrieve a slice of items from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orange', 'Banana', 'Mango', 'Apple', 'Avocado']"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Apple', 'Avocado']\n",
      "['Orange', 'Banana', 'Mango']\n"
     ]
    }
   ],
   "source": [
    "# slice the last two elements\n",
    "print(fruits[-2:])\n",
    "# slice the first 3 elements\n",
    "print(fruits[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also slice a list using a step-size other than 1. For instance, we can slice every other item of the list, or even reverse the list by making negative steps."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Orange', 'Mango', 'Avocado']\n"
     ]
    }
   ],
   "source": [
    "# step-size\n",
    "print(fruits[::2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Avocado', 'Apple', 'Mango']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits[4:1:-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q**: How many fruits we have bought?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# print the number of fruits \n",
    "len(fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing elements using negative indexing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Q:** How could you print out all elements of the list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orange\n",
      "Banana\n",
      "Mango\n",
      "Apple\n",
      "Avocado\n"
     ]
    }
   ],
   "source": [
    "# Your code here\n",
    "for ele in fruits:\n",
    "    print(ele)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Orange\n",
      "Apple\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(fruits), 3):\n",
    "    print(fruits[i])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 Orange\n",
      "1 Banana\n",
      "2 Mango\n",
      "3 Apple\n",
      "4 Avocado\n"
     ]
    }
   ],
   "source": [
    "for i, ele in enumerate(fruits):\n",
    "    print(i, ele)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "numbers = [1, 2, 4, 5, 8]\n",
    "for i in range(len(numbers)):\n",
    "    print(numbers[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "<div class=\"alert alert-success alertsuccess\" style=\"margin-top: 30px\">\n",
    "    The <code>range</code> function returns a sequence of integers between the first and second argument, using the third argument as the step size. Notice that the upper bound (i.e. second argument) is not included in the output."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(range(0, 10, 3))\n",
    "print(range(104, 100, -1))\n",
    "print(range(5)) # starts at 0 and counts by 1 by default"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mutate the list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Removing element from the list:\n",
    "There are two ways of removing element from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits = ['Orange', 'Banana', 'Mango', 'Apple', 'Avocado']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Apple'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Using pop()\n",
    "\n",
    "fruits.pop(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Orange'"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits.pop(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Banana', 'Mango', 'Apple']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orange', 'Banana', 'Mango', 'Avocado']"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Using del keyword\n",
    "\n",
    "del fruits[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orange', 'Banana', 'Mango', 'Apple', 'Avocado']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Updating elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fruits before updating: ['Orange', 'Banana', 'Mango', 'Apple', 'Avocado']\n",
      "Fruits after updating: ['Orange', 'Banana', 'Mango', 'Apple', 'Ananas']\n"
     ]
    }
   ],
   "source": [
    "# replacing the last element in the list\n",
    "print(\"Fruits before updating:\", fruits)\n",
    "\n",
    "fruits[-1] = 'Ananas'\n",
    "\n",
    "print(\"Fruits after updating:\", fruits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Orange', 'Banana', 'Apple', 'Apple', 'Ananas']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fruits[2] = 'Apple'\n",
    "fruits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding new element in the list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`append()` is a Python built-in method that used to add new element into the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Orange', 'Banana', 'Mango', 'Apple', 'Avocado', 'orange']\n",
      "['Orange', 'Banana', 'Mango', 'Apple', 'Avocado', 'orange', 'orange']\n"
     ]
    }
   ],
   "source": [
    "# add Tomato to the list\n",
    "print(fruits)\n",
    "fruits.append('orange')\n",
    "print(fruits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Store heterogeneous data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 'egg', 3.5, True, False]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Store different types of data in a list\n",
    "lst = [2, 3, 'egg', 3.5, True, False]\n",
    "print(lst)\n",
    "type(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Combine lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 2, 4, 5, True, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "list1 =[2, 3, 4, 2]\n",
    "list2 = [4, 5, True, 5, 8]\n",
    "\n",
    "# concatenate\n",
    "combined_list = list1 + list2\n",
    "\n",
    "print(combined_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sort()`:Sorts objects of list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 3, 2, 2]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# example: sort list1\n",
    "list1.sort(reverse=True)\n",
    "list1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion:\n",
    "\n",
    "The three major defining properties of the Python list are that it is **ordered, heterogeneous, and mutable**. Because it is **heterogeneous and mutable**, the list is very flexible. We need to be careful about the changes we make to a list, because they can be very unpredictable. We could break our code or lose data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "### Exercises\n",
    "> Make a list of 10 elements and select only the last 2 elements\n",
    "\n",
    "> Take that same list of 10 elements and select every other element starting with the very first element.\n",
    "\n",
    "> Select every other element starting with the second element.\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Tuples** are another standard sequence data type. \n",
    "\n",
    "A Python tuple is very similar to a `list` with one major difference\n",
    "- `Tupe` is immutable, which means once defined you cannot **delete, add or edit** any values inside it.\n",
    "- `Tuple` is ordered and heterogeneous\n",
    "\n",
    "This might be useful in situations where you might to pass the control to someone else but you do not want them to manipulate data in your collection, but rather maybe just see them or perform operations separately in a copy of the data. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We create a tuple using parentheses `()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_tuple = ('Asibeh', 31, True, 6.8)\n",
    "#print(example_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While we can retrieve data through indexing (because a `tuple` is ordered), we cannot modify it (because a `tuple` is immutable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Accessing the third element \n",
    "\n",
    "print(example_tuple[2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While for clarity we should enclose tuples with `()`, Python will assume we want a `tuple` if we don't use any symbols to enclose comma separated values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "another_example_tuple = 'Cesar', 38, 162.3, True\n",
    "print(another_example_tuple)\n",
    "print(type(another_example_tuple))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This implicit `tuple` comes up most often when working with functions that return multiple outputs. For example, we might have a function that returns the first and last letter of a string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def first_last(string):\n",
    "    return string[0], string[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "In such cases, we'll sometimes want to store the multiple outputs in separate variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_char, last_char = first_last(\"Hello!\")\n",
    "\n",
    "print(first_char)\n",
    "print(last_char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This syntax is called `unpacking`. We can use it with any `tuple`, whether it was returned by a function or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "person_example = 'Cesar', 38, 70.5, True\n",
    "\n",
    "name, age, weight, has_dog = person_example\n",
    "\n",
    "print(name)\n",
    "print(age)\n",
    "print(weight)\n",
    "print(has_dog)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conclusion\n",
    "\n",
    "Both the Python `list` and `tuple` are **ordered and heterogeneous**. However, unlike the `list`, the `tuple` is **immutable**, meaning it cannot be modified after it is created. Therefore, a list might be better for representing data that is expected to change over the course of a program, like a to-do list. A `tuple` might be better for representing data that is expected to be fixed, like the responses of an individual subject to a survey."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gotcha\n",
    "\n",
    "One common mistake people make with immutability and especially with tuples is to assume data structures inside the tuple are immutable because the tuple is immutable. Lets see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup = tuple([[], 'a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup[0].append(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup[0].append(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though the tuple itself is immutable, we cannot change the exact objects which it contains, those objects themselves can be mutated if they are mutable. As with anywhere mutability shows up, this requires the programmer to be careful and not assume data has not been modified in some context.\n",
    "\n",
    "Let see one more example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup2 = tuple([(), []])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(tup2)\n",
    "print(tup2[0])\n",
    "print(tup2[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tup2[1].append(2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Set"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Sets` are a collection of distinct (unique) objects. These are useful to create lists that only hold unique values in the dataset. It is an unordered collection but a mutable one, this is very helpful when going through a huge dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A Python `set` is also similar to a `list`, except it is unordered. It can store heterogeneous data and it is mutable, but what does it mean to be unordered? The simplest explanation is simply to look at an example. \n",
    "\n",
    "We can create a set by enclosing our data with curly brackets `{}`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Example\n",
    "example_set = {'Cesar', 38, 70.5, True}\n",
    "\n",
    "print(example_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Even though we entered the data in one order, the `set` printed out in a different order. Even more significantly, we cannot index or slice a `set`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check the example\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, we can still add and delete items from a `set`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(example_set)\n",
    "print(example_set.pop())\n",
    "print(example_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `add` method of a `set` works similarly to the `append` method of a list. The `update` method of a `set` works similarly to the `extend` method of a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "example_set.add(72)\n",
    "print(example_set)\n",
    "example_set.update([61.1, 'Asibeh'])\n",
    "print(example_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Why is set useful?**\n",
    "\n",
    "It seems strange that we might want an unordered data structure. We can't access or modify the data through indexing. How does giving up order benefit us? The answer is that it gives us flexibility about how the data is stored in memory, and that flexibility can make data retrieval much faster.\n",
    "\n",
    "Imagine we have ten boxes and ten piles of money. We put the ten piles of money in the ten boxes. Now say we want to find the box that has $5.37 in it. We don't know which box this is, so we start with the first box and check. If it isn't in the first box, we move on to the second box. We keep checking boxes until we find it. This might take awhile."
   ]
  },
  {
   "attachments": {
    "542e950a-b2cf-4973-987f-1180e0b7385c.png": {
     "image/png": "iVBORw0KGgoAAAANSUhEUgAAA+MAAABHCAYAAABs4Za1AAAABHNCSVQICAgIfAhkiAAAG+pJREFUeF7tnQfQ1MQXwPej2ZCqiHUUEDt2rNgrKvZRwS52xzL2rqNid0TEUewNVBwdu2LFho4dRcXuqIOAiiKIBcl/3/7NN3fJ5i6b5I5c7rcz30A2m933fm+zl7fZfWnxdFIkCOSUwNSpU9VWW22lPv7445xKWD+x2rRpo+bNm1e/BmkptwTatWun5s6dm1v56iVY27Zt1b///luv5mgnxwToC/83Dhxy3EnrLBp94f/A11lnHfXss8+qbt261dkCNAeBeARacMbjgaJU/QngiNefOS1CAAIQgAAEIACBIhEQh3zcuHGqe/fuRVILXQpCAGe8IIYsohorr7yymjx5chFVQycIQAACEIAABCAAgToR2GyzzdT48ePr1BrNQCA+AZzx+KwoWWcCLS0tdW6R5iAAAQhAAAIQgAAEikagZ8+easqUKUVTC30KQKBNAXRABQhAAAIQgAAEIAABCEAAAhCAQEMRaNdQ0iJs0xOYMGGC6tGjR9NwuPzyy9WoUaPK9F1kkUXUxIkTm4aBKLr55pur77//vkznLbbYQt16661NxaF3794hfe+++2618cYbh/KLmjFy5Eh1zTXXlKm3wAILNF2Qx+222059+eWXZRw22GADNXr06KKa3qpXnz59VDAO7YgRI9TAgQOt5YuYKWPABRdcUKaaBHlstm1egwYNUpMmTSrj0K9fP/Xwww8X0eyROvXt2zcU2HLYsGFqn332ibymaCc++ugjteuuuxZNLfQpKAGc8YIatqhqLbfccmqppZYqqnohvTp37hzKk+X7vXr1CuUXOaN9+/Yh9RZeeOGm4xCCoDOWXHLJpuLQtWvXEIZmvCc6dOgQ4rDgggs2VV8QAGL7oDO+xBJLNBWHxRZbLNQXmvGekEm5YGrWeyLIQfpIMz03zJgxI4iAYwjklgDL1HNrGgSDAAQgAAEIQAACEIAABCAAgaISwBkvqmXRCwIQgAAEIAABCEAAAhCAAARySwBnPLemQTAIQAACEIAABCAAAQhAAAIQKCoBnPGiWha9IAABCEAAAhCAAAQgAAEIQCC3BHDGc2saBIMABCAAAQhAAAIQgAAEIACBohLAGS+qZdELAhCAAAQgAAEIQAACEIAABHJLAGc8t6ZBMAhAAAIQgAAEIAABCEAAAhAoKgGc8aJaFr0gAAEIQAACEIAABCAAAQhAILcEcMZzaxoEgwAEIAABCEAAAhCAAAQgAIGiEsAZL6pl0QsCEIAABCAAAQhAAAIQgAAEcksAZzy3pkEwCEAAAhCAAAQgAAEIQAACECgqAZzxoloWvSAAAQhAAAIQgAAEIAABCEAgtwRwxnNrGgSDAAQgAAEIQAACEIAABCAAgaISwBkvqmXRCwIQgAAEIAABCEAAAhCAAARySwBnPLemQTAIQAACEIAABCAAAQhAAAIQKCoBnPGiWha9IAABCEAAAhCAAAQgAAEIQCC3BHDGc2saBIMABCAAAQhAAAIQgAAEIACBohLAGS+qZdELAhCAAAQgAAEIQAACEIAABHJLAGc8t6ZBMAhAAAIQgAAEIAABCEAAAhAoKgGc8aJaFr0gAAEIQAACEIAABCAAAQhAILcEcMZzaxoES0tgxowZ6rbbblM777yz6tGjh2rfvr1aaqml1H777ac+/PBDp+r/+ecfddNNN6n+/fur7t27q86dO6t+/fqpSy65RM2cObO1Lvn/6aefrjbbbDPT1gILLKCWWWYZtf3226snn3zSqU0KQwAC6QgkGQM6duyoWlparH833nhjbIFc64k7xsQWIEbB119/XW233XZmPFt00UXV5ptvrsaNGxfjyugi+++/fyu7WbNmlRVMYo/oljgDAQhAAAIQaHwCOOONb0M0iCBw9dVXq8MOO0y9/PLLaq211lJ77rmncaTvu+8+tf7666sXX3wx4spw9h577KGOOuooNX36dLXXXnupIUOGqL///ludc845asCAAerPP/80F02bNk1deeWV6qefflJrr722abNv377qhRdeUDvttJM666yzwpXXOCeLh3zXh+i8TUqIrYYNG6ZWW201teCCC6pu3bqpXXfdVb3//vux6bvqlAX32MIFCt5+++1q6NChpt/LJJQ4l08//XTF6tI6ZnnsI0nHAJm8O+igg0J/K620UkWGwZMu9cQdY4JtJD1+7rnnjPM9YcIEJW0PHjzYTFLusMMOauzYsYmqfeyxx9S9996rFl54Yev1Se1hrSyDTNcJE1uTruPCtddea53oKZ0AuuKKK2xNpc5zvUelwazGsfkxJkUBc7FZEmZR7SZhUFpXpYmuqDZd87Pqny6MRca0bFz1pDwEckXAI0EgpwT0jeIF/3744YfY0t55553ePffc42lHueyaq666ytS76qqrxqrrtddeM+XXWWedsrrmzp3rbb311ubcmDFjTF3SlnbEQ/VOnjzZ0xMBXps2bbwff/wxdD4q49RTTw0x0A+QUcWt+XplgKlj+eWX94444gjv6KOP9rRTYfL0231vzpw51utKM88++2xTXr8987bddltvn3328VZffXWTp9/+e3qyoayOzz//3NMPl94qq6ziDRw40NOrEbwtt9zSa9eunbnmzDPPrNpmaYEVVlghxEHqjZP0w6S3zTbbmOv79OnjHXnkkd6+++7rLbTQQkZ2PVkTpxrPVacsuAcFEx2Cf9qpChbzllhiCVOuZ8+e3pJLLmn+/9RTT4XK+RnPPvussY30rYMPPtj0k65duxobPvDAA5HXlZ6oVx+56KKLQgz0BItVxiRjwCKLLOJtsskm1vpcMl3qcRljfBnk3gr2Be1cxxJRT06Z8UD6/3vvvdd6zRdffOF16tTJW2yxxbzff/89Vl1+Ie20eHo1kKcnMbw111zTyBasI4k9qgkhY2qQQ9w+KzbSEyZG5uBfcEyLksN1XHjmmWdCbflty/0nurz55ptRzVnzr7/++hADPQkXKut6j0oFWY1j9RiT5Dc62Bf0arYQBxebJWEWavC/DFcGpfU8+uijRjc90WW9t0rL+r+zpSxGjRoVJVZZflb904WxCJCGjU2xt99+O9QX5PeQBIE8ElB5FAqZICAEgj+qcuzijFeiuNxyy5n6f/nll0rFzLm7777blD3ttNNCZa+55hpzTh6GqqXddtvNlH3jjTeqFW09n9YZT/KQbxPO9SE660mJNM74rbfearjLxEnpxMPEiRM9ceL0ygVPJlaqJRedsuIelMl2T9iccb3U2Pvuu+/M5ccee6zRP8oZz8oxq1cfcXHGg/xKj6PGABcnulL9LvUkGWPSOOPSF6RPyMRLMPljjkxkuiSpSxzbn3/+OdIZr1RflD0qXSPn0jrjaSdeXMaFSrrIRIhMfunVO5WKWc/FdcZd79Esx7F6jElxnXEXm7kysxrov0wXBqX1xJnoKi2fxhmPkt+1f7owljaTsomSF2c8igz5eSTAMnX9REJqPgKyP1KWBXbo0KGq8voNuinz/PPPm6Xpfpo3b57SD7Wqbdu2ZrlnpaTfhiv9tsPsIV9xxRUrFc303FdffWXq02+GTdt+Epll2bwk/fDcmh/1nwMPPNAszS+tQ8qefPLJSj9Eq48//ljJcj4/STnZEhBMsmRflvULu2+++SZ4uibH+o2Cqfe8884zS9T9tMYaayj9hlx99tlnsbYsuOiUFfekQPTqBROrIE6Sfi22kFgKsqzdT71791Z6FYHZcvHII49UrarR+kilMUC2m8iWkkMPPdTEgNBvi2TiuiqDYIG49WQxxgTbrnQ8fvx4c1r6STDJHnJJfpngedux8LnjjjvUddddZ7aAJEmV7JGkvnpd4zIuVJJJ+Ekfkz5Xq+R6j2Y5js2PMSmKo4vNXJlFtSn5LgxK6znppJOUnjBWevK/UvU1PefaP10Yp2FTU6WpHAJ1ItCuTu3QDARyQ0Avy1STJk0yDrR+e1VVLj3brvSyXaWXeSn9Nsr8oIozK3vOp06daoLE6SXbZfVI/vnnn2+cTnHEZc+4fiub6mG1qqCWAsGHfH/ywWUiwVJtWZbLQ/T8mJQQW0jSb9dDqvTq1cvkvfTSS2bCIkmy6VQP7klktV1TzTGTGAhSRiZjkqa89ZFqY4BeYqkuvfTSVnVlD68EZXz44YednM249SQZY5LaQq4TuSTpbRuhavzJQv0mLHTOliF7Qw8//HC1yy67KL19xVakal41e1StIEUBf8JE7uPFF19cbbXVViaonUzWpkm2cSGqPhmP9RtYE9/hgAMOiCpW03zbPTq/xrF6jEk2mC42k+ttzGz1psnzJ7ok1k3Sia407cu1WfZPV8ZpZed6CDQCAZzxRrASMmZGQO9hVDLTrZdxKZcgORJJXd4Ay9tV+b+f9F4/tcUWW4Tkk7fEpeXkjewNN9xg3jTWM9X6Ib/aQ3QeJiX0/leDXN7+LrvssmX4/bfzvnMSxzZxdKo19zhyxi2TpWNmazNvfaTaGCBvoWTViARrE4dML3dUZ5xxhgkEKWPH448/blMzlOdaj+sYE2rQIcP/AoTeHx66ys/77bffQudsGXpZu/r111/N+JYkVbNHkjpdrok7YVKtzjjjQlQdOmaD0ttKlN7KZCYE6p2i7tH5NY7Vekzy+aaxWRSzLG2XxURXFvKk6Z9pGGchO3VAoCEI5HHtPDJBQAjoGyj0l2bPuOxh8gN56QfH2JD//fdf75BDDjGBU/QDs6d/XMy+yNGjR3t6ptoEyIqSS/bjSiAT2W8u+kjwMJeUds+439bFF18c2lspQYO+/fZbF3HKyuoHBRPETfanRQUc+uSTT8psKHu09eehnNtMs2fc30+pPy/n/fXXX61ti2wSxE3sot+ExZbJRaesudvuCdue8VJlqu0Zl4B8Uq/oFUwSU0HOyV7MJKkWfSTNnvGkY4B2Nj09kWNY6C0ZSVCYa6LqSTLGpNkznpXN9RYHs8955MiRZUyiArgFwSW1R2k9afaM669heDqavIkdIvtyJZDhuuuua+ysJ2SC4lY8dhkXghVJQExpU4J0JUlx94zb6o5zj2Y9jtVqTIq7Z9znkNRmcZjZWJfmVWMgZSWQpgRN9eN/SF6ceyvrPeNp+mcSxnHYVOPLnvFqhDifJwIEcMuTNZCljIDN8Yhyequhk4c+ib4tdeo34tWKl52/6667zHWXXXZZ6Dq9j8qcO/HEE0Pnghl6KacpK9FK46a0zniSh/w4srk+RKedlEjjjIus+lN2hv3KK6/sHXfccZ5eCupJgC0/Irz+nFMctcvKVNKpVtxt90RenfFa9ZGkzniaMUAML/1G+Mt4kCbZ6kkyxqRxxvUnF40utkk0vVrEnJOvH1RKMrEl96UEQNPLWMuKxnEY0trDbzCNM27TL2rCxFbWlldpXLCVl4kAvb/WfPlAvvyQJCV1xqvdo7Uax6o5W0kni1ydcZ+1i82qMYtrv2oM0kx0ZemMZ9E/hYkL42ps4jDGGY9DiTJ5IYAznhdLIEeIgM3xSOKMy4+nvOWQ+mSG3zWJ4ybXyhuUYNIBbsy5OJ8UkjfpUvbcc88NVhN5nNYZT/KQHynMfyfSPkQnmZRI44yL2LNmzfL0UmNP7xH35JM/8gmmU045xXvyySeNTcTGaVJQp1pwF/ls90RaZzwLxyzIrpZ9JIkznnYMEP38TxzdfPPNQXWdjm31JBlj0jjjci9IX9LfBA/JLm+H5Zz06Upp+vTp1v5o66NBJzMLe/iyZe2MS722CZNKLKLOBccFWznfkbZ9rcNW3paXxBmPc4/Wahyr5mwlHZOSOuOlTCvZLA4zm31seZUYpJ3oytIZz6J/BvWvxFjKVmITrCvqGGc8igz5eSRANHX95EAqLgH9o6b22GMP9cQTT6gLLrhA6QdhZ2X9COr64TN0rQT/kRSMMh4qqDP8yLQSpKdeSfZ6SbJFe5eAVJJk71vcJDz1g5LSTqzSExtK9ou6Jv3GzVzy6quvul6auLwE6pOAXF9++aWJiK8ndZQEJvvggw9MnXppauK65cKgTllzTyVclYsrBeyqtHczqtq89ZEsxgDR1e+vftC/KP2r5dvqyWqMqda2f94fD/RETugSv+/640OowH8ZEgfjsMMOs/75gaYkpoaU0Q5zazVZ2SNKrizyO3fubKoRWdOk4Lhgq0sCgErSW6Fsp2uSF/cenV/jWNZjkgvEKJvFZebSVlRZ2Sv+9ddfK/1pOXPvSOwK/8//zfKDx0mU9VqmWvTPKMa11IO6IZBnAgRwy7N1kC0VAfnx3H333c3nx/TbaBPdvFrSs8Amcujxxx/fWnTjjTdW999/v3Hm9Leqld47bs7JA/SFF15o/u8HcZMosEsvvXQoSrH8qIrzJ0nvXTb/1iNl+ZDvP0SLI550YkN0nh+TEjbW+m2diYQvkfFlwiZNCuqUJfc0csW5VhwzvQVDiWM2ePDgskviOmb+RXnrI65jgNynermwks+6+Ukv1TX3vtzb8rm4TTfdtIyRbcxwrcdljIlj02plZBxbfvnl1ZgxY5TeYqP69etnLhEHQALJSdBDCSZWmoJ6duzYUd1yyy3WpiTonV7equQaKecnV3tYK69Dpm3CJEmzwXEhWMfEiRPVu+++qzbaaCOlt9AET9fk2OUenV/jWJZjkitEm81cmLm2ZyvvT3TZzskXHeTekokuCURbOtFlK58mr1b908Y4jZxcC4GGJ5DH1/XIBAEhoG+u0J/LMnV/iXeXLl08CVZm+wsGMJO9e9o5KzOALHFebbXVjCz6YdzT34E1gVX0A7vJ059/8SSgiyT93W0T0EjyZI+6fqD19PesW/WQ8y4p7TL14cOHm7b1w543e/bs1qb1w4W34447mnPDhg0rE2nEiBGeXFeaZHmeXz7OMnv9qTATuC6Y9EOup986mXZt+1WD5f3jtMvU9bfEy6r+448/TH8QOWRJXDDZGLjolIR7UAbbse2eSLtMXfbyacfMk+B6+q1La7OyBUNspR0zT0e8LhPHxqdefcRlmbrrGKC/KW7uX4klIFtbdt5559bAbRLAUfZxBpNtzHCtx2WM8dtPs0xd6hg3bpwJvqid5dYxTQJSiv568jGoptnXHBwbQ4X+y4jaM+5qj6j6S/OTLlOXsUh/vq2sCf2W0fP7l4z1Mk6WJlu/dxkXgvqccMIJZgxKu/Uh7jJ113s0yThmYxTUu9oy5CRjkrQRd5m6i81cmYkcWTAIMvOPo+6t0vJZLVOP2z9t+rowDuparX8Ey9uOWaZuo0JeXgmwZzyvlkGuVge21AFxccb18khrHaX16SXaZaSjHjglqI/ss5QAYFJG/vr27WuipMs5P73zzjveMcccY5x3cWTkR1GirQ8aNMjTn0RytmpaZzzJQ76NgetDdNaTEmmdcQmOpD9VZewgf+JgSj/Qbwg9ccyDycbARack3IMy2I7jOuMS9d+ffJI+K9fJlwT8vLfeequs+iwcs3r1ERdn3HUMeOWVV7z999/f3NvipHbo0MEEKRs6dKg3efJkm0msTmqSeuKOMb4QaZ1xqUe/wTf9QiI2S0DDAQMGRAaYtN0TViA6M8phcLVHVP2l+UmdcdcJE2nTxsBlXCiVWxx9GYeEuz+ZG0dfW5m4zrjrPZpkHLMxEplrPSZJG3GdcRebuTITObJiYLN11L1VWjYLZ9ylf9r0dWGcpH/Y2JTm4YxXI8T5PBHAGc+TNZCljIDN8XBxxouAM60zLgxcH/JtP6yuD9FZT0qkdcb19+E9vRTXOFjy8CufL5LZ/GBgKb/P2Bi46uTKPU5/td0TtjfjQ4YMqTgRNXbs2FBzaR2zevURF2c8pGSBMrJwxouAI6kznmTCJItxwWf+4IMPmntUJsjSprjOuOs9KnK5jmM2RlJPrcckaSOuM+4ylidhliWDYN+olzPu0j9t+rowTto/gmxKj3HGK9HhXN4ItIhA+geBBIHcEZCAJcEkgbd0JOxgdmGP9Zv31r3mvpKyB1MvGy6szjbFJGiW7GctTXobgAnM10zJdk/IXm/ZA9wsSQIHSgyI0iR7LOfMmdMsCIyeeiuM0t/wLdNZ9trq5aFNxUFiPkicj9L0wAMPqL333rtpOOjvvCsdAb5MXwkU6u/5bhYQEohT9uCXpv79+yu9JapZEBg9xfbBwG6jRo1SOop503DQkwFqvfXWK9NX4oFMmTKlaRigaOMQIJp649gKSSEAAQhAAAIQgAAEIAABCECgIARwxgtiSNSAAAQgAAEIQAACEIAABCAAgcYhgDPeOLZCUghAAAIQgAAEIAABCEAAAhAoCAGc8YIYEjUgAAEIQAACEIAABCAAAQhAoHEI4Iw3jq2QFAIQgAAEIAABCEAAAhCAAAQKQgBnvCCGRA0IQAACEIAABCAAAQhAAAIQaBwCOOONYyskhQAEIAABCEAAAhCAAAQgAIGCEMAZL4ghUQMCEIAABCAAAQhAAAIQgAAEGocAznjj2ApJIQABCEAAAhCAAAQgAAEIQKAgBHDGC2JI1IAABCAAAQhAAAIQgAAEIACBxiGAM944tkJSCEAAAhCAAAQgAAEIQAACECgIAZzxghgSNSAAAQhAAAIQgAAEIAABCECgcQjgjDeOrZAUAhCAAAQgAAEIQAACEIAABApCAGe8IIZEDQhAAAIQgAAEIAABCEAAAhBoHAI4441jKySFAAQgAAEIQAACEIAABCAAgYIQwBkviCFRAwIQgAAEIAABCEAAAhCAAAQahwDOeOPYCkkhAAEIQAACEIAABCAAAQhAoCAEcMYLYkjUgAAEIAABCEAAAhCAAAQgAIHGIYAz3ji2QlIIQAACEIAABCAAAQhAAAIQKAgBnPGCGBI1IAABCEAAAhCAAAQgAAEIQKBxCOCMN46tkBQCEIAABCAAAQhAAAIQgAAECkIAZ7wghkQNCEAAAhCAAAQgAAEIQAACEGgcAu0aR1QkhYBSjz/+uOratWvToPjss89Cus6dO1eNHTs2lF/kjNmzZ4fUmzJlStNxCEHQGePHj1e//PKL7VQh8yZNmhTSa968eU3XF2bOnBniMH369Kbj4HleiMOECRNCeUXOePfdd0PqNeM9MWPGjBAHGRub7ffSdk+8/fbbqkuXLiE+Rc346quviqoaehWQQIu+acO/ZAVUFJUaj0BLS0vjCY3EEIAABCAAAQhAAAK5ItCzZ08lk/gkCOSNAMvU82YR5IEABCAAAQhAAAIQgAAEIACBwhPAGS+8iRtXwZ122qlxhUdyCEAAAhCAAAQgAIFcEOCZMhdmQAgLAZxxCxSy8kHgoYceUoMGDcqHMEgBAQhAAAIQgAAEINBwBA4++GA1atSohpMbgZuDAHvGm8PODavln3/+qYYOHao+/fTThtUhC8HnzJmjZs2apRZffPEsqmvYOiQYT/v27dWiiy7asDqkFVzCfEybNk11795dtWvXvDE4//rrL/Xbb7+pHj16pEXa0NdL0Kq2bduqTp06NbQeaYWXe6Jbt25NfU/8/fff6tdff236e0LGBUmdO3dO260a+nq5JyRoW4cOHRpaj7TCb7jhhmr48OFmnCRBII8E/ge4EO07e71HHgAAAABJRU5ErkJggg=="
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:542e950a-b2cf-4973-987f-1180e0b7385c.png)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now imagine we have the same ten piles of money, but we have 31 boxes. Instead of putting each pile of money into the boxes in order, instead put each pile into a box based on the amount of money in the pile. First we multiply the amount of money by 100, and then take modulus division by 31. This gives the number of the box we should put the pile of money in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "piles = [2.83, 8.23, 9.38, 10.23, 25.58, 0.42, 5.37, 28.10, 32.14, 7.31]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hash_function(x):\n",
    "    return int(x * 100 % 31)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[hash_function(pile) for pile in piles]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now say we want to find the box with `$5.37` in it. We don't have to search through box after box. We can compute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(5.37 * 100 % 31 ))"
   ]
  },
  {
   "attachments": {
    "182fe9a8-8824-43e9-9ac5-2fefae7a479d.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:182fe9a8-8824-43e9-9ac5-2fefae7a479d.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Box number 10 contains the $5.37 pile.\n",
    "\n",
    "This technique of assigning boxes (i.e. memory) based on the object it contains is called hashing. It makes searching for data very fast (as we've illustrated), but at the cost of increase memory allocation (we needed more boxes). It also means that we cannot assign an order to the objects as they are stored in memory.\n",
    "\n",
    "Hashing also puts two major restrictions on the set. First of all, objects in a set must be immutable. If an object were to change, its position in memory would no longer correspond with its hash. Secondly, the objects in a set must be unique. Identical objects end up with the same hash. Since we can't store multiple objects in the same chunk of memory, we simply discard any duplicates.\n",
    "\n",
    "This second restriction means we can use a set to easily determine the unique objects in a `list` or `tuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(set([23, 609, 348, 10, 5, 23, 340, 82]))\n",
    "print(set(('a', 'b', 'q', 'c', 'c', 'd', 'r', 'a')))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because searching for data is very simple in a `set`, they are also very useful for making comparisons between collections of data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "student_a_courses = {'history', 'english', 'biology', 'theatre'}\n",
    "student_b_courses = {'biology', 'english', 'mathematics', 'computer science'}\n",
    "\n",
    "print(student_a_courses.intersection(student_b_courses))\n",
    "print(student_a_courses.union(student_b_courses))\n",
    "print(student_a_courses.difference(student_b_courses))\n",
    "print(student_b_courses.difference(student_a_courses))\n",
    "print(student_a_courses.symmetric_difference(student_b_courses))"
   ]
  },
  {
   "attachments": {
    "a9a91354-84e3-4ff1-8329-88ab5f937e86.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![image.png](attachment:a9a91354-84e3-4ff1-8329-88ab5f937e86.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercises**\n",
    "\n",
    "1. When should I use a `set` instead of a `list`?\n",
    "2. What is an example of a problem where a `set` might be part of the solution?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionary: dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<hr>\n",
    "\n",
    "*Copyright &copy; 2021 <a href=\"https://yooutube.com/c/epythonlab\">EPYTHON LAB</a>.  All rights reserved.*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  },
  "widgets": {
   "application/vnd.jupyter.widget-state+json": {
    "state": {},
    "version_major": 2,
    "version_minor": 0
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}