Week1/PythonDataTypes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c482c40e",
   "metadata": {},
   "source": [
    "# Python data types"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c63d624e-9797-45e5-8bf3-a7adaaefb53a",
   "metadata": {},
   "source": [
    "We will be working with many different Python data types in Math 9, both built-in data types as well as data types defined in external libraries, like the library NumPy.  We'll start this portion of the class by introducing some of the many different data types."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bb73517",
   "metadata": {},
   "source": [
    "## lists and strings\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/w3HxawiC-7s\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ed881f3-5d58-4544-af41-dbd1ebda20bc",
   "metadata": {},
   "source": [
    "We start with two data types that seem very different but which share a lot of common functionality.\n",
    "\n",
    "We can indicate that an object is a string using quotation marks (either single or double quotation marks).  Here we define the variable `s` to be the string `\"Hello, world\"`.  You can check the type of an object by using the `type` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d40a4116",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello, world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "60f6a149",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "17677f62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a33f4ba-baff-4890-8e5f-45e0905bc77d",
   "metadata": {},
   "source": [
    "Just like we made a string by using quotation marks, here we make a list by using square brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "de96b9a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [3,1,4,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b52f59db",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c4325d0-d9ab-40dd-9e17-bc6d6f649eab",
   "metadata": {},
   "source": [
    "Here is one of the many similarities between strings and lists (as well as many other data types in Python): you can use the following indexing notation to extract a part of the object.  Notice that numbering in Python starts at 0.  I will usually try to refer to this as the \"zeroth\" element or the \"initial\" element.  For example, the initial element in the string `\"Hello, world\"` is the letter `\"H\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "6bf9751d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "18666d1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41e2f56e-4119-4228-8ad0-93b107f1c989",
   "metadata": {},
   "source": [
    "Another similarity between strings and lists is that both have a notion of length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "908add3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "a079b873",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25e9bf5b-11f0-46d4-b1fd-e35fbe18a9da",
   "metadata": {},
   "source": [
    "Because indexing starts at 0 and the string `s` has length 12, using `s[12]` will raise an error.  Unfortunately, many Python error messages are difficult to read, but this one is pretty clear, `IndexError: string index out of range`.  (I usually start reading at the bottom of the error message.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "03453b91",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "string index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_36568/387520648.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: string index out of range"
     ]
    }
   ],
   "source": [
    "s[len(s)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0fdbd3dd-6380-412d-9e5a-a1144deefc88",
   "metadata": {},
   "source": [
    "If you want to get the last element in a string (or list) `s`, you can use `s[len(s)-1]`, but much more common is to use the negative indexing shorthand `s[-1]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "ad76acfd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[len(s)-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dd219415",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "542c1211",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "53586413-a1c0-4d94-9ee0-84c6b6f78b6d",
   "metadata": {},
   "source": [
    "Another use of indexing is to get a sequence of elements (in a string, or a list, or ...).  Calling `s[1:4]` will include `s[1]`, `s[2]`, `s[3]`, but it will not include `s[4]`.  That is a common convention in Python: the right endpoint is usually not included.\n",
    "\n",
    "This type of indexing is called *slicing*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fcdf8b44",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ell'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6b66d070",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, world'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cee2ef1-7c11-4bdf-8c43-5e8a29a49fb9",
   "metadata": {},
   "source": [
    "The string `s[:5]` is the same as `s[0:5]`.  One benefit of the \"right endpoint is not included\" convention is that `s[:5]` will be length 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "597b1819",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "03ed430b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[0:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad012d35-59fb-4104-a130-23138e9617ec",
   "metadata": {},
   "source": [
    "Similarly, the notation `s[3:]` will go from the element `s[3]` to the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "3245a3ec",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'lo, world'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "841ba0c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 1]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "577adb07",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 4, 1]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c646700b-d2f8-4a2c-9c4f-7a8df6a2d03a",
   "metadata": {},
   "source": [
    "Another type of slicing will specify the step size (this is similar to the colon notation from Matlab, although with Python slicing, the step size goes at the end, whereas in Matlab the step size goes in the middle).  For example, `s[1:7:2]` will include `s[1]`, `s[3]`, `s[5]`, but not `s[7]` because right endpoints are not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "1b5952d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'el,'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:7:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "914d7af9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, world'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29fc5d1f-33e7-4e1a-be8a-eb821454d1bf",
   "metadata": {},
   "source": [
    "The following gets all the even-indexed elements in `s`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "248de4d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hlo ol'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abc16a40-0854-4325-a6aa-139cab4d5880",
   "metadata": {},
   "source": [
    "Similarly, `s[1::2]` gets all the odd-indexed elements in `s` (we start at index 1 and go up in steps of 2)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "8ae7725a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'el,wrd'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ceb0eb0",
   "metadata": {},
   "source": [
    "## lists, tuples, and sets\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/1UNVtDrO1Lc\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a94d82c-393d-433d-9cce-4e4f795f98f0",
   "metadata": {},
   "source": [
    "In the previous section, we considered two data types (lists and strings) which seem quite different.  Here we will look at three data types (lists, tuples, and sets) that on the surface seem very similar.  The difference between lists and tuples is more subtle, but sets are very different from these other two.\n",
    "\n",
    "As we already saw, you can construct a list using square brackets.  To construct a tuple, you can use round parentheses, and to construct a set you can use curly brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "92a8f756",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [3,1,4,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "33996f4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = (3,1,4,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "1ad0d058",
   "metadata": {},
   "outputs": [],
   "source": [
    "myset = {3,1,4,1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "59b0f1f1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mytuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "9681e2f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(myset)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "437ae80b-4f70-49d2-9ca8-0f3a88f79404",
   "metadata": {},
   "source": [
    "Here is a first difference with sets: like the mathematical notion of a set, sets in Python do not allow repeated elements.  Notice how there is only a single 1 shown in `myset`, even though we defined `myset` using `myset = {3,1,4,1}`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "da2ab2d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b6bdf9c2-83cd-4672-8077-5e890e9176b7",
   "metadata": {},
   "source": [
    "Here is a major difference between sets and the other two: sets do not support indexing.  This is because, like the mathematical notion of a set, sets in Python do not have a notion of order... there is no \"zeroth\" element in a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "82b31166",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_37067/435093538.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyset\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "myset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "db93d359",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "7ec40150",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ca2e11a-1855-449e-a206-aa6c4ff0dacb",
   "metadata": {},
   "source": [
    "Sets, tuples, and lists all have a notion of length."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7fe50c9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(mytuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "debf9256",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(myset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5c80d54a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b67754ab-1cf0-4d57-917f-dc4a06b50903",
   "metadata": {},
   "source": [
    "Here is a first difference between lists and tuples: you can change elements in a list but not in a tuple.  This is usually described as saying that tuples are \"immutable\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "a1663db6",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[2] = 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8a4d0b1b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 17, 1]"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "53a55d9f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mytuple[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7dd9302e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_37067/2796111138.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmytuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m17\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "mytuple[2] = 17"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37a4dce3-bcd3-4fb4-a359-00e9f6e5818c",
   "metadata": {},
   "source": [
    "Another consequence of lists being mutable and tuples being immutable is that lists have an `append` method and tuples do not.  (A *method* is very similar to a function.  It is like a function which is attached to a specific data type.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "d7bc046b",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist.append(8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "eb1075fa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 17, 1, 8]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "96f2c6a9",
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_37067/4200240113.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmytuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m8\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "mytuple.append(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7136f5f-36ed-4f76-94cf-d7ef0d1f4e0c",
   "metadata": {},
   "source": [
    "It might seem like lists are better than tuples in every way.  One key advantage of a tuple over a list is that you can use tuples in certain situations where lists are not allowed.  As an example, an element in a set is allowed to be a tuple, but you cannot put a list into a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "50065898",
   "metadata": {},
   "outputs": [],
   "source": [
    "newset = {3,1,(4,1)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "5cec3cf0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(newset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ec38d80b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(newset)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "e1cf3661",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_37067/4210761174.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnewset2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "newset2 = {3,1,[4,1]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e435d0c",
   "metadata": {},
   "source": [
    "## ranges and for loops\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/kgBLbHldfXQ\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d7ad7a7b-2594-4289-8aaf-36489a5cc14d",
   "metadata": {},
   "source": [
    "A Python range object is maybe a little more unusual (or at least more specialized) than the other Python data types we have seen before.  On the other hand, range objects usually show up very early when learning Python, because many of the most basic types of for loops are made using range objects.  Before we see those for loop examples using range objects, let's see some for loop examples using the data types we have already met."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "662f9d08",
   "metadata": {},
   "outputs": [],
   "source": [
    "mystring = \"Hello, world\"\n",
    "mylist = [3,1,4,1]\n",
    "mytuple = (3,1,4,1)\n",
    "myset = {3,1,4,1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "2b55581f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "4\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for x in mylist:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "194198b7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      ",\n",
      " \n",
      "w\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "for x in mystring:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9388bade-cd7b-4f2e-929e-6bc91fd91e75",
   "metadata": {},
   "source": [
    "It may come as a surprise that white space in Python is very meaningful.  For example, notice how all three of the following `print` statements are indented the same amount.  Python repeats each of these three `print` statements each iteration looping through the for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "182945de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "<class 'str'>\n",
      "1\n",
      "e\n",
      "<class 'str'>\n",
      "1\n",
      "l\n",
      "<class 'str'>\n",
      "1\n",
      "l\n",
      "<class 'str'>\n",
      "1\n",
      "o\n",
      "<class 'str'>\n",
      "1\n",
      ",\n",
      "<class 'str'>\n",
      "1\n",
      " \n",
      "<class 'str'>\n",
      "1\n",
      "w\n",
      "<class 'str'>\n",
      "1\n",
      "o\n",
      "<class 'str'>\n",
      "1\n",
      "r\n",
      "<class 'str'>\n",
      "1\n",
      "l\n",
      "<class 'str'>\n",
      "1\n",
      "d\n",
      "<class 'str'>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for x in mystring:\n",
    "    print(x)\n",
    "    print(type(x))\n",
    "    print(len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7702918-f684-4bcd-851d-126cb9235248",
   "metadata": {},
   "source": [
    "On the other hand, in the following, only the `print(x)` command is indented, so only that command is repeated by the for loop.  The other two `print` commands are executed after the for loop has completed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "75687d23",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      ",\n",
      " \n",
      "w\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n",
      "<class 'str'>\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for x in mystring:\n",
    "    print(x)\n",
    "print(type(x))\n",
    "print(len(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8d420b34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "1\n",
      "4\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for x in mytuple:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ab800d15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for x in myset:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f7b4045f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3, 4}"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faa18909-3fca-4277-994c-93ef1f76b0fc",
   "metadata": {},
   "source": [
    "Here is our first example of a range object.  In this case, it is used as a quick way to repeat the print statement 5 times."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9260682f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n",
      "Hello, world\n",
      "Hello, world\n",
      "Hello, world\n",
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hello, world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ae47efb-3e3e-4e23-97c4-1235b52c7658",
   "metadata": {},
   "source": [
    "We never used the `i` variable in the previous example.  Here is an example using the `i` variable.  The syntax is very similar to the slicing syntax from above: in particular, the step size comes at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "42568822",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "for i in range(2,10,3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7259077e-9a16-486b-b067-2382de55926e",
   "metadata": {},
   "source": [
    "You can just as easily move backwards (both in slicing and in range objects) by specifying a negative step size.  Notice that, like usual in Python, the right endpoint (3 in this case) is not included."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8cfa5b27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n",
      "5\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in range(10,3,-1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03a1a43d-c5a9-4936-9c28-9cc61def767e",
   "metadata": {},
   "source": [
    "The expression `range(10,3,-1)` above is its own type of object, a `range` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "2479947f",
   "metadata": {},
   "outputs": [],
   "source": [
    "myrange = range(10,3,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b183598f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(myrange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6eb5ed6b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(10, 3, -1)"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "bfb8eabf",
   "metadata": {},
   "outputs": [],
   "source": [
    "myrange2 = range(3,1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9a91c862",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myrange2[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "516d6b2f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "999"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myrange2[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55af0b17-2e2f-4ccc-b54c-4614afbbf75f",
   "metadata": {},
   "source": [
    "Range objects support slicing.  That's not too important; maybe the most interesting thing about slicing in the context of range objects is that it again produces a range object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "11ff2f0c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(13, 103, 4)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myrange2[10:100:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "933b7a15-ecbf-4e82-9073-fed55831ccc3",
   "metadata": {},
   "source": [
    "You can also compute the length of a range object, the same way as you can compute the length of a string, list, tuple, or set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "be4cc4b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "997"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(myrange2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db7408af",
   "metadata": {},
   "source": [
    "## ints, floats, and bools\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/MiESeoWkTWA\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a4432bf4-aadf-421c-9255-4fbbf4512087",
   "metadata": {},
   "source": [
    "We're almost done with what I consider the \"essential\" Python data types.  We will introduce three more data types in this section, and we will introduce dictionaries in the next section."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "9346f9ba",
   "metadata": {},
   "outputs": [],
   "source": [
    "z = 10/2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3eab64e-e405-4c20-ad62-5fadc8ae30e8",
   "metadata": {},
   "source": [
    "The result of the following expression is the Boolean value `True`.  Be sure to notice that the word `True` is capitalized (and be sure not to put it in quotation marks; it is not a string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8b7ee7ab",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "604742de",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c93f049",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'true' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_45994/592217714.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'true' is not defined"
     ]
    }
   ],
   "source": [
    "true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7a6a34e4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "74508a52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f6418b6-2938-487f-90dd-88096f12c85c",
   "metadata": {},
   "source": [
    "Because `z == 5` is `True`, you probably expect `range(z)` to work the same as `range(5)`, but there is a subtle difference.  The problem is that because `z` was defined as `10/2`, Python set its data type as a floating point number (like a decimal, not an integer), and range objects can only be created using integers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "f11c258b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 5)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "range(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1c420ff7",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'float' object cannot be interpreted as an integer",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_45994/374006378.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer"
     ]
    }
   ],
   "source": [
    "range(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "c58c6e1a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "249f2b46",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5d295371-92e1-477e-b94f-4c8941609de0",
   "metadata": {},
   "source": [
    "Because computers can only specify decimals (floats, real numbers) to a finite degree of precision, some subtleties are inevitable.  One consequence is that it is almost never correct to ask if two floating points are equal.  Here is an example where two floats are obviously mathematically equal, but Python reports them as being unequal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "85691c96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(0.1 + 0.1 + 0.1) == 0.3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebb43636",
   "metadata": {},
   "source": [
    "## dictionaries\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/t2CNZ80OGLg\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3f8a4f18-e511-4979-a8b4-877d2d2a1d4d",
   "metadata": {},
   "source": [
    "The last built-in Python data type I want to introduce in this portion of the class is the dictionary data type.  Here is an example of constructing a dictionary.  The portions before the colons are called \"keys\" and the portions after the colons are called \"values\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "753a8aec",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {\"A\": 90, \"B\": 80, \"C\": 70, \"D\": 60, \"F\": 0}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "92421e41",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "78103ad0-5202-4a50-8f3e-36353825b66e",
   "metadata": {},
   "source": [
    "The next two errors are saying that `20` and `0` (the integers, not the strings) do not occur as keys in `d`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f50195e6",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "20",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_50443/1661466599.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m20\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 20"
     ]
    }
   ],
   "source": [
    "d[20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "99901ddd",
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "0",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_50443/1089268471.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 0"
     ]
    }
   ],
   "source": [
    "d[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cee0626c-dd2f-444c-8fa7-c66489eacf6a",
   "metadata": {},
   "source": [
    "Here is an example of adding a new key to the dictionary.  Notice how it gets displayed without quotation marks, because `0` is not the same as `\"0\"` (the first one is an integer, while the second one is a string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "f45480e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[0] = [3,1,4,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "55f54cfe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 90, 'B': 80, 'C': 70, 'D': 60, 'F': 0, 0: [3, 1, 4, 1]}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c24d03bb-876e-4d76-ab46-884b1c3b2e4a",
   "metadata": {},
   "source": [
    "We can also change a value associated to a key using the same kind of syntax.  Notice how the old value gets deleted; there cannot be repeated keys in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "50cbe774",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"B\"] = 85"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a7e3184a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 90, 'B': 85, 'C': 70, 'D': 60, 'F': 0, 0: [3, 1, 4, 1]}"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2781274-68db-4e02-ab66-47e7b065f0ef",
   "metadata": {},
   "source": [
    "I probably should have done this earlier, but here is how you access the value associated for example to the key `\"C\"`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "fde7f5d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "70"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d[\"C\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90125b50-1169-4919-833a-853c71c65e6b",
   "metadata": {},
   "source": [
    "Here we add a new key, and the value is itself a dictionary.  The two things to notice in this next example are that both `0` and `\"0\"` show up as keys, and that a dictionary can be a value in a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "110d31ee",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"0\"] = {\"hello\": \"first word\", \"world\": \"second word\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "a83fb404",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 90,\n",
       " 'B': 85,\n",
       " 'C': 70,\n",
       " 'D': 60,\n",
       " 'F': 0,\n",
       " 0: [3, 1, 4, 1],\n",
       " '0': {'hello': 'first word', 'world': 'second word'}}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07fdbaa1-f45c-445a-bd0f-832feeed1885",
   "metadata": {},
   "source": [
    "Remember that lists were not allowed to go in sets, but tuples were allowed.  It is the same with keys in dictionaries.  (Values in dictionaries can be anything, but there are restrictions on keys; the same restrictions as on elements in sets.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d5964c4c",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_50443/1236779418.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "myset = {3,1,[4,1]}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "ff59721b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(4, 1), 1, 3}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{3,1,(4,1)}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e99288e-3aa7-439e-bff1-08c0b3fdda35",
   "metadata": {},
   "source": [
    "We get the exact same error if we try to make the list `[4,1]` a key in our dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "d55277d6",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_50443/746167574.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "d[[4,1]] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2001d23-591b-4d0c-96bf-769180371220",
   "metadata": {},
   "source": [
    "But making the tuple `(4,1)` a key in our dictionary works fine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "eb3a4f83",
   "metadata": {},
   "outputs": [],
   "source": [
    "d[(4,1)] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "f8f01194",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A': 90,\n",
       " 'B': 85,\n",
       " 'C': 70,\n",
       " 'D': 60,\n",
       " 'F': 0,\n",
       " 0: [3, 1, 4, 1],\n",
       " '0': {'hello': 'first word', 'world': 'second word'},\n",
       " (4, 1): 1}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b664951",
   "metadata": {},
   "source": [
    "## Converting from one type to another\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/nCx1VB-vSUo\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "68843aa8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [3,1,4,1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d0a3782-04ab-4e00-881a-a9ae5cedfff6",
   "metadata": {},
   "source": [
    "Here is the syntax for creating a tuple out of `mylist`.  Notice that it does not actually change the value of `mylist` itself.  (If something gets displayed as a result of the operation, as `(3,1,4,1)` does in this case, that is often a hint that the original object did not change.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5ba4b542",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1, 4, 1)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tuple(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "edefb9a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f95a92d-a4d9-4c41-9cd2-b0fce22a20d1",
   "metadata": {},
   "source": [
    "If you actually want to be able to use that tuple you've created, you need to save it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "955e839f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tuple(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ef463d05",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "7a2bb629",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1, 4, 1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46a1a288-eeeb-4226-aaa7-59fd1a54fdb2",
   "metadata": {},
   "source": [
    "Many of the objects we have seen so far can be converted into other data types.  For example, this is what happens when you convert from a string to a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b45a5503",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"Hello world\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8c0ddf0e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25e6f7b4-b30b-4a16-8882-3c01d8da7b7b",
   "metadata": {},
   "source": [
    "Maybe you would have expected to get a list of words instead of a list of characters.  The fact that we get a list of characters is very similar to what happens if we iterate over the elements in the string using a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9bca9a37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "H\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n",
      " \n",
      "w\n",
      "o\n",
      "r\n",
      "l\n",
      "d\n"
     ]
    }
   ],
   "source": [
    "for x in s:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b10922e-b196-42f8-82f2-eaf0f6583d17",
   "metadata": {},
   "source": [
    "Here is an example where conversion does not work.  This particular list `mylist` cannot be converted to a dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "db1af0cf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 1, 4, 1]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e493c5b1",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "cannot convert dictionary update sequence element #0 to a sequence",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/8j/gshrlmtn7dg4qtztj4d4t_w40000gn/T/ipykernel_50904/677643877.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmylist\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: cannot convert dictionary update sequence element #0 to a sequence"
     ]
    }
   ],
   "source": [
    "dict(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c879f9a4-5edd-4a44-848d-36603fe16fe6",
   "metadata": {},
   "source": [
    "Some lists can be converted to a dictionary.  For example, this list of length-2 tuples can be converted.  Python interprets the 0th element in each tuple as the key and the 1st element in each tuple as the value.  (Remember that keys can't be repeated in a dictionary, which is why we only see the key `1` one time.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "50a0951b",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist2 = [(3,\"a\"),(1,\"b\"),(1,\"c\")]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "974ab56c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{3: 'a', 1: 'c'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(mylist2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dce9d37f-fa23-4b7f-b159-fbb38e61eb47",
   "metadata": {},
   "source": [
    "A surprisingly useful conversion (that is often done automatically) is going from the Boolean values `True` and `False` to the integer values `1` and `0` (respectively).  One reason this is useful is that if you add together the elements in a list or array of Trues and Falses, the result will be exactly the number of Trues."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "84d7eb9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0c096fef",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(False)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9d6709c-a9ad-40d5-a192-c0fad0b3c8cc",
   "metadata": {},
   "source": [
    "You can also add an integer to a Boolean value, and Python will automatically convert the Boolean value to an integer before doing the addition.  This functionality itself is not very important, but it's very important to remember in general that `True` corresponds to `1` and that `False` corresponds to `0`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "e4e4c7d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4+True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6638f5a7",
   "metadata": {},
   "source": [
    "## Timing comparisons\n",
    "\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/oxYzQwF97QM\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06962e74-bd62-46a0-9ac4-bcd03c0e10c8",
   "metadata": {},
   "source": [
    "A fundamental example of sets over lists and tuples is that you can search in a set much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "6088e578",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000000"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10000000"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "221ffb53-3be6-44e1-b2e3-715e3b3932a2",
   "metadata": {},
   "source": [
    "That integer is pretty hard to read.  Notice that we **cannot** make exponents in Python using the caret symbol, instead you have to use `**`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8bad58bd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10^7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "2daccfc9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000000"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10**7"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "127edac5-87a5-4501-a16d-bec2dbb44d8f",
   "metadata": {},
   "source": [
    "Let's make a range object and convert it into a list, into a tuple, and into a set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "3229cc92",
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(0,10**7,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c0d26a72",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = list(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b8f7c61d",
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = tuple(r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "29152dff",
   "metadata": {},
   "outputs": [],
   "source": [
    "myset = set(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "058df631-b67f-4c14-b6b9-aa7f9623b891",
   "metadata": {},
   "source": [
    "Here we use the operator `in` to check if `0` is in the corresponding object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9056ff76",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 in mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6d670e3b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 in mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e0d8dfa-10a9-46f7-bb6c-82adc6b4f583",
   "metadata": {},
   "source": [
    "Here is a special feature of Jupyter notebooks, where we can time how long an operation takes.  I usually only pay attention to the left-most number, which in this case says 36.2 nanoseconds, where one nanosecond is $10^{-9}$ seconds."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "b9fe2009",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36.2 ns ± 0.455 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "0 in mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd2314f-bd8d-49f6-98b1-ed69b1faf009",
   "metadata": {},
   "source": [
    "Very similar speed for checking in `mytuple`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fd285094",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "38.4 ns ± 1.95 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "0 in mytuple"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2369cb9-2e4c-4324-a533-8e57b8037e3a",
   "metadata": {},
   "source": [
    "I said that checking in a set was faster, but it doesn't seem to be, it's actually slower in this case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "348c8146",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42.9 ns ± 1.54 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "0 in myset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "69195ca0-d039-465d-b04f-c180730a14c6",
   "metadata": {},
   "source": [
    "But the reason checking for `0` was fast in the above examples was because Python could find the element `0` very quickly, since it was at the beginning of the set and the beginning of the tuple.  If we instead check for `1`, which is not in the list (or the tuple or the set), then we will see that the set version of searching is much faster.  Notice that the unit for the list version is `ms` rather than `ns`, which represents $10^{-3}$ seconds.  So in this case, the set version is about one million (!) times faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "096ac0e4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55.2 ms ± 4.64 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "1 in mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8fb8fb64",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.1 ns ± 1.09 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "1 in myset"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0b9ae57d-525e-470f-9230-903fa8268946",
   "metadata": {},
   "source": [
    "The fact that we can search in a set very fast is related to the restrictions on the elements that can go in a set.  (For example, remember that we are not allowed to put a list into a set.)  For the same underlying reason, searching for a key in a dictionary is also very fast."
   ]
  }
 ],
 "metadata": {
  "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.10.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}