part_one/2-collections.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a name='sequences'></a>Overview of Built-in Sequences\n",
    "===\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The standard library offers a rich selection of sequence types implemented in C:\n",
    "\n",
    "- _Container sequences_ : `list`, `tuple`, and `collections.deque` can hold items of different types. \n",
    "\n",
    "- _Flat sequences_ : `str`, `bytes`, `bytearray`, `memoryview`, and `array.array` hold items of one type.\n",
    "\n",
    "**Container sequences** hold references to the objects they contain, which may be of any type, while **flat sequences** physically store the value of each item within its own memory space, and not as distinct objects. \n",
    "\n",
    "Thus, flat sequences are more compact, but they are limited to holding primitive values like characters, bytes, and numbers.\n",
    "\n",
    "Another way of grouping sequence types is by **mutability**:\n",
    "\n",
    "- _Mutable sequences_: `list`, `bytearray`, `array.array`, `collections.deque`, and `memoryview` \n",
    "\n",
    "- _Immutable sequences_: `tuple`, `str`, and `bytes`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<img src=\"../images/collections_uml.png\" width=\"60%\" />\n",
    "\n",
    "> From the book **\"Fluent Python\"** by _Luciano Ramalho_ (O'Reilly, 2015)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# A common pattern: Iterating Sequences"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Once you have a **sequence** of items, the very most common operations you would like to do is to **iterate**. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The **most natural** iteration strategy in Python is via the `for` iteration loop!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## The FOR (iteration) loop\n",
    "\n",
    "The `for` loop statement is the most widely used iteration mechanisms in Python.\n",
    "\n",
    "* Every **sequence** in Python can be iterated (*element by element*) by a `for` loop\n",
    "    - a list, a tuple, $\\ldots$ (more details will follows)\n",
    "\n",
    "* In Python, also `while` loops are permitted, but `for` is the one you would see (and use) most of the time!\n",
    "\n",
    "* The **Pythonic** iteration schema is: \n",
    "\n",
    "```python\n",
    "    for item in sequence:\n",
    "        # do smth\n",
    "```    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### FOR Special keywords\n",
    "\n",
    "Python allows two **keywords** to be used within a `for` loop: **break** and **continue**.\n",
    "\n",
    "The two keywords have two **different** meanings:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "* **Break** used to *immediatly break the loop and exit!*\n",
    "* **Continue** used to *skip to the **next** iteration step!*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Lists\n",
    "\n",
    "A list is a collection of items, that is stored in a variable. The items should be related in some way, but there are no restrictions on what can be stored in a list. Here is a simple example of a list, and how we can quickly access each item in the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    ">>> students = ['bernice', 'aaron', 'cody']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Naming convention\n",
    "\n",
    "Since lists are collection of objects, it is good practice to give them a plural name. \n",
    "\n",
    "If each item in your list is a car, call the list `cars`. \n",
    "\n",
    "If each item is a `dog`, call your list `dogs`. \n",
    "\n",
    "This gives you a straightforward way to refer to the entire list (`dogs`), and to a single item in the list (`dog`)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In Python, square brackets designate a list. To define a list, you give the name of the list, the equals sign, and the values you want to include in your list within square brackets."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    ">>> dogs = ['border collie', \n",
    "...         'australian cattle dog', \n",
    "...         'labrador retriever']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Accessing one item in a list\n",
    "\n",
    "Items in a list are identified by their position in the list, starting with zero. \n",
    "\n",
    "This will almost certainly trip you up at some point. \n",
    "\n",
    "Programmers even joke about how often we all make \"off-by-one\" errors, so don't feel bad when you make this kind of error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To access the first element in a list, you give the name of the list, followed by a zero in parentheses."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    "dogs = ['border collie', \n",
    "        'australian cattle dog', \n",
    "        'labrador retriever']\n",
    "\n",
    "dog = dogs[0]\n",
    "print(dog)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The number in parentheses is called the **index** of the item. \n",
    "\n",
    "Because lists start at zero, the index of an item is always one less than its position in the list. \n",
    "\n",
    "Because of that, **Python** is said to be a [*zero-indexed*](http://en.wikipedia.org/wiki/Zero-based_numbering) \n",
    "language (as many others, like `C`, or `Java`)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "So to get the second item in the list, we need to use an index of 1, and so on.."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dog = dogs[1]\n",
    "print(dog)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Accessing the last items in a list\n",
    "You can probably see that to get the last item in this list, we would use an index of 2. \n",
    "\n",
    "This works, but it would only work because our list has exactly three items. \n",
    "\n",
    "To get the **last** item in a list, no matter how long the list is, you can use an index of `-1`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dog = dogs[-1]\n",
    "print(dog)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This syntax also works for the **second to last item**, the third to last, and so forth."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dog = dogs[-2]\n",
    "print(dog)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can't use a negative number larger than the length of the list, however."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dog = dogs[-4]\n",
    "```\n",
    "```\n",
    "---------------------------------------------------------------------------\n",
    "IndexError                                Traceback (most recent call last)\n",
    "----> dog = dogs[-4]\n",
    "IndexError: list index out of range\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Getting the length of a List\n",
    "\n",
    "\n",
    "Another very common operation you would do with list is to know how _many items_ the list contains. \n",
    "\n",
    "To do so, there is a _built-in_ operation in Python via the `len` function:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "print(len(dogs))\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lists are Mutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**Lists are mutable.**\n",
    "\n",
    "When the bracket operator appears on the left side of an assignment, it identifies the element of the list that will be assigned.\n",
    "\n",
    "```python\n",
    ">>> numbers = [17, 123]\n",
    ">>> numbers[1] = 5\n",
    ">>> print(numbers)\n",
    "[17, 5]\n",
    "```\n",
    "\n",
    "The one-eth element of numbers, which used to be 123, is now 5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "You can think of a list as a relationship between indices and elements. \n",
    "\n",
    "This relationship is called a **mapping**; each index “maps to” one of the elements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![List mutable](../images/list.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Traversing a List \n",
    "\n",
    "This is one of the most important concepts related to lists. You can have a list with a million items in it, and in three lines of code you can write a sentence for each of those million items. If you want to understand lists, and become a competent programmer, make sure you take the time to understand this section.\n",
    "\n",
    "We use a loop to access all the elements in a list. A loop is a block of code that repeats itself until it runs out of items to work with, or until a certain condition is met. In this case, our loop will run once for every item in our list. With a list that is three items long, our loop will run three times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Let's take a look at how we access all the items in a list, and then try to understand how it works."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dogs = ['border collie', 'australian cattle dog', 'labrador retriever']\n",
    "\n",
    "for dog in dogs:\n",
    "    print(dog)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We have already seen how to create a list, so we are really just trying to understand how the last two lines work. These last two lines make up a loop, and the language here can help us see what is happening:\n",
    "\n",
    "    for dog in dogs:\n",
    "\n",
    "- The keyword \"for\" tells Python to get ready to use a loop.\n",
    "- The variable \"dog\", with no \"s\" on it, is a temporary placeholder variable. This is the variable that Python will place each item in the list into, one at a time.\n",
    "- The first time through the loop, the value of \"dog\" will be 'border collie'.\n",
    "- The second time through the loop, the value of \"dog\" will be 'australian cattle dog'.\n",
    "- The third time through, \"dog\" will be 'labrador retriever'.\n",
    "- After this, there are no more items in the list, and the loop will end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### A common looping error: a.k.a. The _NON_ Pythonic way to do it!\n",
    "\n",
    "One common looping error occurs when instead of using the `for each item in the sequence` iteration strategy, the index is used instead (_àla C_):\n",
    "\n",
    "**Side Note**: we are going to introduce the Python built-in `range` function - take it for granted now. More details on this function later !-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python \n",
    ">>> dogs = ['border collie', 'australian cattle dog', 'labrador retriever']\n",
    ">>> for i in range(0, len(dogs)):\n",
    "...    print(dogs[i])\n",
    "...\n",
    "\n",
    "border collie\n",
    "australian cattle dog\n",
    "labrador retriever\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In this example, instead of iterating over the list **element by element**, we iterated over a list of \n",
    "integers and used those as index to access the elements within the `dogs` list.\n",
    "\n",
    "Despite this is not wrong in principle, this solution is considered **not Pythonic** (meaning, **not good**, btw :-)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Enumerating a list\n",
    "\n",
    "In the other case in which we would need to iterate a list, and also memorising the position (aka. `index`) \n",
    "of the current element, the **Pythonic** way to do it is to leverage on the `enumerate` function .\n",
    "\n",
    "At each step of the loop, the `enumerate` function returns the pair `(index, element)` and we can use it like in the following example:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    ">>> dogs = ['border collie', 'australian cattle dog', 'labrador retriever']\n",
    ">>> for index, dog in enumerate(dogs):\n",
    "...    place = str(index)\n",
    "...    print(\"Place: \" + place + \" Dog: \" + dog)\n",
    "...\n",
    "Place: 0 Dog: Border Collie\n",
    "Place: 1 Dog: Australian Cattle Dog\n",
    "Place: 2 Dog: Labrador Retriever\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To enumerate a list, you need to add an *index* variable to hold the current index. \n",
    "\n",
    "So instead of\n",
    "\n",
    "    for dog in dogs:\n",
    "    \n",
    "You have\n",
    "\n",
    "    for index, dog in enumerate(dogs)\n",
    "    \n",
    "The value in the variable *index* is always an integer. If you want to print it in a string, you have to turn the integer into a string:\n",
    "\n",
    "    str(index)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## List Operations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `+` operator concatenates lists:\n",
    "\n",
    "```python \n",
    ">>> a = [1, 2, 3]\n",
    ">>> b = [4, 5, 6]\n",
    ">>> c = a + b\n",
    ">>> print(c)\n",
    "[1, 2, 3, 4, 5, 6]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Similarly, the `*` operator repeats a list a given number of times:\n",
    "\n",
    "```python\n",
    ">>> [0] * 4\n",
    "[0, 0, 0, 0]\n",
    ">>> [1, 2, 3] * 3\n",
    "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n",
    "```\n",
    "\n",
    "The first example repeats `[0]` four times. The second example repeats the list `[1, 2, 3]` three times."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## List Slices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Since a list is a collection of items, we should be able to get any subset of those items. \n",
    "\n",
    "For example, if we want to get just the first three items from the list, we should be able to do so easily. \n",
    "\n",
    "The same should be true for any three items in the middle of the list, or the last three items, or any `x` items from anywhere in the list. \n",
    "\n",
    "These subsets of a list are called *slices*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To get a subset of a list, we give the position of the first item we want, and the position of the first item we do *not* want to include in the subset. So the slice *list[0:3]* will return a list containing items 0, 1, and 2, but not item 3. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Here is how you get a batch containing the first three items."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "usernames = ['bernice', 'cody', 'aaron', 'ever', 'dalia']\n",
    "\n",
    "# Grab the first three users in the list.\n",
    "first_batch = usernames[0:3]\n",
    "\n",
    "for user in first_batch:\n",
    "    print(user)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If you want to grab everything up to a certain position in the list, you can also leave the first index blank:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "usernames = ['bernice', 'cody', 'aaron', 'ever', 'dalia']\n",
    "\n",
    "# Grab the first three users in the list.\n",
    "first_batch = usernames[:3]\n",
    "\n",
    "for user in first_batch:\n",
    "    print(user)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "When we grab a slice from a list, the original list is not affected:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "usernames = ['bernice', 'cody', 'aaron', 'ever', 'dalia']\n",
    "\n",
    "# Grab the first three users in the list.\n",
    "first_batch = usernames[0:3]\n",
    "\n",
    "# The original list is unaffected.\n",
    "for user in usernames:\n",
    "    print(user)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "We can get any segment of a list we want, using the slice method:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "usernames = ['bernice', 'cody', 'aaron', 'ever', 'dalia']\n",
    "\n",
    "# Grab a batch from the middle of the list.\n",
    "middle_batch = usernames[1:4]\n",
    "\n",
    "for user in middle_batch:\n",
    "    print(user)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "To get all items from one position in the list to the **end of the list**, we can leave off the second index:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "usernames = ['bernice', 'cody', 'aaron', 'ever', 'dalia']\n",
    "\n",
    "# Grab all users from the third to the end.\n",
    "end_batch = usernames[2:]\n",
    "\n",
    "for user in end_batch:\n",
    "    print(user)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Special Case: List Copy\n",
    "\n",
    "You can use the slice notation to make a copy of a list, \n",
    "by leaving out both the starting and the ending index. \n",
    "\n",
    "This causes the slice to consist of everything from the first item to the last, which is the entire list.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## List Methods: \n",
    "\n",
    "### Adding Items:\n",
    "\n",
    "We can add an item to a list using the `append()` method. This method adds the new item to the end of the list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dogs = ['border collie', 'australian cattle dog', 'labrador retriever']\n",
    "dogs.append('poodle')\n",
    "\n",
    "for dog in dogs:\n",
    "    print(dog + \"s are cool.\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Removing Items:\n",
    "\n",
    "There is a cool concept in programming called \"popping\" items from a collection. \n",
    "\n",
    "Every programming language has some sort of data structure similar to Python's lists. \n",
    "\n",
    "All of these structures can be used as _queues_, and there are various ways of processing the items in a queue.\n",
    "\n",
    "One simple approach is to start with an empty list, and then add items to that list. \n",
    "\n",
    "When you want to work with the items in the list, you always take the last item from the list, do something with it, \n",
    "and then remove that item. \n",
    "\n",
    "The `pop()` function makes this easy. \n",
    "\n",
    "It removes the last item from the list, and gives it to us so we can work with it. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python \n",
    "dogs = ['border collie', 'australian cattle dog', 'labrador retriever']\n",
    "last_dog = dogs.pop()\n",
    "\n",
    "print(last_dog)\n",
    "print(dogs)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "This is an example of a **first-in, last-out** approach. \n",
    "\n",
    "The first item in the list would be the last item processed if you kept using this approach. \n",
    "\n",
    "You can indeed **pop** any item you want from a list, by passing the `index` of the item you want to `pop`. \n",
    "\n",
    "So we could do a **first-in, first-out** approach by popping the first iem in the list:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "dogs = ['border collie', 'australian cattle dog', 'labrador retriever']\n",
    "first_dog = dogs.pop(0)\n",
    "\n",
    "print(first_dog)\n",
    "print(dogs)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Lists and Strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "A **string** is a sequence of characters and a **list** is a sequence of values, but a list of characters is **not** the same as a string."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "To convert from a string to a list of characters, you can use `list`:\n",
    "\n",
    "```python \n",
    ">>> s = 'spam'\n",
    ">>> t = list(s)\n",
    ">>> print(t)\n",
    "['s', 'p', 'a', 'm']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "The `list` function breaks a string into individual letters. \n",
    "\n",
    "If you want to break a string into **words**, you can use the `split` method of strings:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    ">>> s = 'pining for the fjords'\n",
    ">>> t = s.split()\n",
    ">>> print(t)\n",
    "['pining', 'for', 'the', 'fjords']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "An optional argument called a **delimiter** specifies which characters to use as word boundaries. \n",
    "\n",
    "The following example uses a **hyphen** as a delimiter:\n",
    "```python \n",
    ">>> s = 'spam-spam-spam'\n",
    ">>> delimiter = '-'\n",
    ">>> s.split(delimiter)\n",
    "['spam', 'spam', 'spam']\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "`join` is the inverse of `split`. \n",
    "\n",
    "It takes a list of strings and concatenates the elements. `join` is a string method, so you have to invoke it on the delimiter and pass \n",
    "the list as a parameter:\n",
    "\n",
    "```python \n",
    ">>> t = ['pining', 'for', 'the', 'fjords']\n",
    ">>> delimiter = ' '\n",
    ">>> delimiter.join(t)\n",
    "'pining for the fjords'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "In this case the delimiter is a space character (i.e. `' '`), \n",
    "so `join` puts a space between words. To concatenate strings without spaces, you can use the empty string, `''`, as a delimiter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Deques"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The list shortens from the end by one when we pop from it, and we also\n",
    "get the removed item back. So we can add an item to the end of a list\n",
    "using `append`, and we can remove an item from the end using `pop`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "It's also possible to do these things in the beginning of a list, but\n",
    "lists were not designed to be used that way and it would be slow if our\n",
    "list would be big. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `collections.deque` class makes appending and\n",
    "popping from both ends easy and fast. It works just like lists, but it\n",
    "also has `appendleft` and `popleft` methods."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python\n",
    ">>> names = collections.deque(['theelous3', 'Nitori', 'RubyPinch'])\n",
    ">>> names\n",
    "deque(['theelous3', 'Nitori', 'RubyPinch'])\n",
    ">>> names.appendleft('wub_wub')\n",
    ">>> names.append('go|dfish')\n",
    ">>> names\n",
    "deque(['wub_wub', 'theelous3', 'Nitori', 'RubyPinch', 'go|dfish'])\n",
    ">>> names.popleft()\n",
    "'wub_wub'\n",
    ">>> names.pop()\n",
    "'go|dfish'\n",
    ">>> names\n",
    "deque(['theelous3', 'Nitori', 'RubyPinch'])\n",
    ">>>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The deque behaves a lot like lists do, and we can do `list(names)` if we\n",
    "need a list instead of a deque for some reason.\n",
    "\n",
    "Deques are often used as queues. It means that items are always added to\n",
    "one end and popped from the other end."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a name='tuples'></a>Tuples\n",
    "===\n",
    "\n",
    "#### _Tuples as Immutable Lists_\n",
    "\n",
    "Tuples are basically lists that can never be changed. \n",
    "\n",
    "Lists are quite dynamic; they can grow as you append and insert items, and they can shrink as you remove items. You can modify any element you want to in a list. Sometimes we like this behavior, but other times we may want to ensure that no user or no part of a program can change a list. That's what tuples are for.\n",
    "\n",
    "Technically, lists are *mutable* objects and tuples are *immutable* objects. Mutable objects can change (think of *mutations*), and immutable objects can not change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "<a name='defining_tuples'></a>Defining tuples, and accessing elements\n",
    "---\n",
    "\n",
    "You define a tuple just like you define a list, except you use parentheses instead of square brackets. Once you have a tuple, you can access individual elements just like you can with a list, and you can loop through the tuple with a *for* loop:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "colors = ('red', 'green', 'blue')\n",
    "print(\"The first color is: \" + colors[0])\n",
    "\n",
    "print(\"\\nThe available colors are:\")\n",
    "for color in colors:\n",
    "    print(\"- \" + color)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "If you try to add something to a tuple, you will get an error:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python\n",
    ">>> colors = ('red', 'green', 'blue')\n",
    ">>> colors.append('purple')\n",
    "```\n",
    "```\n",
    "---------------------------------------------------------------------------\n",
    "AttributeError                            Traceback (most recent call last)\n",
    "<ipython-input-5-ed1dbff53ab2> in <module>()\n",
    "      1 colors = ('red', 'green', 'blue')\n",
    "----> 2 colors.append('purple')\n",
    "\n",
    "AttributeError: 'tuple' object has no attribute 'append'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The same kind of thing happens when you try to remove something from a tuple, or modify one of its elements. \n",
    "\n",
    "**Note:** Once you define a tuple, you can be confident that its values will not change."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Tuple as Records & Tuple Unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tuple as Record"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "lax_coordinates = (33.9425, -118.408056)\n",
    "\n",
    "city, year, pop, chg, area = ('Tokyo', 2003, 32450, 0.66, 8014)\n",
    "\n",
    "traveler_ids = [('USA', '31195855'), ('BRA', 'CE342567')]\n",
    "for country, passport_number in traveler_ids:  # tuple unpacking\n",
    "    print(passport)\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tuple Unpacking\n",
    "\n",
    "In previous example, we assigned `('Tokyo', 2003, 32450, 0.66, 8014)` to `city`, `year`, `pop`, `chg`, `area` in a single statement. \n",
    "\n",
    "Then, in the last line, the `% operator` assigned each item in the passport tuple to one slot in the format string in the print argument. \n",
    "\n",
    "Those are two examples of **tuple unpacking**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Multiple Supported Forms of Tuple Unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```python \n",
    ">>> t = (1, 99)\n",
    ">>> r, d = t\n",
    ">>> print(r, d)\n",
    "1, 99\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "```python \n",
    ">>> t = (1, 99, 77, 12.6, 's')\n",
    ">>> r, *rest, y = t\n",
    ">>> print(r)\n",
    "1\n",
    ">>> print(v)\n",
    "'s'\n",
    ">>> print(rest)\n",
    "[99, 77, 12.6]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Tuple Unpacking in Action (`for` loop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "```python \n",
    "values = [('1', '99.3'), ('2', '88.9'), ('3', '79.3'), ('4', '78.9'), ('5', '77.5'),\n",
    "          ('6', '69.2'), ('7', '58.1'), ('8', '43.3'), ('9', '38.9'), ('10', '33.3')]\n",
    "\n",
    "for ranking, degree in values:\n",
    "    print(int(ranking), float(degree))\n",
    "```\n",
    "```\n",
    "1 99.3\n",
    "2 88.9\n",
    "3 79.3\n",
    "4 78.9\n",
    "5 77.5\n",
    "6 69.2\n",
    "7 58.1\n",
    "8 43.3\n",
    "9 38.9\n",
    "10 33.3\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Another Example with List of Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### The `range()` function\n",
    "\n",
    "The `range()` function helps us generate long lists of numbers in a specified range. \n",
    "It accepts three parameters: `start`, `end`, `step`\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "```python \n",
    "numbers = range(0, 20, 2)\n",
    "print(list(numbers))\n",
    "for item in enumerate(numbers):\n",
    "    index, value = item\n",
    "    print('index: ', index, ' value: ', value )\n",
    "```\n",
    "```\n",
    "[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]\n",
    "index:  0  value:  0\n",
    "index:  1  value:  2\n",
    "index:  2  value:  4\n",
    "index:  3  value:  6\n",
    "index:  4  value:  8\n",
    "index:  5  value:  10\n",
    "index:  6  value:  12\n",
    "index:  7  value:  14\n",
    "index:  8  value:  16\n",
    "index:  9  value:  18\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "skip"
    }
   },
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Named Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `collections.namedtuple` function is a **factory** that produces subclasses of tuple enhanced with field names and a \n",
    "class name which helps debugging."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import collections \n",
    "\n",
    "card = collections.namedtuple('Card', ['rank', 'suit'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "City(name='Tokyo', country='JP', population=36.933, coordinates=(35.689722, 139.691667))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "## Defining and Using Named Tuples\n",
    "\n",
    "from collections import namedtuple\n",
    "\n",
    "City = namedtuple('City', 'name country population coordinates')\n",
    "tokyo = City('Tokyo', 'JP', 36.933, (35.689722, 139.691667))\n",
    "tokyo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36.933"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokyo.population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(35.689722, 139.691667)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokyo.coordinates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'JP'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tokyo[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<a name='sets'></a>Sets\n",
    "===\n",
    "\n",
    "**Sets** are a relatively new addition in the history of Python, and somewhat underused. \n",
    "\n",
    "The `set` type and its immutable sibling `frozenset` first appeared in a module in _Python 2.3_ and were \n",
    "promoted to built-ins in _Python 2.6_.\n",
    "\n",
    "A set object is an unordered collection of distinct hashable objects. Common uses include membership testing, removing duplicates from a sequence, and computing mathematical operations such as intersection, union, difference, and symmetric difference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'circle', 'square', 'triangle'}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shapes = ['circle','square','triangle','circle']\n",
    "set_of_shapes = set(shapes)\n",
    "set_of_shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "square\n",
      "circle\n",
      "triangle\n"
     ]
    }
   ],
   "source": [
    "shapes = {'circle','square','triangle','circle'}\n",
    "for shape in set_of_shapes:\n",
    "    print(shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'square', 'polygon', 'circle', 'triangle'}\n"
     ]
    }
   ],
   "source": [
    "set_of_shapes.add('polygon') \n",
    "print(set_of_shapes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Sets vs FrozenSets\n",
    "\n",
    "Set elements **must** be hashable (that is the way to avoid repetitions). \n",
    "\n",
    "The `set` type is **not** hashable, but `frozenset` is, so you can have `frozenset` elements inside a `set`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "set_with_frozenset = {frozenset([2, 3, 4]), frozenset([4, 5, 6])}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{frozenset({4, 5, 6}), frozenset({2, 3, 4})}\n"
     ]
    }
   ],
   "source": [
    "print(set_with_frozenset)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Exists (Check)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Circle is in the set:  True\n",
      "Rhombus is in the set: False\n"
     ]
    }
   ],
   "source": [
    "# Test if circle is IN the set (i.e. exist)\n",
    "print('Circle is in the set: ', ('circle' in set_of_shapes))\n",
    "print('Rhombus is in the set:', ('rhombus' in set_of_shapes))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Operations\n",
    "\n",
    "In addition to guaranteeing uniqueness, the set types implement the essential set operations as infix operators, so, given two sets `a` and `b`, `a | b` returns their **union**, `a & b` computes the **intersection**, and `a - b` the **difference**. \n",
    "\n",
    "Smart use of set operations can reduce both the line count and the runtime of Python programs, at the same time making code easier to read and reason about by removing loops and lots of conditional logic.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'circle', 'triangle'}"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "favourites_shapes = set(['circle','triangle','hexagon'])\n",
    "\n",
    "# Intersection\n",
    "set_of_shapes.intersection(favourites_shapes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'circle', 'triangle'}"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equivalently\n",
    "set_of_shapes & favourites_shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'circle', 'hexagon', 'polygon', 'square', 'triangle'}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Union\n",
    "set_of_shapes.union(favourites_shapes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'circle', 'hexagon', 'polygon', 'square', 'triangle'}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equivalently\n",
    "set_of_shapes | favourites_shapes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'polygon', 'square'}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Difference\n",
    "set_of_shapes.difference(favourites_shapes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'polygon', 'square'}"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Equivalently\n",
    "set_of_shapes - favourites_shapes"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}