0. Python_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Python Introduction\n",
    "##### Created by Professor Eric Larson, contact at eclarson@smu.edu for errors or questions\n",
    "\n",
    "In this notebook, we will introduce the basics of programming in python as well as the installation of different modules and libraries. Debugging in python can be a pain, but there are many different ways of debugging depending on what you are most comfortable with. \n",
    "\n",
    "We will go over:\n",
    "+ Analysing and debugging errors \n",
    "+ Setting breakpoints with pdb \n",
    "+ Using an IDE with python that can look at memory, set breakpoints, etc.\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "![Guido Von Rossum](https://raw.githubusercontent.com/eclarson/DataMiningNotebooks/master/data/guido.png)\n",
    "\n",
    "Python was founded by a guy named Guido Von Rossum in 1989. I will let him explain his motivations.\n",
    "From wikipedia:\n",
    ">Over six years ago, in December 1989, I was looking for a \"hobby\" programming project that would keep me occupied during the week around Christmas. My office ... would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of ABC that would appeal to Unix/C hackers. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of Monty Python's Flying Circus).\n",
    "\n",
    "        -Guido van Rossum in 1996\n",
    "\n",
    "So let that be a lesson! Python is not named after the snake, it is after Monty Python. However, even though the language is a bit quirky, do not let that fool you. It is absolutely made for people to use as a serious programming language and tool. Whether you have novice programming skills or are a sesoned veteran at OOP. \n",
    "\n",
    "For example, take a look at the most popular programming languages as identified by the number of projects in GitHub, and the number of related questions on stack overflow. Notice the other langauges next to python, like java, php, c++, ruby, and all the heavy hitters. Its also on every top ten list of programming languages needed to get a job in programming. Check it out. Graphic credit given to RedMonk.\n",
    "![Python](https://raw.githubusercontent.com/eclarson/DataMiningNotebooks/master/data/python_ranking.png)\n",
    "\n",
    "Moreover, python is one of the fastest growing languages used in scientific computing and data science. According to a recent survey, the three most helpful languages or packages for doing data science are R, SAS, and python. You will likely make use of all three for a given project or set of projects. See http://www.r-bloggers.com/data-science-toolbox-survey-results-surprise-r-and-python-win/ for a high level description of the survey.\n",
    "\n",
    "# Running Python\n",
    "Python can be run in various ways. We will cover how to run it from the interpreter prompt, command line scripts, and from iPython notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# this is a comment\n",
    "\n",
    "# place this at the top of python file to enable running as >>./filename.py\n",
    "#! /usr/bin/python\n",
    "\n",
    "# otherwise you can run with >>python filename.py {or} >>python27 filename.py\n",
    "\n",
    "# those commands can be run from a terminal window"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world\n"
     ]
    }
   ],
   "source": [
    "# hello world from iPython Notebook\n",
    "print (\"hello world\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Syntax\n",
    "Okay, so lets first dive into some of the syntax in python programming."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable type examples:\n",
      "<class 'int'>\n",
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'bool'>\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# ============================================\n",
    "# Variables Example\n",
    "int_val = 8\n",
    "long_val = 23423423235 # in python 3 longs are integers!!\n",
    "float_val = 2.546923764237654239\n",
    "bool_val = False\n",
    "\n",
    "print (\"Variable type examples:\")\n",
    "print (type(int_val))\n",
    "print (type(long_val))\n",
    "print (type(float_val))\n",
    "print (type(bool_val))\n",
    "\n",
    "# testing for the type of a variable\n",
    "temp = isinstance(float_val,float)\n",
    "print (temp)\n",
    "print (isinstance(float_val,int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Arithmetic examples:\n",
      "2.6666666666666665\n",
      "2.6666666666666665\n",
      "2.6666666666666665\n",
      "False\n",
      "False\n",
      "True\n",
      "8.0\n",
      "5\n",
      "81\n"
     ]
    }
   ],
   "source": [
    "#============================================\n",
    "# Arithmetic and casting\n",
    "print (\"\\nArithmetic examples:\")\n",
    "print (8 / 3)\n",
    "print (float(8) / 3)\n",
    "print (float(8) / float(3))\n",
    "\n",
    "print (True and False)  # logicals\n",
    "print (8 == 3        )  # logical equallty\n",
    "print (5 <= 6        )  # logical comparison\n",
    "\n",
    "print (2.0*4.0)  # multiplication\n",
    "print (65%6   ) # remainder, modulus\n",
    "print (3**4   ) # 3 to the fourth power"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "String example:\n",
      "A string is double or single quotes\n",
      "Three quote means that the string goes over\n",
      "multiple lines\n",
      "This also spans multiple lines but has no newline\n"
     ]
    }
   ],
   "source": [
    "#============================================\n",
    "# strings example\n",
    "print (\"\\nString example:\")\n",
    "str_val = \"A string is double or single quotes\"\n",
    "str_val_long = '''Three quote means that the string goes over\n",
    "multiple lines'''\n",
    "str_val_no_newline = '''This also spans multiple lines \\\n",
    "but has no newline'''\n",
    "\n",
    "print (str_val)\n",
    "print (str_val_long)\n",
    "print (str_val_no_newline)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A\n",
      "tr\n",
      "s\n",
      "uotes\n",
      "A string is double or single quotes\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-7-db4b305f836f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mstr_val\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mstr_val\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# print the first five elements, then from the fifth and on\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 9\u001b[0;31m \u001b[0mstr_val\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'G'\u001b[0m \u001b[0;31m# this is an error, strings are immutable once they are set\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# string can be accessed in a variety of different ways\n",
    "\n",
    "print (str_val[0]  ) # initial element \"0th\" element\n",
    "print (str_val[3:5]) # elements 3 and 4, but not 5\n",
    "print (str_val[-1] ) # the last element in the string\n",
    "print (str_val[-5:]) # the last five elements\n",
    "print (str_val[0:5] + str_val[5:]) # print the first five elements, then from the fifth and on\n",
    "\n",
    "str_val[5] = 'G' # this is an error, strings are immutable once they are set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A string is double or single quotesA string is double or single quotes\n",
      "True\n",
      "Eric\n",
      "a string is double or single quotes\n",
      "A STRING IS DOUBLE OR SINGLE QUOTES\n",
      "['this', ' is', ' separated', ' by', ' commas']\n"
     ]
    }
   ],
   "source": [
    "# some common operations for strings\n",
    "print (str_val*2) # mutliply is like adding the number of times, here it repeats the string twice\n",
    "print ('Python' > 'Java') # compare the strings alphabetically \n",
    "\n",
    "print (\"eric\".capitalize()) # the dot operator works like it does in most other OOP languages\n",
    "print (str_val.lower())\n",
    "print (str_val.upper())\n",
    "print (\"this, is, separated, by, commas\".split(',')) # this results is returned as a list, which we need to talk about!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tuples, Lists, Sets, and Dictionaries "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[45, 67, 'not a number', 'A string, appended as a new element in the list']\n",
      "[45, 67, 'not a number', 'A string, appended as a new element in the list', ['a list', 'within another list', 442]]\n",
      "['a list', 'within another list', 442]\n",
      "['A string, appended as a new element in the list', ['a list', 'within another list', 442]]\n"
     ]
    }
   ],
   "source": [
    "# A List is one of the most powerful tools in python from which\n",
    "# most abstract types get created and implemented\n",
    "\n",
    "# a list is very much like the mutable version of a tuple\n",
    "# it can hold any type of information\n",
    "a_list = [45, 67, \"not a number\"]\n",
    "\n",
    "# we can add to a list through the append function\n",
    "a_list.append(\"A string, appended as a new element in the list\")\n",
    "\n",
    "print (a_list)\n",
    "\n",
    "# Lists can have other lists in them\n",
    "tmp_list = [\"a list\", \"within another list\", 442]\n",
    "a_list.append(tmp_list)\n",
    "\n",
    "print (a_list)\n",
    "\n",
    "# all of the indexing we learned from before still works with lists\n",
    "print (a_list[-1])\n",
    "print (a_list[-2:])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(45, 67, 'not a number')\n",
      "not a number\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-10-a10b9f1d25cc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0;31m# but you cannot change a tuple, its immutable!!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0ma_tuple\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'hey'\u001b[0m \u001b[0;31m# this will give you an error!!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "# tuples are immutable lists and are designated by commas\n",
    "# you can store ANYTHING in side a tuple, its basically a complex object container\n",
    "a_tuple = 45, 67, \"not a number\" \n",
    "print (a_tuple)\n",
    "\n",
    "# you can access a tuple with square brackets\n",
    "print (a_tuple[2])\n",
    "\n",
    "# but you cannot change a tuple, its immutable!!\n",
    "a_tuple[2] = 'hey' # this will give you an error!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pear', 'banana', 'orange', 'apple'}\n",
      "True\n",
      "False\n",
      "{'r', 'a', '!', 'b', 'd', 'c'}\n",
      "{'d', '!', 'b', 'r'}\n",
      "{'r', 'a', '!', 'm', 'b', 'd', 'c', 'z', 'l'}\n",
      "{'a', 'c'}\n",
      "{'r', '!', 'm', 'b', 'd', 'z', 'l'}\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'frozenset' object has no attribute 'add'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-c0a647e24c26>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     20\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m \u001b[0ma_immutable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfrozenset\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m \u001b[0ma_immutable\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0madd\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'e'\u001b[0m\u001b[0;34m)\u001b[0m   \u001b[0;31m# the set is immutable, so we cannot add to it, this will give an error!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'add'"
     ]
    }
   ],
   "source": [
    "# Sets, taken from the Python sets tutorial\n",
    "# https://docs.python.org/2/tutorial/datastructures.html#sets\n",
    "basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']\n",
    "fruit = set(basket) # create a set without duplicates\n",
    "print (fruit)\n",
    "print ('orange' in fruit )# fast membership testing\n",
    "print ('crabgrass' in fruit)\n",
    "\n",
    "# Demonstrate set operations on unique letters from two words\n",
    "a = set('abracadabra')\n",
    "b = set('alacazam')\n",
    "a.add('!') # also add the some punctuation\n",
    "\n",
    "# set operations\n",
    "print (a     )   # unique letters in a\n",
    "print (a - b )  # letters in a but not in b\n",
    "print (a | b )  # letters in either a or b\n",
    "print (a & b )  # letters in both a and b\n",
    "print (a ^ b )  # letters in a or b but not both\n",
    "\n",
    "a_immutable = frozenset(a)\n",
    "a_immutable.add('e')   # the set is immutable, so we cannot add to it, this will give an error!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'dog': 4, 'human': 2, 'cat': 4}\n",
      "4\n",
      "2\n",
      "===============\n",
      "{'dog': 4, 'human': 'two', 'bird': 'two and some wings', 45: 'a key that is not a string'}\n"
     ]
    }
   ],
   "source": [
    "# Dictionaries map keys to values.\n",
    "\n",
    "# Here we setup a key as a string and the value as a number\n",
    "num_legs = { 'dog': 4, 'cat': 4, 'human': 2 }\n",
    "\n",
    "# You access Subscripts via the \"key\"\n",
    "print (num_legs)\n",
    "print (num_legs['dog'])\n",
    "print (num_legs['human'])\n",
    "\n",
    "print ('===============')\n",
    "# Entries can be added, updated, or deleted.\n",
    "# Again, these are just containers for any memory type\n",
    "num_legs['human'] = 'two'\n",
    "num_legs['bird'] = 'two and some wings'\n",
    "num_legs[45] = 'a key that is not a string' # notice that the key does not need to be a string\n",
    "# the key just needs to be some immutable memory\n",
    "\n",
    "del num_legs['cat']\n",
    "print (num_legs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# ADTs, Loops, and Conditionals"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "for loop output:\n",
      "DataMining <class 'str'>\n",
      "This statement is in the loop\n",
      "8 <class 'int'>\n",
      "This statement is in the loop\n",
      "23423423235 <class 'int'>\n",
      "This statement is in the loop\n",
      "2.546923764237654 <class 'float'>\n",
      "This statement is in the loop\n",
      "False <class 'bool'>\n",
      "This statement is in the loop\n",
      "This statement is outside the loop\n"
     ]
    }
   ],
   "source": [
    "\n",
    "#============================================\n",
    "# for loop example with list\n",
    "print (\"\\nfor loop output:\")\n",
    "\n",
    "list_example = [int_val, long_val, float_val, bool_val]\n",
    "list_example.insert(0, \"DataMining\")\n",
    "\n",
    "# notice that the loop ends with a colon and \n",
    "# is designated by the tab alignment\n",
    "for val in list_example:\n",
    "    print (str(val) + ' ' + str(type(val)))\n",
    "    print (\"This statement is in the loop\")\n",
    "    \n",
    "print (\"This statement is outside the loop\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "B. exiting for loop without break\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "val = 0\n",
    "for i in range(0, random.randint(1, 10) ):\n",
    "    val += i\n",
    "    print (val)\n",
    "    if val>20:\n",
    "        print (' A. leaving the loop on break')\n",
    "        break # break out of loop\n",
    "else: # this else belongs to the for loop\n",
    "    print ('B. exiting for loop without break')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataMining \t is at index \t 0\n",
      "8 \t is at index \t 1\n",
      "23423423235 \t is at index \t 2\n",
      "2.546923764237654 \t is at index \t 3\n",
      "False \t is at index \t 4\n"
     ]
    }
   ],
   "source": [
    "# more for loop examples\n",
    "\n",
    "# you can also get the index using the enumerate example\n",
    "for index, val in enumerate(list_example):\n",
    "    print (str(val), '\\t is at index \\t', index)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What is your name?  It is lancelot.\n",
      "What is your quest?  It is the holy grail.\n",
      "What is your favorite color?  It is blue.\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# this is a classic example for zipping, provided by the official python tutorial\n",
    "# notice the references to Monty Python\n",
    "\n",
    "# say you have two lists of equal size, that you would like to \n",
    "# loop through without indexing, you can use the \"zip\" function\n",
    "questions = ['name', 'quest', 'favorite color']\n",
    "answers = ['lancelot', 'the holy grail', 'blue']\n",
    "for q, a in zip(questions, answers):\n",
    "    print ('What is your %s?  It is %s.' % (q, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['dog', 'human', 'bird', 45])\n",
      "dog => 4\n",
      "human => two\n",
      "bird => two and some wings\n",
      "45 => a key that is not a string\n",
      "===============\n",
      "dog => 4\n",
      "human => two\n",
      "bird => two and some wings\n",
      "45 => a key that is not a string\n",
      "===============\n",
      "human => two\n",
      "beast is not present.\n",
      "cat is not present.\n",
      "dog => 4\n",
      "45 => a key that is not a string\n"
     ]
    }
   ],
   "source": [
    "# Looping through dictionaries\n",
    "# Get all the keys.\n",
    "print (num_legs.keys())\n",
    "for k in num_legs.keys():\n",
    "    print (k, \"=>\", num_legs[k])\n",
    "\n",
    "print ('===============')\n",
    "# you can also use the iter_items function\n",
    "for k, v in num_legs.items():\n",
    "    print (k, \"=>\", v)\n",
    "\n",
    "print ('===============')\n",
    "# Test for presence of a key.\n",
    "for t in [ 'human', 'beast', 'cat', 'dog', 45 ]:\n",
    "    print (t,end=' ')\n",
    "    if t in num_legs:\n",
    "        print ('=>', num_legs[t])\n",
    "    else:\n",
    "        print ('is not present.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 16, 81, 256, 625, 1296, 2401, 4096, 6561]\n",
      "['NAME', 'QUEST', 'FAVORITE COLOR']\n",
      "{0: 0, 1: 1, 2: 16, 3: 81, 4: 256, 5: 625, 6: 1296, 7: 2401, 8: 4096, 9: 6561}\n",
      "260\n"
     ]
    }
   ],
   "source": [
    "# list comprehensions and dictionary comprehensions\n",
    "\n",
    "# comprehensions are like shorthand for loops where each\n",
    "# pass through the loop saves the result in a list or dictionary\n",
    "\n",
    "# for example, imagine we want to take every element in a range to the fourth power\n",
    "times_four = [x**4 for x in range(10)]\n",
    "print (times_four)\n",
    "# this save the fourth power of the numbers 0 through 9\n",
    "# the result of each pass through the loop saves a value\n",
    "# in other languages this is also known as \"lambda functions\"\n",
    "\n",
    "# you can also call functions inside a comprehension, and take \n",
    "# advantage of the data type. For example, if each element is a string\n",
    "# we can use the string member methods\n",
    "questions = ['name', 'quest', 'favorite color']\n",
    "quest_upper = [x.upper() for x in questions]\n",
    "print (quest_upper)\n",
    "\n",
    "# you can also do comprehensions with dictionaries\n",
    "times_four = {x:x**4 for x in range(10)}\n",
    "# notice that the comprehension is wrapped in curly braces and the key for the value \n",
    "# is given inside the code itself, followed by a colon\n",
    "print (times_four)\n",
    "\n",
    "# you can also nest comprehensions inside each other, but this is not always good coding practice\n",
    "# especially if it makes the code less readable\n",
    "\n",
    "# Finally, all of the enumerate, zipping, and slicing we performed also applies to \n",
    "# list comprehensions\n",
    "x_array = [10, 20, 30]\n",
    "y_array = [7, 5, 3]\n",
    "# this prints the sum of the multiplication of the arrays\n",
    "print (sum(x*y for x,y in zip(x_array, y_array)) ) \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Stack Example:\n",
      "['LIFO', 0, 1, 2, 3, 4]\n",
      "=============\n",
      "4\n",
      "=============\n",
      "['LIFO', 0, 1, 2, 3]\n",
      "=============\n"
     ]
    }
   ],
   "source": [
    "#============================================\n",
    "# array as a stack\n",
    "print (\"\\nStack Example:\")\n",
    "list_example = []\n",
    "list_example.append('LIFO')\n",
    "\n",
    "for i in range(0, 5):\n",
    "    list_example.append(i)\n",
    "\n",
    "print (list_example)\n",
    "print (\"=============\")\n",
    "val = list_example.pop()\n",
    "print (val)\n",
    "print (\"=============\")\n",
    "print (list_example)\n",
    "print (\"=============\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Queue Example:\n",
      "deque([9, 8, 7, 6, 5, 'FIFO'])\n",
      "=============\n",
      "FIFO\n",
      "=============\n",
      "deque([9, 8, 7, 6, 5])\n",
      "=============\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#============================================\n",
    "# array as a queue\n",
    "print (\"\\nQueue Example:\")\n",
    "from collections import deque # this is an import, we will get back to that later\n",
    "# essentially this is a set of utility functions shipped with python\n",
    "\n",
    "q_example = deque()\n",
    "q_example.appendleft(\"FIFO\")\n",
    "for i in range(5, 10):\n",
    "    q_example.appendleft(i)\n",
    "\n",
    "print (q_example)\n",
    "print (\"=============\")\n",
    "val = q_example.pop()\n",
    "print (val)\n",
    "print (\"=============\")\n",
    "print (q_example)\n",
    "print (\"=============\")\n",
    "\n",
    "# pop and print each element\n",
    "while len(q_example) > 0:\n",
    "    print (q_example.pop())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Conditional Example:\n",
      "a is true\n",
      "b is false\n"
     ]
    }
   ],
   "source": [
    "#============================================\n",
    "# conditional example\n",
    "print (\"\\nConditional Example:\")\n",
    "\n",
    "a, b = True, False\n",
    "\n",
    "if a:\n",
    "    print (\"a is true\")\n",
    "elif a or b:\n",
    "    print (\"b is true\")\n",
    "else:\n",
    "    print (\"neither a or b are true\")\n",
    "\n",
    "# conditional assignment\n",
    "val = \"b is true\" if b else \"b is false\"\n",
    "print (val)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I. Everybody is a five!\n",
      "II. These are the same object!\n",
      "III. Wish we had the same objects...\n",
      "IV. Everybody is a five!\n",
      "V. Wish we had fives...\n",
      "VI. Got through nested conditional\n"
     ]
    }
   ],
   "source": [
    "# more on conditionals, \"is\" versus ==\n",
    "\n",
    "# I. the traditional == works as expected\n",
    "a=5\n",
    "b=5\n",
    "if a==b:\n",
    "    print (\"I. Everybody is a five!\")\n",
    "else:\n",
    "    print (\"I. Wish we had fives…\" )\n",
    "    \n",
    "# II. the \"is\" function is for object comparison, much like comparing pointers\n",
    "a=327676\n",
    "b=a\n",
    "if a is b:\n",
    "    print (\"II. These are the same object!\")\n",
    "else:\n",
    "    print (\"II. Wish we had the same objects...\" )\n",
    "    \n",
    "# III. while these have the same value, they are not the same memory\n",
    "a=327676\n",
    "b=327675+1\n",
    "if a is b:\n",
    "    print (\"III. These are the same object!\")\n",
    "else:\n",
    "    print (\"III. Wish we had the same objects...\" )\n",
    "\n",
    "# IV. you would expect this to say wish we had fives,\n",
    "# but small integers like this are cached so right now they do point to the same memory\n",
    "a=5\n",
    "b=4+1\n",
    "if a is b:\n",
    "    print (\"IV. Everybody is a five!\")\n",
    "else:\n",
    "    print (\"IV. Wish we had fives...\" )\n",
    "    \n",
    "# V. but if we change the memory, that caching gets released\n",
    "b = b*2.0\n",
    "b = b/2.0\n",
    "if a is b:\n",
    "    print (\"V. Everybody is a five!\")\n",
    "else:\n",
    "    print (\"V. Wish we had fives...\")\n",
    "    \n",
    "# you can also perform nested conditionals, like bounding\n",
    "if 5 < 8 < 6: # not true because 8 is not less than 6\n",
    "    print ('VI. How did we get here')\n",
    "elif 4 < 18 < 22:\n",
    "    print (\"VI. Got through nested conditional\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pythonic\n",
    "Now that we have gone through a consierable number of examples and data types, we need to talk about what it means to write code in python that is \"pythonic\". In a nutshell, there are many ways to implement something in python. The \"best\" method is one that is readable, simple, and brief. \n",
    "\n",
    "There many different coding “styles”\n",
    "+ “best” styles get the distinction of “pythonic”\n",
    "    + ill formed definition\n",
    "    + changes as the language matures\n",
    "+ pythonic code is:\n",
    "    + simple and readable\n",
    "    + uses dynamic typing when possible\n",
    "    + uses underscores to separate names\n",
    "    + names of variables are distinctive\n",
    "+ …or to quote Tim Peters…, run the next cell\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this # the zen of python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pop Quiz!!!\n",
    "Which of these is more pythonic: You want to add the numbers between zero and N. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8128\n",
      "8128\n",
      "8128.0\n"
     ]
    }
   ],
   "source": [
    "N = 128\n",
    "\n",
    "sum_value = 0\n",
    "for i in range(N):\n",
    "    sum_value += i\n",
    "print (sum_value)\n",
    "\n",
    "# OR\n",
    "print (sum(range(N)))\n",
    "\n",
    "# OR\n",
    "print (N*(N-1)/2 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions and Classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Function Example:\n",
      "upper case\n",
      "data mining\n"
     ]
    }
   ],
   "source": [
    "#============================================\n",
    "print (\"\\nFunction Example:\")\n",
    "\n",
    "# create and call a function\n",
    "# the function can be defined almost anywhere in file, as long as it is defined before it gets used\n",
    "def make_strings_lowercase(str_input):\n",
    "    assert isinstance(str_input, str)  # test the type of input\n",
    "    return str_input.lower()\n",
    "\n",
    "# now we are back on the main execution\n",
    "print (make_strings_lowercase(\"UPPER CASE\"))\n",
    "print (make_strings_lowercase(\"Data Mining\"))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n",
      "====================\n",
      "[1, 2, 3, 4, 5]\n",
      "[1, 2, 3, 4, 5]\n",
      "a cool X value\n",
      "[1, 2, 3, 4, 5]\n",
      "a cool X value\n",
      "a cool Y value\n",
      "====================\n",
      "(4, 1024)\n"
     ]
    }
   ],
   "source": [
    "# more functions examples\n",
    "def show_data(data):\n",
    "    # print the data\n",
    "    print (data)\n",
    "\n",
    "some_data = [1,2,3,4,5]\n",
    "show_data(some_data)\n",
    "\n",
    "# you can also define default values for the functions\n",
    "print ('====================')\n",
    "def show_data(data,x=None,y=None):\n",
    "    # print the data\n",
    "    print (data)\n",
    "    if x is not None:\n",
    "        print (x)\n",
    "    if y is not None:\n",
    "        print (y)\n",
    "\n",
    "some_data = [1,2,3,4,5]\n",
    "show_data(some_data);\n",
    "show_data(some_data,x='a cool X value')\n",
    "show_data(some_data,y='a cool Y value',x='a cool X value') \n",
    "\n",
    "# as well as have multiple return types in the function\n",
    "print ('====================')\n",
    "def get_square_and_tenth_power(x):\n",
    "    return x**2,x**10\n",
    "\n",
    "print (get_square_and_tenth_power(2) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name: Heart has 1 beats per second\n",
      "This is a long string meant to be so long that the memory for it is not cached by python\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# This is a class that inherits from a generic object\n",
    "class BodyPart(object):\n",
    "    kind = \"This is a long string meant to be so long that the memory for it is not cached by python\"\n",
    "    # this is a class variable, shared across all instances\n",
    "    def __init__(self,name):\n",
    "        self.name = name # the name attribute is unique to each instance of the BodyPart class\n",
    "\n",
    "# now define a class that sub classes from the defined BodyPart CLass\n",
    "class Heart(BodyPart):\n",
    "    def __init__(self,rate=60,units=\"minute\"):\n",
    "        self.rate = rate\n",
    "        self.units= units\n",
    "        super().__init__(\"Heart\")\n",
    "        \n",
    "\n",
    "    def print_rate(self):\n",
    "        print (\"name: \" + str(self.name) + \" has \" + str(self.rate) + \" beats per \" + self.units) \n",
    "        \n",
    "\n",
    "my_heart = Heart(1,\"second\")\n",
    "my_heart.print_rate()\n",
    "\n",
    "generic_part = BodyPart(\"Foot\")\n",
    "print (my_heart.kind)\n",
    "print (my_heart.kind is generic_part.kind) # true, these are the same memory location\n",
    "\n",
    "# take the following for example, these are not the same object\n",
    "a = \"This is a long string meant to be so long that the memory for it is not cached by python\"\n",
    "b = \"This is a long string meant to be so long that the memory for it is not cached by python\"\n",
    "print (a is b) # not the same memory location"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 5\n",
      "\n",
      "Some value is out of range: list index out of range\n"
     ]
    }
   ],
   "source": [
    "# error handling and exceptions\n",
    "# Python exception handling.\n",
    "\n",
    "# example reissued from: http://sandbox.mc.edu/~bennet/python/code/exc_py.html\n",
    "\n",
    "# Choose two random integers.\n",
    "import random\n",
    "i = random.randrange(0, 8)\n",
    "j = random.randrange(-1, 6)\n",
    "print (i, j)\n",
    "\n",
    "# Get a nice little array, then try a bunch of dangerous stuff.\n",
    "some = [3, 10, 0, 8, 18];\n",
    "try:\n",
    "    # We try to execute this block.\n",
    "    den = some[j] / i\n",
    "    print (\"A:\", den)\n",
    "    frac = (i + j) / den\n",
    "    print (\"B:\", frac)\n",
    "    if frac < 2:\n",
    "        k = 3\n",
    "    else:\n",
    "        k = 'mike'\n",
    "    print (\"C:\", k)\n",
    "    print (\"D:\", some[k])\n",
    "    # This is the catch block.\n",
    "except ZeroDivisionError:\n",
    "    print( \"\\nDivision by zero.\")\n",
    "except TypeError as err:\n",
    "    # The detail provides extra information about the exception.\n",
    "    print( \"\\nSome type mismatch:\", err)\n",
    "except IndexError as err:\n",
    "    print (\"\\nSome value is out of range:\", err)\n",
    "except:\n",
    "    # Except without an exception name catches any exception.\n",
    "    print( \"\\nSomething else went wrong.\")\n",
    "\n",
    "# An else attached to an except block is run if no exception occurrs.\n",
    "else:\n",
    "    print (\"\\nThat's odd, nothing went wrong.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# create a file to read from\n",
    "!echo \"Some File\" > some_file.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read successfully, file contents:\n",
      "Some File\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# the with command and opening a file\n",
    "\n",
    "# the regular way of opening a file, lots of error checking\n",
    "try:\n",
    "    file = open(\"some_file.txt\")\n",
    "    data = file.read()\n",
    "except IOError as err:\n",
    "    print (\"\\nCould not read file:\", err)\n",
    "else:\n",
    "    print (\"Read successfully, file contents:\")\n",
    "    print (data)\n",
    "finally:\n",
    "    # this always gets called, close the file if its open\n",
    "    if not file.closed:\n",
    "        file.close()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Read successfully, file contents:\n",
      "Some File\n",
      "\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# the \"file\" class actually has a built in __init__ and __exit__\n",
    "# so we can really on their class implemntation to close the file propoerly\n",
    "# and handle any exceptions gracefully\n",
    "\n",
    "# in that respect, the \"with\" statement is a protocol that the \"file class\" adopts\n",
    "\n",
    "with open(\"some_file.txt\") as file:\n",
    "    data = file.read()\n",
    "    print (\"Read successfully, file contents:\")\n",
    "    print (data)\n",
    "\n",
    "# is the file closed? Let's check\n",
    "print (file.closed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Just initialized body part with name Lungs\n",
      "2. Building up from \"with\" command\n",
      "3. Hi, my name is: Lungs\n",
      "4. Exit was called, no errors\n"
     ]
    }
   ],
   "source": [
    "# you can also define your own classes that adopt the \"with\" protocol,\n",
    "# if you are interested check out the example \n",
    "class BodyPart(object):\n",
    "    def __init__(self,name):\n",
    "        self.name = name\n",
    "        print ('1. Just initialized body part with name', name)\n",
    "        \n",
    "    def __enter__(self):\n",
    "        print ('2. Building up from \"with\" command' )\n",
    "        return self\n",
    "        \n",
    "    def __exit__(self, type, value, traceback):\n",
    "        if value is not None:\n",
    "            print ('4. An error occurred,', value)\n",
    "        else:\n",
    "            print ('4. Exit was called, no errors')\n",
    "            \n",
    "    def print_self(self):\n",
    "        # 5/0 # uncomment to raise an error\n",
    "        print ('3. Hi, my name is:', self.name)\n",
    "\n",
    "with BodyPart(\"Lungs\") as bp:\n",
    "    bp.print_self()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Importing Libraries\n",
    "Python shipd with many libraries already packaged. You simply import them using the \"import\" command. However, you can also install many third party libraries, of which there are many for data wrangling. In the next examples we will use some built in libraries, as well as ones that are third party.\n",
    "\n",
    "For installing the third party libraries, you will need to install a package mananger. There are three main ones that you may want to use on your system:\n",
    "+ Anaconda's system (`conda`), https://www.continuum.io/downloads\n",
    "+ Pip, https://pypi.python.org/pypi/pip\n",
    "+ Homebrew, http://brew.sh\n",
    "+ Macports, https://www.macports.org\n",
    "    \n",
    "I have had the best luck using anaconda. But you will need to explore the options and decide which one is right for your system. If you are using windows, anaconda or pip is the way to go. If you do not want the setup to affect other libraries installed on your system, consider setting up a virtual environment (which is built into anaconda).\n",
    "\n",
    "Now go our and install the Numpy and Matplotlib systems on your system! It might be as simple as:\n",
    "     > conda install numpy\n",
    "     > conda install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.999874127674\n",
      "-1.22464679915e-16\n"
     ]
    }
   ],
   "source": [
    "# with the package installed, we can import the libraries and use them.\n",
    "\n",
    "# The numpy package is great for working with groups of numbers as matrices\n",
    "# and has many functionalities that are comparable to Matlab and Octave\n",
    "import numpy as np\n",
    "t = np.linspace(0, 1, 100)  # 100 equally spaced array of numbers from 0.0 to 1\n",
    "y = np.sin(2 * np.pi * t)  # take sine of the value\n",
    "\n",
    "print (np.max(y))\n",
    "print (np.median(y))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYEAAAEACAYAAABVtcpZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10ac6c860>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Matplotlib has a number of plotting tools that are extremely powerful for\n",
    "# exploring data. The plotting functionality is simliar to R, but many times\n",
    "# it is easier of more customizable. \n",
    "# Note: everthying you know in \"R\" will come back full circle. Python and R play very \n",
    "#   nicely with one another and python can call R code, share memory with it, and use its plotting functions\n",
    "#   ...with the correct libraries installed! Check out Rpy2, http://rpy.sourceforge.net \n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "#============================================\n",
    "# plotting example\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "plt.plot(t, y)  # plot them\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.6.0\n"
     ]
    }
   ],
   "source": [
    "# this library ships with python and is for accessing SQL\n",
    "# You will learn how to use the module more extensively in the future!\n",
    "# here, we will just import it and get its version\n",
    "import sqlite3\n",
    "\n",
    "print (sqlite3.version)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# this is \n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Debugging\n",
    "\n",
    "Debugging in python is much like any other programming language. If you use the command line to run programs, you need to be able to catch and interpret runtime errors. There is no compilation process (that we have talked about), so all errors will occur at runtime--that includes things like spelling errors. Because of this, it is critical to run your code in varying contexts. That also means exploring ways that it could fail by changing the values of different variables.\n",
    "\n",
    "One easy way to do this is by the using the pdb package. You can run it from the iPython notebook, but it gets quite long on the output trace. You will likely want to copy this test over to another document (for example, debugging.py) and run it from the command line (for example, >python debugging.py). The pdb library allows you to set break points in the files and also step through the program, changing the variable values. \n",
    "\n",
    "+ import pdb\n",
    "    + pdb.set_trace()\n",
    "+ command line arguments\n",
    "    + s(tep), c(ontinue), n(ext), w(here), l(ist), r(eturn), j(ump)\n",
    "+ and much more… like print, p, pp\n",
    "+ can set numbered break points by running from python window\n",
    "    + python -m pdb your_function.py "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "> <ipython-input-37-25daee69af4d>(4)<module>()\n",
      "-> for i in range(0,5):\n",
      "(Pdb) c\n",
      "> <ipython-input-37-25daee69af4d>(4)<module>()\n",
      "-> for i in range(0,5):\n",
      "(Pdb) c\n",
      "> <ipython-input-37-25daee69af4d>(4)<module>()\n",
      "-> for i in range(0,5):\n",
      "(Pdb) c\n",
      "> <ipython-input-37-25daee69af4d>(4)<module>()\n",
      "-> for i in range(0,5):\n",
      "(Pdb) c\n",
      "> <ipython-input-37-25daee69af4d>(4)<module>()\n",
      "-> for i in range(0,5):\n",
      "(Pdb) \n",
      "(Pdb) c\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "import pdb\n",
    "\n",
    "j = 0\n",
    "for i in range(0,5):\n",
    "    j += 5*i\n",
    "    pdb.set_trace()\n",
    "    \n",
    "print (j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is still plenty more to learn about python, but now you have the basics. One topic that may be intersting to you is the concept of decorators, discussed here:\n",
    "    http://simeonfranklin.com/blog/2012/jul/1/python-decorators-in-12-steps/\n",
    "    \n",
    "Essentially, decorators are ways of manipulating functions with other functions. Mostly, this means recycling the functionality of one function to create a new function. \n",
    "\n",
    "There is also much to be learned about iterators, yield, etc. Python is an active language and it is still evolving!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [MLEnv]",
   "language": "python",
   "name": "Python [MLEnv]"
  },
  "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
}