Chapter 02 -- Data Structures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Chapter 02 -- Data Structures"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Topics Covered:\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#list\" a>list </a>\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#Indexing\" a>indexing </a>\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#tuple\" a>tuple </a>\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#dictionary\" a>dictionary </a>\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#sequences\" a>sequences </a>\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#set\" a>set </a>\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2002%20--%20Data%20Structures.ipynb#Resources\" a>Resources</a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This chapter briefly touches on Python's data structures.  As the name suggests, data structures are containers for data and other objects.  We introduce these objects since they form the building-blocks for other structures discussed in subsequent chapters.\n",
    "\n",
    "A cursory examination is needed, so a quick review is in order.  Later, you will want to refer back to these since they aid the creation of <a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2004%20--%20Pandas%2C%20Part%201.ipynb#DataFrames\">DataFrames</a> and other useful objects.  DataFrames are built on top of Python and Numpy modules which are the predominate structures discussed in Chapter 4 onwards. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has four main data structures.  There are:\n",
    "    \n",
    "    1. list\n",
    "    2. tuple\n",
    "    3. set\n",
    "    4. dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## list\n",
    "\n",
    "A list contains an ordered collection of items.  You determine the order.  In Python, items in a list are separarated by commas and enclosed in square brackets.  Lists are mutable, meaning you can add,  remove, or alter items.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 5 items in \"a_list\"\n"
     ]
    }
   ],
   "source": [
    "a_list = ['ale', 'lager', 'stout', 'hefeweizen', 'stout']\n",
    "print('There are', len(a_list), 'items in \"a_list\"')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example below, the parameter:\n",
    "\n",
    "    end=' '\n",
    "\n",
    "for the print() method suppresses the default new-line character (CR/LF)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A list of beers include:\n",
      "ale lager stout hefeweizen stout "
     ]
    }
   ],
   "source": [
    "print(\"A list of beers include:\")\n",
    "for i in a_list:\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexing\n",
    "\n",
    "Python provides indexing methods for a number of objects, including lists.  SAS has a similiar construct \\_n\\_ for the Data Step.  Both indexing methods act as keys providing access to an individual item (or set of items).  In Python's case, the default start index position is 0, and for SAS it is 1.\n",
    "\n",
    "The SAS code example in the cell below is an imperfect analogy for a Python list, since the SAS logic uses a variable to hold the beer_type values.  Nonetheless, each program illustrates access to an array 'item' by indexing.\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2005%20--%20Understanding%20Indexes.ipynb\">Chapter 05 -- Understanding Indexes\"</a> has more details."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python uses zero as its index start position, in contrast to SAS' \\_n\\_ which uses a start position of 1.  Almost every example of SAS DO loops, by convention, use a start position of 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value for beer type is: ale\n"
     ]
    }
   ],
   "source": [
    "print('Value for beer type is:', a_list[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "````\n",
    "    /******************************************************/\n",
    "    /* c02_retrieve_list_item_by_index_position.sas       */\n",
    "    /******************************************************/\n",
    "    4         data beers;\n",
    "    5         length beer_type $ 10;\n",
    "    6         input beer_type $ @@;\n",
    "    7         \n",
    "    8         if _n_ = 1 then\n",
    "    9            put 'Value for beer type is: ' beer_type;\n",
    "    10        \n",
    "    11        list;\n",
    "    12        datalines;\n",
    "\n",
    "    Value for beer type is: ale\n",
    "    RULE:     ----+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+-\n",
    "    13        ale lager stout hefeweizen stout \n",
    "````    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The next two examples illustrate the .append() and .sort() attributes for a list.  They produce no visible output, so use the print() method to view results."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a_list.append('malt')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a_list.sort(reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A for statement used to interate along the items in the list.  For statements are documented <a href=\"https://docs.python.org/3.6/tutorial/controlflow.html#for-statements\"> here</a>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A list of beers include:\n",
      "stout stout malt lager hefeweizen ale "
     ]
    }
   ],
   "source": [
    "print(\"A list of beers include:\")\n",
    "for i in a_list:\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The .count() attribute returns the number of items in an object.  Here it is used to return the number of occurrences of a value by having the list element as an argument. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a_list count for stout is: 2\n"
     ]
    }
   ],
   "source": [
    "print('a_list count for stout is:', a_list.count('stout'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example below illustrates Python's flexibility.  Since nearly everything in Python is an object, you can have a list containing other lists.  The built-in len() method provides a method to count the number of items in a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ales', 23, ['stout', 'stout', 'malt', 'lager', 'hefeweizen', 'ale']]\n",
      "Item count for b_list is: 3\n"
     ]
    }
   ],
   "source": [
    "b_list = ['ales', 23, a_list]\n",
    "print(b_list)\n",
    "print('Item count for b_list is:', len(b_list))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## tuple\n",
    "\n",
    "A tuple is similar to a list, but unlike lists, are immutable.   Tuples are defined by a list of comma-separated items inside a set of optional parentheses.  Legibility of code demands their use, however.\n",
    "\n",
    "A common use case for tuples is where Python statements or user-defined functions can assume that the items will not change, for example the names of the months."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The breakfast menu has: 5 items\n"
     ]
    }
   ],
   "source": [
    "dishes = ('eggs', 'green ham', 'biscuits', 'grits', 'steak')\n",
    "print('The breakfast menu has:', len(dishes), 'items')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pancakes cupcakes twinkies dishes "
     ]
    }
   ],
   "source": [
    "more_dishes = ('pancakes', 'cupcakes', 'twinkies', 'dishes')\n",
    "for i in more_dishes:\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The tuple within a tuple remains one that is indexed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(more_dishes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to count all of the items in the tuple.  \n",
    "    1. get the number of items in the tuple: more_dishes.  \n",
    "    2. subtract 1 since the 'tuple-within-a-tuple' item is not counted. \n",
    "    3. add the length of the tuple more_dishes starting at position [3]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of items in more_dishes is: 9\n"
     ]
    }
   ],
   "source": [
    "print('The number of items in more_dishes is:', len(more_dishes)-1+len(more_dishes[3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## dictionary\n",
    "\n",
    "A dictionary provides a look-up method through key/value pairs.  Keys must be unique.  Keys must be immutable objects such as lists, however, values can be either mutable or immutable objects.\n",
    "\n",
    "Key/value pairs are specified as:\n",
    "\n",
    "x = {key1: value1, key2: value2, key_n: value_n} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a dictionary"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n"
     ]
    }
   ],
   "source": [
    "capital = {'Oregon' : 'Salem',\n",
    "           'Washington' : 'Olympia',\n",
    "           'California' : 'Sacrament',\n",
    "           'Nevada' : 'Carson City'\n",
    "          }\n",
    "print(type(capital))            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Print a dictionary value by key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The capital of Nevada is Carson City\n"
     ]
    }
   ],
   "source": [
    "print('The capital of Nevada is', capital['Nevada'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Add a key/value pair to the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "capital['Colorado'] = 'Denver'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Printing key/value pairs.  String formatting is covered in <a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2003%20%20--%20Data%20Types%20and%20Formatting.ipynb\">Chapter 03 -- Data Types and Formatting</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of value/pairs in the dictionary capital is 5:\n"
     ]
    }
   ],
   "source": [
    "print('Number of value/pairs in the dictionary capital is {}:'.format(len(capital)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Delete a value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "del capital['California']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many Python operations are silent unless an error is raised.  Check the length of the dictionary following the delete operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of value/pairs in the dictionary capital is 4:\n"
     ]
    }
   ],
   "source": [
    "print('Number of value/pairs in the dictionary capital is {}:'.format(len(capital)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## sequences\n",
    "\n",
    "There are three basic sequence types:\n",
    "\n",
    "    list \n",
    "    tuple  \n",
    "    range\n",
    "    \n",
    "A feature for sequences is membership testing.  Using operators such as in, not in, and concatenation, you can test for the presence or absences of values.  \n",
    "\n",
    "Implicit in these examples are boolean values(True False) being returned.  Boolean operators are discussed in <a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/blob/master/Chapter%2003%20%20--%20Data%20Types%20and%20Formatting.ipynb#Boolean\">Chapter 03, Boolean</a> operators.\n",
    "\n",
    "The precedence order for sequence operations is found <a href=\"https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range\">here.</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example below does an item membership test for the a_list list object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found\n"
     ]
    }
   ],
   "source": [
    "item = 'ale'\n",
    "if (item in a_list):\n",
    "    print('found')\n",
    "else:\n",
    "    print('not found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Item membership test in a tuple using the boolean and operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found\n"
     ]
    }
   ],
   "source": [
    "item1 = 'eggs' \n",
    "item2 = 'cupcakes'\n",
    "if (item1 and item2 in more_dishes):\n",
    "    print('found')\n",
    "else:\n",
    "    print('not found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A for statement to iterate over the key value pairs in the 'capital' dictionary."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The capital of Washington is Olympia\n",
      "The capital of Nevada is Carson City\n",
      "The capital of Colorado is Denver\n",
      "The capital of Oregon is Salem\n"
     ]
    }
   ],
   "source": [
    "for state, capital in capital.items():\n",
    "    print('The capital of {} is {}'.format(state, capital))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if logic used for membership testing.  The if/elif statements are documented <a href=\"https://docs.python.org/3.6/reference/compound_stmts.html#if\"> here</a>. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if 'Nevada' in capital:\n",
    "    print(\"Nevada's capital:\", capital['Nevada'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the boolean not operator for membership test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'California' not in capital"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## set\n",
    "\n",
    "A set object is an unordered collection of distinct objects. They are used for membership testing, removing duplicates from a sequence, and computing mathematical operations such as intersection, union, difference, and symmetric differences.  \n",
    "\n",
    "Another common use case is when the existence of an object is more important than order or obtaining a count of occurrences of items. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Membership test using the in operator for a set "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months1 = set(['January', 'February', 'March', 'April', 'May', 'June'])\n",
    "\n",
    "'Jan' in months1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "copy() method for sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "months2 = months1.copy()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The remove() method for sets to delete an item"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "months1.remove('February')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The add() method for adding an item to a set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "months2.add('July')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The three examples above do not produce any visible output.  The sets Month1 and Month2 are displayed below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The set months1 contains: {'January', 'June', 'May', 'April', 'March'}\n",
      "The set months2 contains: {'June', 'March', 'May', 'April', 'July', 'January', 'February'}\n"
     ]
    }
   ],
   "source": [
    "print('The set months1 contains:', months1)\n",
    "print('The set months2 contains:', months2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can find the intersection of the sets 'months1' and 'months2'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'April', 'January', 'June', 'March', 'May'}"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months1 & months2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Test if the set months2 is a super-set of the set months1 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "months2.issuperset(months1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Resources:\n",
    "    \n",
    "v3.1.5 <a href=\"https://docs.python.org/3.1/tutorial/datastructures.html\"> Documentation </a> for Data Structures  \n",
    "\n",
    "<a href=\"http://www.datacommunitydc.org/blog/2013/07/python-for-data-analysis-the-landscape-of-tutorials\"> Python for Data Analysis</a>  The landscape of tutorials describing a range of resources across the web.  While a bit dated, it is useful for getting started and becoming familiar with the wide variety of packages built on top of Python.\n",
    "\n",
    "<a href=\"https://python.swaroopch.com\"> A Byte of Python</a> ...is a free book on programming using the Python language. It serves as a tutorial or guide to the Python language for a beginner audience. If all you know about computers is how to save text files, then this is the book for you.\n",
    "\n",
    "<a href=\"http://cs231n.github.io/python-numpy-tutorial/\"> Python Numpy Tutorial </a>  An overview of Nympy by Justin Johnson."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Navigation\n",
    "\n",
    "<a href=\"http://nbviewer.jupyter.org/github/RandyBetancourt/PythonForSASUsers/tree/master/\"> Return to Chapter List </a>    "
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [Root]",
   "language": "python",
   "name": "Python [Root]"
  },
  "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}