day-1-introduction-to-python-part-I/04 - Lists, Tuples and Sets.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:49:08.930236Z",
     "start_time": "2019-07-01T12:49:08.924607Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunss.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-weight: bold;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsx.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-style: oblique;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunsi.otf');\n",
       "    }\n",
       "    @font-face {\n",
       "        font-family: \"Computer Modern\";\n",
       "        font-weight: bold;\n",
       "        font-style: oblique;\n",
       "        src: url('http://9dbb143991406a7c655e-aa5fcb0a5a4ec34cff238a2d56ca4144.r56.cf5.rackcdn.com/cmunso.otf');\n",
       "    }\n",
       "    h1 {\n",
       "        font-family: Helvetica, serif;\n",
       "    }\n",
       "    h4{\n",
       "        margin-top:12px;\n",
       "        margin-bottom: 3px;\n",
       "       }\n",
       "    div.text_cell_render{\n",
       "        font-family: Computer Modern, \"Helvetica Neue\", Arial, Helvetica, Geneva, sans-serif;\n",
       "        line-height: 145%;\n",
       "        font-size: 130%;\n",
       "        margin-left:auto;\n",
       "        margin-right:auto;\n",
       "    }\n",
       "    .CodeMirror{\n",
       "            font-family: \"Source Code Pro\", source-code-pro,Consolas, monospace;\n",
       "    }\n",
       "    .text_cell_render h5 {\n",
       "        font-weight: 300;\n",
       "        font-size: 22pt;\n",
       "        color: #4057A1;\n",
       "        font-style: italic;\n",
       "        margin-bottom: .5em;\n",
       "        margin-top: 0.5em;\n",
       "        display: block;\n",
       "    }\n",
       "    \n",
       "    .warning{\n",
       "        color: rgb( 240, 20, 20 )\n",
       "        }  \n",
       "</style>\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"]\n",
       "                           },\n",
       "                tex2jax: {\n",
       "                    inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                    displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                },\n",
       "                displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                \"HTML-CSS\": {\n",
       "                    styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                }\n",
       "        });\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling():\n",
    "    #Can use `presentation.css` or `custom.css`\n",
    "    styles = open(\"../Data/www/styles/custom.css\", \"r\").read()\n",
    "    return HTML(styles)\n",
    "css_styling()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Synopsis\n",
    "\n",
    "In this unit we will learn about three of the four collection data types in Python.\n",
    "\n",
    "1. **Lists** are ordered sequences of elements, with that order being specified by the order that the elements are in when the list is created or as elements are added to the list.  \n",
    "\n",
    "    1. Lists are created using the `[]` syntax.\n",
    "    \n",
    "    2. Lists can include mixed data types.\n",
    "    \n",
    "    4. List elements are accessed by index.\n",
    "    \n",
    "    3. Lists are **mutable**. You can add, remove, and replace values using functions such as `append()`, `extend()`, `insert()`, `pop()`, `remove()`, and `del`. \n",
    "    \n",
    "2. **Tuples** are similar to lists except for the very important fact that they are **immutable**.\n",
    "\n",
    "3. **Sets** are unordered collections of elements.\n",
    "\n",
    "    1. Sets are created using the `{}` syntax.\n",
    "    \n",
    "    2. Sets can included mixed data types.\n",
    "    \n",
    "    3. Set elements are accessed by key (name).\n",
    "    \n",
    "    4. Elements in a set cannot be repeated.\n",
    "    \n",
    "    5. Sets are are **mutable**. You can add and remove values using functions such as `add()` and `discard()`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "+++"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Collection Data Types\n",
    "\n",
    "Python has four collection data types:\n",
    "\n",
    "* Lists\n",
    "* Tuples\n",
    "* Sets\n",
    "* Dictionaries\n",
    "\n",
    "These data types allow for a greater number of operations because they can hold multiple elements.  In order to ease into deadling with collections, we will first recall some properties of another collection data type: strings.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:49:17.961390Z",
     "start_time": "2019-07-01T12:49:17.958504Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "introduction = \"Well, I thought that, maybe, you know, like, possibly?\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now this introduction has a little lyrical flourish if you will, it has a large number of pauses as indicated by the commas. What if you wanted to get rid of those pesky commas?\n",
    "\n",
    "You learned earlier that the `strip()` function can remove characters from the beginning or from the end of a string. Unfortunately, the commas are in the middle of the introduction so, `strip()` will not work.  \n",
    "\n",
    "There is, however, another function that we can use to split apart a `string`. It is aptly labelled the `split()` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:50:54.153772Z",
     "start_time": "2019-07-01T12:50:54.149139Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "['Well', ' I thought that', ' maybe', ' you know', ' like', ' possibly?']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print( type( introduction ) )\n",
    "new_variable = introduction.split(',')\n",
    "print( new_variable )\n",
    "print( type( new_variable ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`introduction` is a string. Check.\n",
    "\n",
    "`new_variable` is **not** a string. It is a list! \n",
    "\n",
    "Unlike the `strip()` function, the `split()` function returns a list. Each element in the list contains a string with the set of characters found between consecutive occurrences of the character used to break the original string.\n",
    "\n",
    "We can tell that it's a list because it has multiple elements and it starts and ends with the brackets. The bracket symbol (`[]`) is used to denote a list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "A list is an ordered sequence of elements, with that order being specified by the order that the elements are in when the list is created or as elements are added to the list. We create a list by using the `[]` syntax.\n",
    "\n",
    "Let's go back to our obsession with pets, and imagine we own a pet store that carries a number of different species of pets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:16.009672Z",
     "start_time": "2019-07-01T12:58:16.004973Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dogs', 'cats', 'fish']\n",
      "dogs\n",
      "cats\n"
     ]
    }
   ],
   "source": [
    "pets = ['dogs', 'cats', 'fish']\n",
    "print( pets )\n",
    "print( pets[0] )\n",
    "print (pets[1] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the list printed the elements in the same order in which they were created. Unlike strings, **lists are mutable**. Thus, we can change them. \n",
    "\n",
    "If we want to add an element to the list, we `append()` the new element to the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:16.536316Z",
     "start_time": "2019-07-01T12:58:16.530218Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs', 'cats', 'fish', 'hedgehog']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets.append('hedgehog')\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to add several new elements?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:17.032256Z",
     "start_time": "2019-07-01T12:58:17.027107Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs', 'cats', 'fish', 'hedgehog', ['parrot', 'iguana']]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets.append(['parrot', 'iguana'])\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is not what I had in mind, I wanted to add 'parrot' and 'iguana', not the list `['parrot', 'iguana']`. If we want to add multiple additional values, we can either append them one by one, or we can `extend()` our list `pets` with the list of additional pets that our pet shop carries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:17.534880Z",
     "start_time": "2019-07-01T12:58:17.527733Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs', 'cats', 'fish', 'hedgehog', 'parrot', 'iguana']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets.remove(['parrot', 'iguana'])\n",
    "pets.extend(['parrot', 'iguana'])\n",
    "\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add two lists together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:18.070128Z",
     "start_time": "2019-07-01T12:58:18.065514Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs', 'cats', 'fish', 'hedgehog', 'parrot', 'iguana']"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets + ['chameleon', 'hamster']\n",
    "\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But notice that the addition symbol doesn't change the value of `pets`. If we want to add to the list variable, we just set it equal to itself and the new list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:18.764734Z",
     "start_time": "2019-07-01T12:58:18.757450Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs',\n",
       " 'cats',\n",
       " 'fish',\n",
       " 'hedgehog',\n",
       " 'parrot',\n",
       " 'iguana',\n",
       " 'chameleon',\n",
       " 'hamster']"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets = pets + ['chameleon', 'hamster']\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And just like strings, we can use both of the additive math operators. I'll use a small number here so as not to flood the screen, but we can multiply the list too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:19.859486Z",
     "start_time": "2019-07-01T12:58:19.850189Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dogs', 'cats', 'fish', 'hedgehog', 'parrot', 'iguana', 'chameleon', 'hamster', 'dogs', 'cats', 'fish', 'hedgehog', 'parrot', 'iguana', 'chameleon', 'hamster']\n"
     ]
    }
   ],
   "source": [
    "print( pets * 2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As for strings, subtraction and division are not implemented for lists.  The reason is that it is not clear what subtracting two lists should produce."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:20.341465Z",
     "start_time": "2019-07-01T12:58:20.333187Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for -: 'list' and 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m----------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-6423e0300905>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpets\u001b[0m \u001b[0;34m-\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m'hamster'\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: unsupported operand type(s) for -: 'list' and 'list'"
     ]
    }
   ],
   "source": [
    "pets - ['hamster']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing and Slicing\n",
    "\n",
    "Since a list comprises multiple elements, just as a string comprises multiple chracters, it is helpfuul to be able to access a single element by its index or to access a section of the list using slicing. To access an element by its index we use the syntax: `variable[index]`.\n",
    "\n",
    "As for strings, you cannot attempt to access an index that has not been defined.  In order to avoid that kind of mistake it is useful to keep track of the number of elements in a list.  You can obtain this number using the built-in function `len()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:22.125759Z",
     "start_time": "2019-07-01T12:58:22.115186Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cats\n",
      "8\n",
      "hamster\n"
     ]
    },
    {
     "ename": "IndexError",
     "evalue": "list 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<ipython-input-38-2480b951ce0d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpets\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[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mpets\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mpets\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[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m \u001b[0mpets\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m9\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: list index out of range"
     ]
    }
   ],
   "source": [
    "print( pets[1] )\n",
    "print( len(pets) )\n",
    "print( pets[len(pets)-1] )\n",
    "print( pets[9] )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to obtain a access a section of a list, we use the slicing syntax  `variable[start_index : stop_index : step]`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:22.629104Z",
     "start_time": "2019-07-01T12:58:22.624620Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['cats', 'fish']"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets[1 : 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Because lists are mutable, we can not only add and remove elements, we can also change the value of the elements. Let's say that we stopped selling cats because everyone just looks at them on the internet and now we carry sea monkeys. We could delete `cats` and append `sea monkeys` or we could just replace `cats` in the list with `sea monkeys`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:23.567849Z",
     "start_time": "2019-07-01T12:58:23.562784Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs',\n",
       " 'sea monkeys',\n",
       " 'fish',\n",
       " 'hedgehog',\n",
       " 'parrot',\n",
       " 'iguana',\n",
       " 'chameleon',\n",
       " 'hamster']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets[1] = 'sea monkeys'\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes, we know that a certain value is included in a list but do not know its index in the list. If we want to find out the index of a given value, we use the built-in function `index()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:24.256083Z",
     "start_time": "2019-07-01T12:58:24.251494Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets.index('fish')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adding and removing elements from a list\n",
    "\n",
    "Python provides several methods for changing the contents of a list.  We will first look at `insert()` and `pop()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:25.268293Z",
     "start_time": "2019-07-01T12:58:25.261706Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs',\n",
       " 'sea monkeys',\n",
       " 'fish',\n",
       " 'hedgehog',\n",
       " 'parrot',\n",
       " 'leopard',\n",
       " 'iguana',\n",
       " 'chameleon',\n",
       " 'hamster']"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets.insert(5, 'leopard')\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wait, it is illegal to have leopards as pets. Better take it out from our list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:27.391350Z",
     "start_time": "2019-07-01T12:58:27.386803Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "leopard\n",
      "['dogs', 'sea monkeys', 'fish', 'hedgehog', 'parrot', 'iguana', 'chameleon', 'hamster']\n"
     ]
    }
   ],
   "source": [
    "illegal_pet = pets.pop(5)\n",
    "print( illegal_pet )\n",
    "print( pets )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how popping an element, returns its value.  A limitation of `pop()` is that we must know the index of the value we want to remove. If we do not have that knowledge, then we can use the function `remove()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:35.197108Z",
     "start_time": "2019-07-01T12:58:35.192748Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dogs', 'sea monkeys', 'hamster', 'fish', 'hedgehog', 'parrot', 'iguana', 'chameleon', 'hamster']\n",
      "None\n",
      "['dogs', 'sea monkeys', 'fish', 'hedgehog', 'parrot', 'iguana', 'chameleon', 'hamster']\n"
     ]
    }
   ],
   "source": [
    "pets.insert(2, 'hamster')\n",
    "print( pets )\n",
    "\n",
    "removed_pet = pets.remove('hamster')\n",
    "print( removed_pet ) \n",
    "print( pets )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the function `remove()` does not return anything. This makes sense since we already know the value we are removing.\n",
    "\n",
    "Notice also that `remove()` will only remove the **first** instance of the value in a list. If there is more than one entry then you would need to use remove again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:43.841747Z",
     "start_time": "2019-07-01T12:58:43.836436Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs', 'sea monkeys', 'fish', 'hedgehog', 'parrot', 'iguana', 'chameleon']"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets.remove('hamster')\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you try to remove a value and it doesn't exist then Python will return an error and stop execution of the code.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:58:49.549517Z",
     "start_time": "2019-07-01T12:58:49.537016Z"
    }
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "list.remove(x): x not in list",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m----------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                           Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-46-22b6fd6300ac>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpets\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'hamster'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mpets\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: list.remove(x): x not in list"
     ]
    }
   ],
   "source": [
    "pets.remove('hamster')\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to remove elements from a list is with the command `del`. However, `del` is a sort of nuclear option. If we do not provide an an index though it will delete the **entire** variable from memory! **Be careful when you use `del`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:59:04.031332Z",
     "start_time": "2019-07-01T12:59:04.026124Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs', 'sea monkeys', 'fish', 'hedgehog', 'parrot', 'iguana']"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del pets[-1]\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ordering lists\n",
    "\n",
    "Lists have other built-in methods too besides the maintenance functions of adding and deleting elements. For example, you can reverse a list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:59:24.530572Z",
     "start_time": "2019-07-01T12:59:24.526258Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial pets ['iguana', 'parrot', 'hedgehog', 'fish', 'sea monkeys', 'dogs']\n",
      "Reversed pets ['dogs', 'sea monkeys', 'fish', 'hedgehog', 'parrot', 'iguana']\n"
     ]
    }
   ],
   "source": [
    "print('Initial pets', pets)\n",
    "pets.reverse()\n",
    "print('Reversed pets', pets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The elements in a list can also be sorted.  If the elements are numbers that the standard ordering of numbers is used. If the elements are string, then alphanumeric ordering is used."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T12:59:33.746036Z",
     "start_time": "2019-07-01T12:59:33.741522Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial pets ['dogs', 'sea monkeys', 'fish', 'hedgehog', 'parrot', 'iguana']\n",
      "Sorted pets ['dogs', 'fish', 'hedgehog', 'iguana', 'parrot', 'sea monkeys']\n"
     ]
    }
   ],
   "source": [
    "print('Initial pets', pets)\n",
    "pets.sort()\n",
    "print('Sorted pets', pets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that the methods `sort()` and `reverse()` act on the variable directly.  If you want to keep the original variable unchanged, you must use the built-in functions  `sorted()` and `reversed()`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:00:02.013495Z",
     "start_time": "2019-07-01T13:00:02.009730Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list_reverseiterator'>\n",
      "<list_reverseiterator object at 0x10c037eb8>\n"
     ]
    }
   ],
   "source": [
    "print( type(reversed(pets)) )\n",
    "print( reversed(pets) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The output of the function `reversed()` is not a list. It is what Python calls an `iterator`, this is just a rule for generating values from some input. The advantage of `iterators` is that they require less memory and may be faster???\n",
    "\n",
    "However, if we want to have a human readable printout, we need to cast the iterator as a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:00:11.130741Z",
     "start_time": "2019-07-01T13:00:11.124613Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Reversing the list ['sea monkeys', 'parrot', 'iguana', 'hedgehog', 'fish', 'dogs']\n",
      "The original list ['dogs', 'fish', 'hedgehog', 'iguana', 'parrot', 'sea monkeys']\n"
     ]
    }
   ],
   "source": [
    "print( \"Reversing the list\", list( reversed(pets) ) )\n",
    "\n",
    "print( \"The original list\", pets )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "On the surface, tuples appear similar to `list`:\n",
    "\n",
    "* Both Tuples and Lists contain a sequence of individual elements\n",
    "* Both Tuples and Lists are stored in the order that they were added\n",
    "* Both Tuples and Lists can store mixed data types\n",
    "* We access individual elements with the syntax `variable[index]`\n",
    "\n",
    "So what is the difference? \n",
    "\n",
    "The big difference is that tuples are an **immutable** data type (like strings). This means that none of the functions that are built-in to modify variables can be applied to tuples.\n",
    "\n",
    "In order to indicate this **crucial** difference between lists and tuples, Python uses a different syntax to create a tuple.\n",
    "The syntax for creating a `list` uses `[]`. The syntax to create a `tuple` uses `()`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:01:47.349577Z",
     "start_time": "2019-07-01T13:01:47.343588Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(60, 75, 'yellow')"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a tuple that stores the attributes of our golden retriever, `penny`.\n",
    "\n",
    "penny = (60, 75, 'yellow') #Length (in), Weight (lbs), Color \n",
    "print( type(penny) )\n",
    "penny"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that since it isn't necessarily clear what each of the individual elements stood for in the tuple, I added a comment listing the meaning of each field. As we discussed earlier, comments are signaled in Python by the symbol `#` Whatever you type in a line after the `#` will be ignored by the Python interpreter.\n",
    "\n",
    "Because tuples are immutable element assignment does not work."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:01:56.516376Z",
     "start_time": "2019-07-01T13:01:56.507669Z"
    },
    "scrolled": true
   },
   "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<ipython-input-56-49c9f7e1255b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mpenny\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[0;34m'amber'\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": [
    "penny[-1] = 'amber'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:02:15.272827Z",
     "start_time": "2019-07-01T13:02:15.264898Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object doesn't support item deletion",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m----------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-58-3dca6067f55e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mpenny\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[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
     ]
    }
   ],
   "source": [
    "del penny[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "and neither does element removal.  However, We can still perform the additive operators with tuples though"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:02:49.796340Z",
     "start_time": "2019-07-01T13:02:49.790438Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(60, 75, 'yellow')\n",
      "(60, 75, 'yellow', 'amber', 'stinky')\n"
     ]
    }
   ],
   "source": [
    "penny + ('amber', 'stinky') #Eye color, breath smell\n",
    "print( penny )\n",
    "\n",
    "penny2 = penny + ('amber', 'stinky')\n",
    "print( penny2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason is that when we add something to a tuple we are not changing the tuple, we are creating a new tuple. Notice that if we do not copy the new tuple into a new variable, then it is lost ot us.\n",
    "\n",
    "Another subtlety with tuples is that they require a non-obvious syntax when they have a single element.  Specifically, a tuple with a single element must be written as using the syntax `(value, )`. Without the comma, the Python interpreter would decide that we are using the `()` in the context of a mathematical operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:02:53.299367Z",
     "start_time": "2019-07-01T13:02:53.290412Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60, 75, 'yellow', 'amber')"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "penny + ('amber', )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### So wait, why are there both lists and tuples? \n",
    "\n",
    "I know, right now it's pretty hard to see why you would use one data type over the other. \n",
    "\n",
    "Remember that Python was developed with the ideal of being readable and understandable. That means that when you are writing code, you want to make choices that make it easy for others to understand what is going on. For example, if you have a some variable that contains values that are never going to change, then why would you use a mutable data type such as a list to store it?  \n",
    "\n",
    "Think of the days of the week or the months of the year: Does it make more sense to define\n",
    "\n",
    "`days_of_the_week = (\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\")`\n",
    "\n",
    "or \n",
    "\n",
    "`days_of_the_week = [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"]`?\n",
    "\n",
    "By using a tuple to store some data, you are signaling to a reader of your code, that the values you stored are not going to change during the execution of your code."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets\n",
    "\n",
    "A Python set is an unordered collection that prevents the repetition of values from occurring.  To create a `set` we use the syntax `{}`. \n",
    "\n",
    "Why do we need sets? Imagine, for example, that you want to store the names of your friends; you will want to use a list since you might have several friends named Mary.  However, if you are storing the city in which your friends live, you do not want the same city repeated several times. If you want to find out cities to visit where you have friends you only need the city name in there once.\n",
    "\n",
    "Let us see this in play with our pet store.  We want to keep track of what pet species we have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:04:32.962272Z",
     "start_time": "2019-07-01T13:04:32.957225Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'bulldog', 'hamster', 'parrot'}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pet_species = {'bulldog', 'hamster', 'parrot'}\n",
    "pet_species"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The way to add an element to a set is using the function `add()`. However, if we try to add an element that already exists in the set, that element will just be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:04:52.892957Z",
     "start_time": "2019-07-01T13:04:52.888103Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'hamster', 'bulldog', 'crocodile', 'parrot'}\n",
      "{'hamster', 'bulldog', 'crocodile', 'parrot'}\n"
     ]
    }
   ],
   "source": [
    "pet_species.add('crocodile')\n",
    "print( pet_species )\n",
    "pet_species.add('crocodile')\n",
    "print( pet_species )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sets are also **mutable**, like a `list`. However, they don't use the same built-in functions. To add an item, you use the built-in function `add()`. T remove an element, you use the built-in function `discard()`.  Notice, however, that **sets cannot be added or multiplied**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:05:19.216801Z",
     "start_time": "2019-07-01T13:05:19.212660Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'crocodile', 'bulldog', 'gerbil', 'hamster', 'parrot'}\n",
      "{'bulldog', 'gerbil', 'hamster', 'parrot'}\n"
     ]
    }
   ],
   "source": [
    "pet_species.add('gerbil')\n",
    "print( pet_species )\n",
    "pet_species.discard('crocodile')\n",
    "print( pet_species )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Other set operations\n",
    "\n",
    "Another class of operations that can be performed on sets are `intersection`, `union`, and `difference`. These operations are identical to their homonymous functions in the mathematics of sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:07:05.080910Z",
     "start_time": "2019-07-01T13:07:05.075634Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fish', 'parrot'}\n",
      "{'fish', 'bulldog', 'terrier', 'cat', 'hamster', 'parrot'}\n",
      "{'hamster', 'bulldog'}\n",
      "{'cat', 'terrier'}\n"
     ]
    }
   ],
   "source": [
    "store_one = {'bulldog', 'parrot', 'hamster', 'fish'}\n",
    "store_two = {'fish', 'parrot', 'terrier', 'cat'}\n",
    "\n",
    "print( store_one.intersection(store_two) )\n",
    "\n",
    "print( store_one.union(store_two) )\n",
    "\n",
    "print( store_one.difference(store_two) )  # A - B = A - (A intersection B)\n",
    "\n",
    "print( store_two.difference(store_one) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that while `intersection` and `union` are symmetrical -- for example, `A.union(B) = B.union(A)` -- the same is not true for `difference`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Changing types across sets, lists, and tuples\n",
    "\n",
    "Since `sets`, `lists`, and `tuples` are all collections of elements, Python allows us to easily convert variables from one type to another as needed. You just need to cast the variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:07:26.179044Z",
     "start_time": "2019-07-01T13:07:26.175171Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['fish', 'hamster', 'bulldog', 'parrot']\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "list_store_one = list( store_one )\n",
    "print( list_store_one )\n",
    "print( type(list_store_one) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:07:48.445136Z",
     "start_time": "2019-07-01T13:07:48.439089Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('fish', 'hamster', 'bulldog', 'parrot')\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "tuple_store_one = tuple( store_one )\n",
    "print( tuple_store_one )\n",
    "print( type(tuple_store_one) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:07:56.403065Z",
     "start_time": "2019-07-01T13:07:56.398952Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'fish', 'hamster', 'bulldog', 'parrot'}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "reset_store_one = set(tuple_store_one)\n",
    "print( reset_store_one )\n",
    "print( type(reset_store_one) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nesting\n",
    "\n",
    "So far, most of the elements that we have added to our collections have been `string`, `float`, or `integer` data types. However, the elements of a collections can be collections themselves. Indeed, we can include any data type inside a `tuple` or a `list` or even a `set`.  This process is called **nesting** and it is a bit like Russian dolls.\n",
    "\n",
    "<img width='400' style=\"float:center\" src='../Data/www/images/nesting_dolls.jpg')></img>\n",
    "\n",
    "Let's see nesting at play.  Going back to our pet store, assume that our costumers are picky and care about the breed of the dog they want to buy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:08:26.680633Z",
     "start_time": "2019-07-01T13:08:26.672130Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dogs', 'fish', 'hedgehog', 'iguana', 'parrot', 'sea monkeys']\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['dogs',\n",
       " 'hedgehog',\n",
       " 'iguana',\n",
       " 'parrot',\n",
       " 'sea monkeys',\n",
       " ['bulldog', 'terrier', 'greyhound']]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print( pets )\n",
    "pets.pop(1)   # Get rid of dogs\n",
    "dog_breeds = ['bulldog', 'terrier', 'greyhound']\n",
    "pets.append(dog_breeds)  # append list of dog breeds available\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We see that the last position of the list `pets` is now occupied by the list of dog breeds. That means that we can access the usual way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:08:56.288253Z",
     "start_time": "2019-07-01T13:08:56.283460Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['bulldog', 'terrier', 'greyhound']"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How can we now access a specific dog breed? \n",
    "\n",
    "The dog breeds are in a list, so we are able to access any element in that list using an index. We just need to know the name of the list. The name is, of course, `pets[-1]`.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-23T21:13:10.361423Z",
     "start_time": "2019-06-23T21:13:10.355359Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'bulldog'"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets[-1][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The parenteses in the command above are unnecessary.  We can just write `pets[-1][0]`. Thus, to access elements in nested lists, we just need to keep adding `[]` in order to navigated deeper and deeper into the nested collection of lists. When Python navigates through your list variable it will always read the indices from left to right, with the leftmost `[]` being the topmost `list`.\n",
    "\n",
    "<img src='../Data/www/images/nesting.png'></img>\n",
    "\n",
    "Also, we can change the values inside our nested lists just like at our topmost `list` and use all of our normal `list` functions that we used before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:09:10.752928Z",
     "start_time": "2019-07-01T13:09:10.747860Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs',\n",
       " 'hedgehog',\n",
       " 'iguana',\n",
       " 'parrot',\n",
       " 'sea monkeys',\n",
       " ['golden retriever', 'terrier', 'greyhound']]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets[-1][0] = 'golden retriever'\n",
    "pets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:09:12.275582Z",
     "start_time": "2019-07-01T13:09:12.270273Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dogs',\n",
       " 'hedgehog',\n",
       " 'iguana',\n",
       " 'parrot',\n",
       " 'sea monkeys',\n",
       " ['golden retriever', 'terrier', 'greyhound', 'pug']]"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pets[-1].append('pug')\n",
    "pets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The subtleties of copying nested structures\n",
    "\n",
    "Imagine that we open a second pet store, and that initially we will be having the same inventory as in the first store.  As all programmers worth their name, we want to minimize the amount of work we do. Thus, we would never add the names to the list one by one.  We just want to copy the list with the inventory from the first store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:09:39.132883Z",
     "start_time": "2019-07-01T13:09:39.129029Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dogs', 'hedgehog', 'iguana', 'parrot', 'sea monkeys', ['golden retriever', 'terrier', 'greyhound', 'pug']]\n",
      "['dogs', 'hedgehog', 'iguana', 'parrot', 'sea monkeys', ['golden retriever', 'terrier', 'greyhound', 'pug']]\n"
     ]
    }
   ],
   "source": [
    "store_one = pets\n",
    "store_two = store_one\n",
    "print( store_one )\n",
    "print( store_two )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Business is going well at store one. We sold the `pug`, and acquired a `cat` and a `gerbil`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:09:51.840714Z",
     "start_time": "2019-07-01T13:09:51.836081Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "store_one[-1].remove('pug')\n",
    "store_one.extend(['cat', 'gerbil'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-07-01T13:09:57.531337Z",
     "start_time": "2019-07-01T13:09:57.527762Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['dogs', 'hedgehog', 'iguana', 'parrot', 'sea monkeys', ['golden retriever', 'terrier', 'greyhound'], 'cat', 'gerbil']\n",
      "['dogs', 'hedgehog', 'iguana', 'parrot', 'sea monkeys', ['golden retriever', 'terrier', 'greyhound'], 'cat', 'gerbil']\n"
     ]
    }
   ],
   "source": [
    "print( store_one )\n",
    "print( store_two )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Both inventories were changed!** \n",
    "\n",
    "The reason is that the statement\n",
    "\n",
    "`store_two = store_one`\n",
    "\n",
    "did not copy the values in the collection labelled by `store_one` to a new place in memory labelled by `store_two`. It just made the name `store_two` point to the same position in memory as `store_one`. \n",
    "\n",
    "If you actually want to copy the values in the collection labelled by `store_one` to a new place in memory, then you have to use one of the built-in functions `copy()` and `deepcopy()`. \n",
    "\n",
    "Notice that there are important differences between the two functions. `copy()` does not make copies of nested stuctures. That is, if you a using `copy()` on a list that contains other lists, the other lists are not being copied to a different location in memory.\n",
    "\n",
    "**Every distribution of Python includes these two functions, but unlike other built-in functions, we have to import them before we can use them!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-23T21:13:16.632594Z",
     "start_time": "2019-06-23T21:13:16.626911Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Store One ['terrier', 'bulldog', 'fish', 'parrot', 'gerbil']\n",
      "Store Two ['beagle', 'terrier', 'bulldog', 'fish']\n"
     ]
    }
   ],
   "source": [
    "from copy import copy\n",
    "\n",
    "store_one = ['beagle', 'terrier', 'bulldog', 'fish']\n",
    "store_two = copy(store_one)\n",
    "store_one.remove('beagle')\n",
    "store_one.extend(['parrot', 'gerbil'])\n",
    "\n",
    "print('Store One', store_one)\n",
    "print('Store Two', store_two)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For now, do not worry about the meanig of the `from ... import ...` command. Just be aware of the subtleties when copying collections, especially nested collections since you may not be doing what you intended to do. Accidentally setting one variable name equal to another without noticint it is a way for logical errors to creep into your programs. **Always be careful! Always test your code!**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exercises"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are now the manager of the pet store! I'm going to need you to manage the inventory of pets that we have at the store."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-06-23T21:13:18.670613Z",
     "start_time": "2019-06-23T21:13:18.667629Z"
    },
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "pet_store = ['beagle', 'parrot', 'iguana', 'gerbil', 'chameleon', 'fish']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We've sold out of `chameleon` and `iguana`, you need to remove them from the inventory. Use both `remove()` and `del` to do so."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We just got in a `terrier`, `chameleon`, `bulldog`, and another `terrier`. Please add all of those animals to the `pet_store`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, how many **unique** animal types do we currently have in the store?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How many `terrier` dogs do we have in the store? (Hint: the `list` data type has a built-in function called `count()`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an owner, I actually have a very bad obsessive-compulsive disorder. Could you please reverse-alphabetically sort the pet types at the store? Thanks so much! Also going to need you to work this entire weekend. For free."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Could you print from `beagle` to `fish` but display it in alphabetical order?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is the index of `parrot`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.6.8"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}