6_Data_structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "2. Python:\n",
    "  - 2.1 Data types: Numbers, strings, booleans\n",
    "  - 2.2 Data structures (I): List, Sets, dictionaries, numpy array, pandas dataframe\n",
    "  - 2.3 Code: How Python works\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>.container { width:90% !important; }</style>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "##Some code to run at the beginning of the file, to be able to show images in the notebook\n",
    "##Don't worry about this cell\n",
    "\n",
    "#Print the plots in this screen\n",
    "%matplotlib inline \n",
    "\n",
    "#Be able to plot images saved in the hard drive\n",
    "from IPython.display import Image \n",
    "\n",
    "#Make the notebook wider\n",
    "from IPython.core.display import display, HTML \n",
    "display(HTML(\"<style>.container { width:90% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. PYTHON: Data types, structures and code\n",
    "Python uses variables and code.\n",
    "\n",
    "\n",
    "### Variables\n",
    "Variables tell the computer to save something (a number, a string, a spreadsheet) with a name.\n",
    "\n",
    "For instance, if you write **variable_name = 3**, the computer knows that *variable_name* is 3.\n",
    "\n",
    "Variables can represents:\n",
    "- **2.1 Data types**: Numbers, strings and others\n",
    "- **2.2 Data structures**: \n",
    "    - Lists, tables... (which organize data types)\n",
    "\n",
    "\n",
    "### 2.3 Code\n",
    "- Instructions to modify variables\n",
    "- Can be organized in functions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 Most common data structures\n",
    "- **2.2.1 list** = notebook (you can add things, take out things, everything is in order). e.g. a list of the numbers 1,2 and 3: [1,2,3]\n",
    "- **2.2.2 tuple** = book  (you cannot change it after it's printed). (1,2,3)\n",
    "- **2.2.3 set** = keywords in a paper (you can check if something exists easily). {1,2,3}\n",
    "- **2.2.4 dictionary** = index (you can find content easily). {\"a\":1, \"b\":2, \"c\":3}\n",
    "- **2.2.5 numpy array** = fast list for math. np.array([1,2,3])\n",
    "- **2.2.6 pandas dataframe** = spreedsheet. pd.DataFrame([1,2,3],columns=[\"a\",\"b\",\"c\"])\n",
    "\n",
    "**They have methods** = ways to edit the data structure. For example add, delete, find, sort... (= functions in excel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 Lists\n",
    "- Combines a series of variables in order\n",
    "- Fast to add and delete variables, slow to find variables (needs to go over all the elements)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "##this is a list\n",
    "print([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type([1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.5, \"I'm another string\", 4]\n",
      "[3.5, \"I'm another string\", 4, [3.5, \"I'm another string\", 4]]\n"
     ]
    }
   ],
   "source": [
    "# A list can combine several data types\n",
    "this_is_list1 = [3.5,\"I'm another string\",4]\n",
    "print(this_is_list1)\n",
    "\n",
    "# It can even combine several data structures, for instance a list inside a list\n",
    "this_is_list2 = [3.5,\"I'm another string\",4,this_is_list1]\n",
    "print(this_is_list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OPERATIONS IN LISTS**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original:  [1, 3, 2, 'b']\n"
     ]
    }
   ],
   "source": [
    "## A list\n",
    "this_is_a_list = [1,3,2,\"b\"]\n",
    "print(\"Original: \", this_is_a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add element**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Added c:  [1, 3, 2, 'b', 'c']\n"
     ]
    }
   ],
   "source": [
    "## Add elements\n",
    "this_is_a_list.append(\"c\")\n",
    "print(\"Added c: \", this_is_a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Retrieve element**\n",
    "\n",
    "**CAREFUL**:  The first element has index 0, which means that this_is_a_list[0] gets the first element and  this_is_a_list[1] gets the second element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fourth element:  b\n"
     ]
    }
   ],
   "source": [
    "## Get element. The first element has index 0, which means that this_is_a_list[0] gets the first element\n",
    "print(\"Fourth element: \", this_is_a_list[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Get slices** \n",
    "- Get a part of list. This is important"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 2, 'b', 'c']"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this_is_a_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 2]"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "this_is_a_list[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "Second to end element:  [1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "#Entire list\n",
    "this_is_a_list = [0,1,2,3,4]\n",
    "print(this_is_a_list)\n",
    "#\"Second to end element (included)\"\n",
    "print(\"Second to end element: \", this_is_a_list[1:])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Second to the fourth (included):  [1, 2, 3]\n",
      "First to the last element (not included):  [0, 1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "#Second to the fourth (included)\n",
    "print(\"Second to the fourth (included): \",this_is_a_list[1:4])\n",
    "\n",
    "#First to the last element (not included)\n",
    "print(\"First to the last element (not included): \",this_is_a_list[:-1])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Search**\n",
    "- element in list\n",
    "- Note that this also works for strings (in fact, a string is very similar to a list of characters): \"eggs\" in \"eegs and bacon\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "#Search\n",
    "print(3 in this_is_a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "#Find index\n",
    "print(this_is_a_list.index(4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Length**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Length:  3\n"
     ]
    }
   ],
   "source": [
    "## Count the number of elements in a list\n",
    "this_is_a_list = [1, 3, 2]\n",
    "len_this_is_a_list = len(this_is_a_list) #you tell the computer to sum it and save it as `sum_this_is_a_list` \n",
    "print(\"Length: \", len_this_is_a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sort**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sorted:  [1, 2, 3]\n"
     ]
    }
   ],
   "source": [
    "## Sort a list\n",
    "this_is_a_list = [1, 3, 2]\n",
    "this_is_a_list = sorted(this_is_a_list) #you tell the computer to sort it, and to save it with the same name\n",
    "print(\"Sorted: \", this_is_a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Sum**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum:  6\n"
     ]
    }
   ],
   "source": [
    "## Sum a list\n",
    "this_is_a_list = [1, 3, 2]\n",
    "sum_this_is_a_list = sum(this_is_a_list) #you tell the computer to sum it and save it as `sum_this_is_a_list` \n",
    "print(\"Sum: \", sum_this_is_a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for +: 'int' and 'str'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-2da79e18f70a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m\"1\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\"2\"\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'"
     ]
    }
   ],
   "source": [
    "sum([\"1\",\"2\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notice that we wrote `this_is_a_list.pop()`, but `sum(this_is_a_list)` and `sorted(this_is_a_list)`**\n",
    "\n",
    "This is because `.pop()` only works in lists (*`.pop()` is a method of the data structure List*), while `sum()` and `sorted()` work with many different data structures. \n",
    "\n",
    "Some standard functions:\n",
    "- sum()\n",
    "- len()\n",
    "- sorted()\n",
    "- min()\n",
    "- max() \n",
    "- list() #convert to list\n",
    "- set() #convert to set\n",
    "- dict() #convert to dictionary\n",
    "- tuple() #convert to tuple\n",
    "- float() #convert to float\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "print(float(\"1\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(int(1.))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### CREATING RANGES\n",
    "- range(start,stop,step) generates a list of numbers between `start` and `stop` (not including the number `stop`), jumping in steps of size `step`. \n",
    "- See examples below.\n",
    "- Useful for example if we want to do one thing many times. We will see their importance on Thursday.\n",
    "- They are not really lists but very similar, in the examples I'll convert them to lists to see what's inside."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4]\n",
      "range(0, 5)\n"
     ]
    }
   ],
   "source": [
    "## Create a list [0,1,2,3,4]\n",
    "print(list(range(0,5,1)))\n",
    "print(range(5)) #for all practical issues you don't need to convert them"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "## Create the list [1,2,3,4]\n",
    "print(list(range(1,5,1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "## Create the list [1,3,4,5,7,9]\n",
    "print(list(range(1,10,2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**WORKING WITH STRINGS AND LISTS**\n",
    "- Divide a string into words\n",
    "- Join many words in a list into a string\n",
    "- Replace an element\n",
    "- Find an element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['eggs', 'and', 'bacon']\n"
     ]
    }
   ],
   "source": [
    "#we create a string and call it \"eggs and bacon\"\n",
    "our_string = \"eggs and bacon\"\n",
    "#now we divide it into words, creating a list and saving it with the name our_list_of_wrods\n",
    "our_list_of_words = our_string.split()\n",
    "print(our_list_of_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eggs and bacon'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can do the opossite and join the words using the function \"join\". \n",
    "\" \".join(our_list_of_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'eggs:::and:::bacon'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#we can join the words using any character we want in the quoted par of (\" \".join)\n",
    "\":::\".join(our_list_of_words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['eggs ', 'nd b', 'con']\n"
     ]
    }
   ],
   "source": [
    "#we can also divide a string using other characters instead of space. \n",
    "#for example let's split in the \"a\"s\n",
    "our_string = \"eggs and bacon\"\n",
    "print(our_string.split(\"a\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eggs and tofu\n"
     ]
    }
   ],
   "source": [
    "#we can change parts of the word\n",
    "our_string = \"eggs and bacon\"\n",
    "print(our_string.replace(\"bacon\",\"tofu\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "#we can find where a word start. For example let's find how many characters there are before \"and\"\n",
    "our_string = \"eggs and bacon and\"\n",
    "print(our_string.find(\"and\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "4\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#and we can use this to slice the string like we did with the list\n",
    "our_string1 = \"10 events\"\n",
    "our_string2 = \"120 events\"\n",
    "our_string3 = \"2 events\"\n",
    "\n",
    "#we find the index of and\n",
    "index_and1 = our_string1.find(\"event\")\n",
    "index_and2 = our_string2.find(\"event\")\n",
    "index_and3 = our_string3.find(\"event\")\n",
    "\n",
    "print(index_and1)\n",
    "print(index_and2)\n",
    "print(index_and3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 events\n"
     ]
    }
   ],
   "source": [
    "print(our_string1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 \n",
      "120 \n",
      "2 \n"
     ]
    }
   ],
   "source": [
    "#and keep all the string until that index\n",
    "print(our_string1[:our_string1.find(\"event\")])\n",
    "print(our_string2[:index_and2])\n",
    "print(our_string3[:index_and3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ipython help**\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "this_is_a_list?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "our_string1.find?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2.Tuples\n",
    "- The same than a list but inmutable (fixed size). You can't add or remove elements.\n",
    "- I (almost) never use them, but you may encounter them."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 3, 2, 'b')\n",
      "[1, 3, 2, 'b']\n"
     ]
    }
   ],
   "source": [
    "this_is_a_tuple = (1,3,2,\"b\")\n",
    "print(this_is_a_tuple)\n",
    "this_is_a_list = list(this_is_a_tuple)\n",
    "print(this_is_a_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'pop'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-96aadfa5bd16>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#If we try to pop and elment, like with lists, we get an error.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mthis_is_a_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'pop'"
     ]
    }
   ],
   "source": [
    "#If we try to pop and elment, like with lists, we get an error.\n",
    "this_is_a_tuple.pop(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.3. Sets\n",
    "- One element of each kind (no repeated elements!) -> If you convert a list to a set you find the *unique* elements.\n",
    "- Allows for intersecting\n",
    "- Example: Which words are different between two sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Image(filename='./images/set-operations-illustrated-with-venn-diagrams.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 3}"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1,2,3} - {2,5,6} "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 1, 1, 1, 2, 3]\n",
      "{1, 2, 3}\n",
      "{1, 2, 4}\n"
     ]
    }
   ],
   "source": [
    "#Let's create a list with repeated elements\n",
    "this_is_a_list = [3,1,1,1,2,3]\n",
    "print(this_is_a_list)\n",
    "#Now we convert it to a set and see how the repeated elements are gone\n",
    "this_is_a_set1 = set(this_is_a_list)\n",
    "print(this_is_a_set1)\n",
    "#You can also create sets like this\n",
    "this_is_a_set2 = {1,2,4}\n",
    "print(this_is_a_set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "## Union\n",
    "print(this_is_a_set1 | this_is_a_set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2}\n"
     ]
    }
   ],
   "source": [
    "## Intersection\n",
    "print(this_is_a_set1 & this_is_a_set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{3}\n"
     ]
    }
   ],
   "source": [
    "## Diference set_1 - set2\n",
    "print(this_is_a_set1 - this_is_a_set2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4}\n"
     ]
    }
   ],
   "source": [
    "## Diference set_2 - set1\n",
    "print(this_is_a_set2 - this_is_a_set1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'bacon'}\n"
     ]
    }
   ],
   "source": [
    "## Very useful for words. Imagine we have two articles, one saying \"eggs bacon python\" and another saying \"bacon spam\" \n",
    "#We can find which words they have in common\n",
    "print({\"eggs\",\"bacon\",\"python\"} & {\"bacon\",\"spam\"})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "##Very fast\n",
    "list_ = list(range(10000000))\n",
    "set_ = set(range(10000000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "105 ms ± 1.47 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%timeit 999999999 in list_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35.1 ns ± 0.307 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit 999999999 in set_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.4. Dictionary\n",
    "- Like in a index, finds a page in the book very very fast.\n",
    "- It combiens keys (word in the index) with values (page number associated to the word):\n",
    "**{key1: value2, key2: value2}**\n",
    "- The keys can be numbers, strings or tuples, but NOT lists (if you try Python will give the error unhashable key)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Amsterdam': 'NL', 'Madrid': 'ES', 'Brussels': 'BE'}\n",
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "#Dictionary\n",
    "cities2countries = {\"Amsterdam\": \"NL\", \n",
    "                    \"Madrid\": \"ES\", \n",
    "                    \"Brussels\": \"BE\"}\n",
    "\n",
    "print(cities2countries)\n",
    "print(type(cities2countries))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**OPERATIONS IN DICT**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Get**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NL\n",
      "NL\n"
     ]
    }
   ],
   "source": [
    "#Get an element\n",
    "print(cities2countries[\"Amsterdam\"])\n",
    "print(cities2countries.get(\"Amsterdam\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "#The difference between the two is that while the first line gives an error if \"Friends2\" \n",
    "#is not part of the dictionary, the second one answers with None**\n",
    "print(cities2countries.get(\"Paris\")) #not there"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Add**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create an element\n",
    "cities2countries[\"Paris\"] = \"FR\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Amsterdam': 'NL', 'Madrid': 'ES', 'Brussels': 'BE', 'Paris': 'FR'}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cities2countries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Amsterdam', 'Madrid', 'Brussels', 'Paris'])\n"
     ]
    }
   ],
   "source": [
    "#Print the keys\n",
    "print(cities2countries.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_values(['NL', 'ES', 'BE', 'FR'])\n"
     ]
    }
   ],
   "source": [
    "#Print the values\n",
    "print(cities2countries.values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_items([('Amsterdam', 'NL'), ('Madrid', 'ES'), ('Brussels', 'BE'), ('Paris', 'FR')])\n"
     ]
    }
   ],
   "source": [
    "#Print the pairs\n",
    "print(cities2countries.items())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Remove**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Amsterdam': 'NL', 'Madrid': 'ES', 'Brussels': 'BE'}\n"
     ]
    }
   ],
   "source": [
    "del cities2countries[\"Paris\"]\n",
    "print(cities2countries)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Creating a dictionary from two lists: ZIP**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Amsterdam': 'NL', 'Madrid': 'ES', 'Brussels': 'BE'}\n"
     ]
    }
   ],
   "source": [
    "#Creating dictionary using two lists\n",
    "list_cities = [\"Amsterdam\", \"Madrid\", \"Brussels\"]\n",
    "list_countries = [\"NL\",\"ES\",\"BE\"]\n",
    "\n",
    "#Put both together using zip\n",
    "cities2countries = dict(zip(list_cities,list_countries))\n",
    "print(cities2countries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<zip object at 0x7fb2d4357fa0>\n"
     ]
    }
   ],
   "source": [
    "#The zip object is another strange data structure that we cannot see (like range)\n",
    "print(zip(list_cities,list_countries))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('Amsterdam', 'NL'), ('Madrid', 'ES'), ('Brussels', 'BE')]\n"
     ]
    }
   ],
   "source": [
    "#But we can convert it to a list to see how it looks (like range)\n",
    "print(list(zip(list_cities,list_countries)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "** Why to use dict? Because it's much much faster than a list, it always takes the same time to find an element in a dict, that's not the case in a list**\n",
    "- With 10 elements, finding an element in a dict is **2x** faster than finding it in a list\n",
    "- With 1000 elements, finding an element in adict is **100x** faster  than finding it in a list\n",
    "- With 1 million elements, finding an element in a dict is **100000x** faster  than finding it in a list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.5.Numpy array\n",
    "- Part of the numpy package\n",
    "- Extremely fast (and easy) to do math\n",
    "- You can slice them like lists\n",
    "- It gives many cool functions, like mean(), or \\*\\* over a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "#First we need to import it\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([       0,        1,     1024,    59049,  1048576,  9765625,\n",
       "       60466176])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_list = [0,1,2,3,4,5,6]\n",
    "a_np_array = np.array(a_list)\n",
    "a_np_array**10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "21\n"
     ]
    }
   ],
   "source": [
    "#Sum of a list\n",
    "a_list = [0,1,2,3,4,5,6]\n",
    "#Using the standard function\n",
    "print(sum(a_list))\n",
    "#Using numpy\n",
    "print(np.sum(a_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'mean' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-62-9d0243857c4c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m##How to find the mean() of a list of numbers? mean() does not exist\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma_list\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;31mNameError\u001b[0m: name 'mean' is not defined"
     ]
    }
   ],
   "source": [
    "##How to find the mean() of a list of numbers? mean() does not exist\n",
    "print(mean(a_list)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'numpy.ndarray'>\n",
      "3.0\n"
     ]
    }
   ],
   "source": [
    "##but numpy rescues you\n",
    "import numpy as np\n",
    "\n",
    "a_list = [0,1,2,3,4,5,6]\n",
    "\n",
    "#first convert the list to an array. \n",
    "#This is not required when you use np.mean(a_list), but it is required in some other ocassions. \n",
    "a_np_array = np.array(a_list) \n",
    "\n",
    "print(type(a_list))\n",
    "print(type(a_np_array))\n",
    "print(np.mean(a_np_array)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  4  9 16 25 36]\n"
     ]
    }
   ],
   "source": [
    "##you can take powers\n",
    "print(a_np_array**2) #this would not work with a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         1.         1.41421356 1.73205081 2.         2.23606798\n",
      " 2.44948974]\n"
     ]
    }
   ],
   "source": [
    "##or square roots\n",
    "print(np.sqrt(a_np_array)) #this would work with a list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "499.5\n",
      "288.6749902572095\n",
      "499.5\n",
      "ModeResult(mode=array([0]), count=array([1]))\n",
      "0.0\n"
     ]
    }
   ],
   "source": [
    "#or some basic statistics\n",
    "import numpy as np\n",
    "import scipy.stats #another library for more complicated statistics\n",
    "\n",
    "#we create a list with numbers 0,1,2...998,999\n",
    "numElements = 1000\n",
    "this_is_an_list = list(range(numElements)) \n",
    "this_is_an_array = np.array(this_is_an_list)\n",
    "print(this_is_an_array[:10]) #print only the 10 first elements to make sure it's okay\n",
    "\n",
    "#and print some stats\n",
    "print(np.mean(this_is_an_array))\n",
    "print(np.std(this_is_an_array))\n",
    "print(np.median(this_is_an_array))\n",
    "print(scipy.stats.mode(this_is_an_array))\n",
    "print(scipy.stats.skew(this_is_an_array))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### IMPORTANT: NUMPY ARRAYS ALLOW YOU TO FILTER BY A CONDITION\n",
    "- **array_name[array_condition]**\n",
    "- For example, maybe you have a list [1,2,3,4,5,6,7,8,9,10] and you want the elements greater or equal to 5.\n",
    "- Numpy can help"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  2  3  4  5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "#Let's start with this array\n",
    "this_is_an_array = np.array([1,2,3,4,5,6,7,8,9,10])\n",
    "print(this_is_an_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  6  7  8  9 10]\n"
     ]
    }
   ],
   "source": [
    "#If we want the elements greater or equal (>=) to 5, we could do:\n",
    "print(this_is_an_array[4:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  9  4  3  2  8  6  7 10  1]\n"
     ]
    }
   ],
   "source": [
    "#However this case was very easy, but what getting the elements >= 5 in here:\n",
    "#[ 5,  9,  4,  3,  2,  8,  6, 7, 10,  1]\n",
    "unsorted_array = np.array([ 5,  9,  4,  3,  2,  8,  6, 7, 10,  1])\n",
    "print(unsorted_array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  9  8  6  7 10]\n"
     ]
    }
   ],
   "source": [
    "#We can do the following: unsorted_array[unsorted_array >= 5]\n",
    "#which means keep the elements of unsorted_array that are larger or equal to 5\n",
    "#unsorted_array[condition]\n",
    "print(unsorted_array[unsorted_array >= 5])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 5  9  4  3  2  8  6  7 10  1]\n",
      "[False False False False  True  True  True  True  True  True]\n"
     ]
    }
   ],
   "source": [
    "#This is a special kind of slicing where you filter elements with a condition. \n",
    "#Lists do not allow you to do this\n",
    "#How does it work? By creating another array, of the same lenght, with False and Trues\n",
    "print(unsorted_array)\n",
    "print(this_is_an_array >= 5) #the same than comparing 3 >= 5, but numpy compares every number inside the array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " - When you do **unsorted_array[condition]**, the computer check if the first element of the array `condition` is True\n",
    " - If it is True, then it keeps the first element of `unsorted_array`.\n",
    " - The computer then checks the second element of the `condition` array.\n",
    " - If it is True, then it keeps the second element of `unsorted_array`\n",
    " - And keeps doing this until the end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  8  6  7 10  1]\n"
     ]
    }
   ],
   "source": [
    "#We can use variables\n",
    "condition = this_is_an_array >= 5 #the computer does the = at the end always\n",
    "print(unsorted_array[condition])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greater than 5 and lower than 9 [8 6 7]\n"
     ]
    }
   ],
   "source": [
    "#What if we want to get the numbers between 5 and 9 (6, 7,9)?\n",
    "unsorted_array = np.array([ 5,  9,  4,  3,  2,  8,  6, 7, 10,  1])\n",
    "\n",
    "#We combine conditions\n",
    "condition_gt5 = unsorted_array > 5\n",
    "condition_lw9 = unsorted_array < 9 #we are using the new array\n",
    "unsorted_array_gt5_lw9 = unsorted_array[condition_gt5&condition_lw9]\n",
    "\n",
    "print(\"Greater than 5 and lower than 9\", unsorted_array_gt5_lw9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2.5. Pandas dataframe \n",
    "- They correspond to excel spreadsheets\n",
    "- Part of the pandas package\n",
    "- It is a big, complicated library that we will use a lot. \n",
    "- They are based on numpy arrays, so anything you can do with numpy arrays you can do with the rows or columns of a dataframe\n",
    "- Read/write csv files. It can also read stata or excel files (and sometimes spss), but who likes those programs.\n",
    "- Tip: Always save spreadsheets as .csv data\n",
    "\n",
    "\n",
    "\n",
    "**We've seen them already**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}