tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <h1 style=\"color:blue;\"><center>Welcome to this tutorial</center></h1>\n",
    " <p><center> Author: Sneha Mani</center></p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### In this python notebook, the topics that will be covered are:\n",
    "* Strings\n",
    "* Lists\n",
    "* Sorting\n",
    "* Dictionaries\n",
    "\n",
    "### 1. String Manipulation\n",
    "\n",
    "Many applications require strings to be pre-processed/cleaned before performing further analysis. This has especially seen great use in Natural Language Processing. \n",
    "\n",
    "Let's take a look at the split function which splits up the text based on the separator passed as a parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rose', ' lily', ' jasmine and hydrangea']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a. Using split function to break down a comma-separated string\n",
    "tex = 'rose, lily, jasmine and hydrangea'\n",
    "#Splitting tex by specifying commas within the split function\n",
    "commaless = tex.split(',') \n",
    "commaless"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that 'jasmine and hydrangea' were not split. Upon closely observing the output, it is clear that the whitespaces right before ' jasmine and hydrangea' and ' lily' are undesirable.\n",
    "\n",
    "If we wanted to split it up in order to get every flower individually, we must use the strip function as shown below.\n",
    "\n",
    "We are using the strip function to strip off the string 'and' below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rose,', 'lily,', 'jasmine', '', 'hydrange']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# b. Combining the use of strip and split function in order to trim whitespaces \n",
    "flowers = [x.strip('and') for x in tex.split(' ')]    \n",
    "flowers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To remove the whitespaces from the string we are using strip without any arguments - this removes leading and trailing whitespaces.\n",
    "\n",
    "Note the use of 'commaless' - the list generated without commas and NOT flowers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['rose', 'lily', 'jasmine', 'hydrangea']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clean_list = []  \n",
    "for x in commaless:     #Note the use of variable commaless ->list from the split function in In [35] of this tutorial.\n",
    "    split_strs = x.split('and')     #The 'and' is undesirable and cannot be identified by splitting at a ',' \n",
    "    split_strs = [y.strip() for y in split_strs]\n",
    "    clean_list.extend(split_strs)       #Note the use of extend() which is used to merge the two lists\n",
    "\n",
    "clean_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We have looked at how to split and trim off whitespaces. \n",
    "\n",
    "How do you put them back together?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'roselilyjasminehydrangea'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#c. Concatenating strings\n",
    "together = 'rose'+ 'lily'+'jasmine'+'hydrangea'\n",
    "together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we want to step through the list and concatenate?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'roselilyjasminehydrangea'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "together1=\"\"\n",
    "for a in clean_list:\n",
    "    together1=together1+a\n",
    "together1   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What if we wanted it backwards from the list(last element onwards?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hydrangeajasminelilyrose'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "together2=\"\"\n",
    "for a in clean_list:\n",
    "    together2=a+together2\n",
    "together2   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d. Using keyword 'in'\n",
    "'lily' in clean_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note as to how the output is a boolean."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#e. Index function\n",
    "tex.index('hydrangea')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note as to how the output counts the index location of the starting of the word 'hydrangea'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#f. Finding the position of the string\n",
    "tex.find('hydrangea')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "They appear to do the same thing, right? \n",
    "Actually, there is a small difference. as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "substring not found",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-cbfa37a3033d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtex\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\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;31mValueError\u001b[0m: substring not found"
     ]
    }
   ],
   "source": [
    "tex.index(':')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tex.find(':')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Check out how the '.index' function throws an error while the '.find' function returns -1 upon encountering the situation where the substring value does not exist. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#f. How do we count the number of occurrences of a substring.\n",
    "tex.count(',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's assume that I have an auto text editor on and I mispell a student's name. How do I correct it at all occurrences for my text body? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rose, lilly, jasmine and hydrangea lilly'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#g. Let's use replace!\n",
    "tex=tex+\" lily\"\n",
    "tex1 = tex.replace('lily','lilly') \n",
    "#Notice the order - .replace(old_value, new_value)\n",
    "tex1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ROSE, LILY, JASMINE AND HYDRANGEA LILY'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#h Want to send out an important message and emphasize??\n",
    "tex.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Rose, Lily, Jasmine And Hydrangea Lily'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#h2. Want the first letter to be uppercase for all words in \n",
    "#your string?\n",
    "tex.title()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'rose, lily, jasmine and hydrangea lily'"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#h3.unnecessary use of uppercase in your text?\n",
    "tex.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Back to how it was! Phew!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also use custom string formatter as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Unexpected betrayal by a friend - Et tu, Brute!!!\n"
     ]
    }
   ],
   "source": [
    "#i. custom string formatter\n",
    "name = \"Brute\"\n",
    "print(\"Unexpected betrayal by a friend - Et tu, {}!!!\".format(name))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "String is a primitive type and therefore, an assignment will always create a new memory footprint for the variable. Hence, changing one wouldn't affect the other. This is illustrated below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String 1: Hello, String2 Helloworld, type <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#j. Assigning value of string\n",
    "t=\"Hello\"\n",
    "tex_cpy = t\n",
    "tex_cpy = tex_cpy + \"world\"\n",
    "print(\"String 1: {}, String2 {}, type {}\".format(t, tex_cpy, type(t)))\n",
    "# Notice how the print statement gives placeholders an explicit positional index as discussed previously."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another interesting string method is the join() function. \n",
    "The join() function returns a string in which the elements of sequence have been joined by str separator as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'H$e$l$l$o$w$o$r$l$d'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Using join function for string type iterable\n",
    "s='$'\n",
    "s = s.join(tex_cpy)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "I'm sure we all make lists in our day to day lives. It could be a list of groceries, a to-do list(how many of us actually get those done?!), a list of job offers(oh boy! we wish!), a play-list and so on.\n",
    "\n",
    "A list is a data structure in Python that can be changed. It is an ordered sequence of items. A list can contain elements of different data types."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 'apple', [2]]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#a. How to create a list?\n",
    "a_list = [2,3,5,'apple',[2]]\n",
    "a_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are immutable and therefore they can be passed into a list in order to be made changeable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['try', 'can', 'work']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#b. A tuple can be passed into a list\n",
    "tup=('try','can','work')\n",
    "b_list=list(tup)\n",
    "b_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "range(0, 10)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#c. Range expression\n",
    "gen=range(10)\n",
    "gen"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#generates a list of integers from 0 to 9 \n",
    "list(gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As discussed earlier that lists are mutable, we will now discuss how to add an remove elements from a list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['try', 'hope', 'can', 'work']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d. Adding to list\n",
    "#d1. Exploring insert function\n",
    "b_list.insert(1,'hope')\n",
    "#notice how insert(position,element)\n",
    "b_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['try', 'hope', 'can', 'work', 'dream']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Trying larger index\n",
    "b_list.insert(20,'dream')\n",
    "b_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we try to input an index value larger than the size of the list, the element is assigned to the highest index value. \n",
    "This is a good inference to remember. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 5, 'apple', [2], 'try', 'hope', 'can', 'work', 'dream', 'can']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d2. Combining lists using '+' sign\n",
    "# Just like we saw with strings and concatenated using + sign\n",
    "c_list = a_list+b_list\n",
    "c_list.insert(20,'can')\n",
    "c_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d3. Finding the index of element in the list\n",
    "c_list.index('can')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is important to note that upon two occurrences of 'can', the index function returns the position of the first occurrence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 10]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d4. Finding multiple indices for same element\n",
    "ind = [i for i,x in enumerate(c_list) if x=='can']\n",
    "ind"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3]]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d5. Appending to a list\n",
    "empty_lis=[]\n",
    "empty_lis.append([1,2,3])\n",
    "empty_lis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d6. Using the extend function\n",
    "empty_lis=[]\n",
    "empty_lis.extend([1,2,3])\n",
    "empty_lis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above 2 cells denote the difference between using append and extend. \n",
    "\n",
    "* Append adds its argument as a single element to the end of a list. The length of the list itself will increase by one. \n",
    "* Extend iterates over its argument adding each element to the list, extending the list. The length of the list will increase by however many elements were in the iterable argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'dream'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#e. Removing from List\n",
    "#e1. Exploring pop function - removing by index\n",
    "x=b_list.pop(4) \n",
    "x\n",
    "# Passing index value of the item that needs to be popped"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['try', 'hope', 'can', 'work']"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how 'dream' no longer exists in b_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['try', 'hope', 'work']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#e2. Removing by value \n",
    "b_list.remove('can')\n",
    "b_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how 'can' no longer exists in b_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#f.Boolean functions to check if an element is in a list or not\n",
    "#f1. Using 'in' keyword\n",
    "'can' in b_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#f2. Using 'not in' keyword\n",
    "'dream' not in b_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unlike strings, list is not a primitive type and assignment does not create a new object, but assigns the reference of the old object. Hence, changing one will effect all the variables that reference the list. This is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b_list ['try', 'hope', 'work', 'world']\n",
      " b_list_ref ['try', 'hope', 'work', 'world']\n"
     ]
    }
   ],
   "source": [
    "#g. Creating a reference of b_list\n",
    "b_list_ref = b_list\n",
    "b_list_ref.append('world')\n",
    "print(\"b_list {}\\n b_list_ref {}\".format(b_list, b_list_ref))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to solve this problem, one can use copy.deepcopy \n",
    "which creates a new memory footprint for the variable. This is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b_list ['try', 'hope', 'work', 'world']\n",
      " b_list_ref ['try', 'hope', 'work', 'world', 'world2']\n"
     ]
    }
   ],
   "source": [
    "#Importing copy in order to use deepcopy\n",
    "import copy\n",
    "b_list_cpy = copy.deepcopy(b_list)\n",
    "b_list_cpy.append(\"world2\")\n",
    "print(\"b_list {}\\n b_list_ref {}\".format(b_list, b_list_cpy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A couple of other tricks which are interesting with lists is to access the elements from the end. The last element and the last but one element in the list can be accessed as shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last element in the list is world, the previous one is work\n"
     ]
    }
   ],
   "source": [
    "print(\"Last element in the list is {}, the previous one is {}\".format(b_list[-1], b_list[-2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the above syntax to access any nth element backwards! Pretty cool!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We saw earlier, the use of the 'join' function with a string iterable. The join() function can also take other objects as iterables. Some of them being - List, Tuple, Dictionary and Set(and string)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value of s is:1-2-3-4 and data type of s is:<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "#Let us consider a list\n",
    "list1 = ['1','2','3','4']  \n",
    "  \n",
    "s = \"-\"\n",
    "\n",
    "s=s.join(list1)\n",
    "print(\"value of s is:{} and data type of s is:{}\".format(s,type(s)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is good to note that s is of data type string. This is the case for any type of object being passed to the join function. The result of using join always returns a string object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 3. Sorting\n",
    "\n",
    "Sorting becomes important when we need to arrange items in a certain order. \n",
    "A list can be sorted 'in-place' - a new object need not be created. This can be done by using the sort function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[7, 2, 9, 1, 3]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Initializing list\n",
    "a=[7,2,9,1,3]\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 7, 9]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#a. Using sort() function which by default sorts in ascending order\n",
    "a.sort()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the sort function arranges the elements in ascending order. \n",
    "What if we want to arrange the elements in descending order? \n",
    "We use parameters within the sort() function - reverse=True/False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 7, 3, 2, 1]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#b. Sorting in decreasing order\n",
    "a.sort(reverse=True)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also pass a function to specify a sorting criteria within the sort() function and is as shown below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BMW', 'Ford', 'Mustang']"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#c1. Passing a function for sorting criteria method1\n",
    "#def lenfunc(e):\n",
    "#    return len(e)\n",
    "\n",
    "#c2. Passing a function for sorting criteria method2\n",
    "cars = ['BMW','Mustang','Ford']\n",
    "cars.sort(key=len)\n",
    "#cars.sort(key=lenfunc)\n",
    "cars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Mustang', 'Ford', 'BMW']"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#In decreasing order of length of car names.\n",
    "cars.sort(reverse=True,key=len)\n",
    "#cars.sort(reverse=True,key=lenfunc)\n",
    "cars"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['BMW', 'Ford', 'Mustang']\n"
     ]
    }
   ],
   "source": [
    "#d. Using sorted function - increasing order of length\n",
    "print(sorted(cars))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Mustang', 'Ford', 'BMW']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cars"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how the 'sorted' function does not alter the original list and instead returns the sorted list. While the 'sort' function changes the list 'in-place'."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mustang', 'Honda', 'Ford', 'BMW']\n"
     ]
    }
   ],
   "source": [
    "#Let's add an element\n",
    "cars.insert(4,'Honda')\n",
    "#Decreasing order of length\n",
    "print(sorted(cars,reverse=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Mustang', 'Honda', 'Ford', 'BMW']\n"
     ]
    }
   ],
   "source": [
    "# Key function in-place\n",
    "print(sorted(cars,reverse=True,key=len))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To find a position in the list where an element must be inserted into the list so as to maintain the resultant list in a sorted order. \n",
    "\n",
    "The built-in bisect module implements binary search and inserts into a sorted list.\n",
    "\n",
    "bisect.bisect finds the location where an element should be inserted to keep it sorted, while bisect.insort actually inserts the element into that location (right-most possible position)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import bisect\n",
    "\n",
    "#initializing list1\n",
    "l1 = [2,4,6]\n",
    "\n",
    "#e. Finding index position of the digit '10' in the list l1\n",
    "bisect.bisect(l1,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 6]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#f. Using insort function to insert the digit 6 to the list such that l1 remains sorted after insertion\n",
    "bisect.insort(l1,6)\n",
    "l1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Dictionary\n",
    "   \n",
    "Dict is one of the most important built-in Python data structures. It is also known by the names of hash map or associative array. \n",
    "\n",
    "It is a flexibly sized collection of key-value pairs, where key and value are Python objects.\n",
    "  \n",
    "Now, let us look at how we can create dicts. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating an empty dict {}\n",
    "d1={}\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{}"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another way to initialize a dict\n",
    "d2=dict()\n",
    "d2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': [1, 2, 3, 4]}"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#a Creating a dict d1\n",
    "d1={'a':'some value','b':[1,2,3,4]}\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#b Inserting a key value pair into an existing dict\n",
    "d1[6] = 'random stuff'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': [1, 2, 3, 4], 6: 'random stuff'}"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#c To obtain the value for a particular key\n",
    "d1['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some value\n",
      "[1, 2, 3, 4]\n",
      "random stuff\n"
     ]
    }
   ],
   "source": [
    "# Looping through a dict and print values by key\n",
    "for key in d1:\n",
    "    print(d1[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Considering a situation where the key does not exist in the dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'s'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-58-aac7aae76c9e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0md1\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m's'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 's'"
     ]
    }
   ],
   "source": [
    "d1['s']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to safely get the value of a non-existent key without any exception being thrown, we can use 'get' which has parameters get(key,Default_When_Key_Missing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(d1.get('s',None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#d Boolean function using 'in' keyword\n",
    "'b' in d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': [1, 2, 3, 4]}"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#e How to delete values using 'del' keyword or 'pop' keyword\n",
    "del d1[6]\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': [1, 2, 3, 4], 'dummy': 'another value'}"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1['dummy']='another value'\n",
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'another value'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x=d1.pop('dummy')\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The copy of a popped(with keyword 'pop') value can be stored while being removed. \n",
    "Whereas, when we delete(using keyword 'del') a key value pair, they are removed from the dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': [1, 2, 3, 4]}"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['a', 'b'])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Fetch and access all the keys in a dict\n",
    "d1.keys()\n",
    "# The above returns an enumerable object which can be looped through"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['some value', [1, 2, 3, 4]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Fetch and access the list of all the values in a dictionary\n",
    "d1.values()\n",
    "# The above returns an enumerable object which can be looped through"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 'some value', 'b': 'integer', 'object': 'flower', 'shape': 'abstract'}"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#h Merging one dict into another\n",
    "d2={'object':'flower','shape':'abstract','b':'integer',}\n",
    "d1.update(d2)\n",
    "d1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The update key changes the dict in-place, so if any existing keys are passed to update, the corresponding(old) values will be discarded and replaced by the new value. For eg: key - 'b' before update was [1, 2, 3, 4] and it is now changed to 'integer'."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pairing up two lists, element-wise to form key value pairs of the resultant dict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'red', 2: 'blue', 3: 'green'}"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Creating two lists\n",
    "key_list=[1,2,3]\n",
    "value_list=['red','blue','green']\n",
    "#i Initializing dictionary\n",
    "d=dict()\n",
    "for key,value in zip(key_list,value_list):\n",
    "    d[key]=value\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'green', 2: 'blue', 3: 'red'}"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reversing the order\n",
    "d=dict(zip((key_list),reversed(value_list)))\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valid dict key types\n",
    "\n",
    "While the values of dict can be any Python object, the keys generally have to be immutable objects like scalar types(int,float,string) or tuples. \n",
    "Basically, we have to check for hashability using a hash function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6286836567149951470"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#j hashing a string\n",
    "hash('string1')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2725224101759650258"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# hashing a tuple\n",
    "hash((1,2,(3,4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-72-cf24376f1e2b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m# Trying to hash a list ---> unsuccessful\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mhash\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\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: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "# Trying to hash a list ---> unsuccessful\n",
    "hash([1,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3713081631934410656"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Converting list to tuple to make it hashable\n",
    "hash(tuple([1,2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar to lists, dicts is not a primitive type and hence is always passed by reference. Hence, assigning a dict variable to another variable, simply creates a reference to the existing memory footprint. And similar to lists, we can use copy.deepcopy to create a new memory footprint for the dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Org: {'red': 1, 'blue': 2, 'green': [1, 2, 3]}\n",
      " Ref: {'red': 1, 'blue': 2, 'green': [1, 2, 3]}\n",
      " Copy: {'red': 1, 'blue': 2, 'green': [1, 2, 3, 4]}\n"
     ]
    }
   ],
   "source": [
    "#k. Creating reference for dict\n",
    "import copy\n",
    "d = { \"red\": 1, \"blue\": 2,  \"green\": [1, 2]}\n",
    "d_ref = d\n",
    "d_ref[\"green\"].append(3)\n",
    "d_copy = copy.deepcopy(d)\n",
    "d_copy[\"green\"].append(4)\n",
    "print(\"Org: {}\\n Ref: {}\\n Copy: {}\".format(d, d_ref, d_copy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " <p> References: </p>\n",
    "* \"Python for Data Analysis - Wes McKinney\" \n",
    "* https://www.pythonforbeginners.com/concatenation/string-concatenation-and-formatting-in-python\n",
    "* Geeks for Geeks\n",
    "* StackOverflow"
   ]
  }
 ],
 "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}