B06. Basic Data Structures Part 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# B06: Basic Data Structures Part 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We spent quite a bit of time looking at lists and methods. You'll be pleased to hear that a lot of the principles that you learned for lists are applicable to other data structures in Python, including the more advanced analytical data structures we'll meet later on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we're going to look at Dictionaries (also called Dicts). Enclosed within curly brackets {} They are a type of 'mapping' and are made up of a key and a value as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "example = {'key1':'value1',\n",
    "          'key2':'value2',\n",
    "          'key3':'value3'}   # Creating a dictionary\n",
    "example"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you've got some experience in web development, in particular with <a href=\"http://www.w3schools.com/json/\">JSON</a>, then the format of dictionaries should look familiar to you. Let's see what else we can do with dictionaries..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict1 = {'Alex':27,\n",
    "           'Tom':36,\n",
    "           'Samantha':44,\n",
    "           'Gill':51,\n",
    "           'Barry':53}     # Basic dictionary\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the key as an index to call values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict1['Tom']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also add values to our dictionary as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict1['Ronnie'] = 15\n",
    "mydict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dictionaries also have a set of pre-defined methods for you to use. As before simply type the reference of a dictionary followed by a . and then press tab to bring up a list of available methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mydict1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some useful methods are as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict1.keys()                     # Returns all the keys\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict1.values()                   # Returns all the values\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict1.items()                    # Returns a list of tuples containing keys and values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "mydict2 = {'Reggie':15}\n",
    "mydict1.update(mydict2)     # Updates the dict with the contents of another dict \n",
    "mydict1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nesting and Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Previously we mentioned that data structures can be used to store other data structures. This is called 'nesting' and can appear a bit daunting at first. However you'll soon see that this is a very powerful way to store data and coupled with our newfound skills in slicing and indexing, we'll have no problem at all dealing with it!\n",
    "\n",
    "Let's imaging we're opening a restaurant and we want to store our menu items in some Python data structures..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "steak = ['Rump','Sirloin','Fillet']                                    # Steak Menu\n",
    "pizza = ['Margarita','Napoli',['Single Pepperoni','Double Pepperoni']] # Pizza Menu\n",
    "burger = ['Chicken',['Regular','Cheese','Special'],'Vegetarian']       # Burger Menu\n",
    "salad = [None]                                                         # Salad Menu\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can access the various nested levels of these lists by specifying multiple indexes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pizza[0]     # First index in the pizza menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pizza[2]     # Third index in the pizza menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pizza[2][0] # Third index in the pizza menu, First index of the nested list (pepperoni types)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "pizza[2][1] # Third index in the pizza menu, Second index of the nested list (pepperoni types)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we wanted to store and access all this data from a single data item, we could use a dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "menu = {'Steak':steak,\n",
    "        'Pizza':pizza,\n",
    "        'Burger':burger,\n",
    "        'Salad':salad}\n",
    "menu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to lists, we can access various levels of the index as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "menu['Burger']      # Return whole the burger menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "menu['Burger'][0]   # Return the first item of the burger menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "menu['Burger'][1]   # Return the second item of the burger menu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "menu['Burger'][1][1] # Return the second item of the burger menu, and the second item in nested data structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "menu['Pizza'][2][0] # Return the third item of the pizza menu, and the first item in nested data structure"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a relatively simple example but demonstrates the power and versatility of Python's basic data structures. Let's now meet Tuples!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A tuple is similar to a list except that it is enclosed within curved brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "blank = ()                        # Creating a blank tuple\n",
    "mytuple = (1,2,3,4,5,6,7,8,9,10)  # Creating a tuple with integers\n",
    "print(type(mytuple),mytuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is one other important difference... Tuples are immutable. This means that they cannot be changed! This makes them useful in situtations where you can be certain that data will not change (e.g. date of birth). They are also considered more efficient to process than lists but this will likely not be notocable until using masses of data!\n",
    "\n",
    "Again, we can bring up a list of available methods by specifying our tuple followed by a . and then pressing tab:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mytuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll notice that there are only two methods available for tuples. This is because as they are immutable, there are no methods to change the data or structure of a tuple (e.g. append, sort etc.). For this reason you'll not be likely to use Tuples as much as dictionaries or lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "A Set is an unordered collection of unique elements and they can be created using the set() function as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset1 = set()    # Creating a blank set\n",
    "myset1.add(1)     # Adding a value to our set\n",
    "print(type(myset1),myset1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can see that the set is displayed in curly brackets, so don't confuse it with a dictionary! Sets are their own type of object.\n",
    "\n",
    "As with the other data structures we can see a list of available methods as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "myset1."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll see that a lot of the methods are to do with comparing sets (union, difference, intersection etc.) and this is because one of the primary uses of sets is comparing two unique 'sets' of data to see which values intersect, differ etc.\n",
    "\n",
    "For now, we'll add some more values to our set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset1.add(2)\n",
    "myset1.add(4)\n",
    "myset1.add(6)\n",
    "myset1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What happens when we try and add a value that's already in our set?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset1.add(2)\n",
    "myset1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nothing! That's because sets can only contain unique elements. Let's create a second set to do some comparisons with:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset2 = set()\n",
    "myset2.add(2)\n",
    "myset2.add(4)\n",
    "myset2.add(5)\n",
    "myset2.add(6)\n",
    "myset2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset1.difference(myset2)     # Returning the values that differ between two sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset1.intersection(myset2)   # Returning the values that are the same between two sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "myset1.union(myset2)         # Returning the union (values that are in either set) of the two sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is more to sets but they are probably the least used of the data structures in Python so we'll not be devoting more time to them here. However feel free to explore them further on your own!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting Between Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When using Python for data analysis, you'll find that you spend a lot of time converting data between various data structures. This is because you'll meet a lot of functions in Python Extensions/Modules/Libraries etc. that require data to be supplied in a specific format.\n",
    "\n",
    "This means that being able to convert between data structures is a <b>VERY</b> important skill! Let's start by going back to lists and looking at the ways in which we can convert them to other data structures."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting Lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "beatles = ['John','Paul','George','Ringo']\n",
    "beatles_tuple = tuple(beatles)            # Converting a list to a tuple\n",
    "print(type(beatles_tuple),beatles_tuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "beatles_set = set(beatles)               # Converting a list to a set\n",
    "print(type(beatles_set),beatles_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You'll remember that Dicts require key/values pairs so we'll create some key values as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "keys = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to supply two sets of arguments to the dict() function we have to use a special function called zip(). We'll provide some more info on this really useful function later, but for now just rest easy in the knowledge that zip() is your friend and has done some work for you, and helps us when using 2 separate lists to create a dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "beatles_dict = dict(zip(keys,beatles))\n",
    "beatles_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Converting Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "turtles = ('Leonardo','Raphael','Donatello','Michaelangelo')\n",
    "turtles_list = list(turtles)              # Converting a tuple to a list\n",
    "print(type(turtles_list),turtles_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "turtles_set = set(turtles)              # Converting a tuple to a set\n",
    "print(type(turtles_set),turtles_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "keys = [1,2,3,4]\n",
    "turtles_dict = dict(zip(keys,turtles))\n",
    "turtles_dict\n",
    "print(type(turtles_dict),turtles_dict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'm sure by now you've noticed a pattern emerging! With a few simple functions we can easily convert between data structures:\n",
    "\n",
    "* list()\n",
    "* tuple()\n",
    "* set()\n",
    "* dict(zip(keys,data))\n",
    "\n",
    "You can also use these functions to create data structures from individual variables as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 123\n",
    "b = 456\n",
    "c = 'Hello'\n",
    "d = 'World'\n",
    "e = list([a,b,c,d])\n",
    "print(type(e),e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember that most functions in Python will have positional arguments so make sure you gather multiple data items in brackets so as not to confuse Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Further Reading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a href = \"http://www.dotnetperls.com/set-python\">More on Sets</a>"
   ]
  }
 ],
 "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.5.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}