Tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sherman's One-Hour Python Tutorial\n",
    "\n",
    "Let's learn some basics of python in 60 minutes.\n",
    "\n",
    "We'll assume you already have python 3 installed.\n",
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Running Python Interactively\n",
    "\n",
    "The `python` command starts the python interpreter.\n",
    "\n",
    "```bash\n",
    "bash$ python3\n",
    "```\n",
    "\n",
    "You will see the following prompt:\n",
    "\n",
    "```\n",
    "Python 3.6.2 (default, Jul 17 2017, 16:44:45) \n",
    "[GCC 4.2.1 Compatible Apple LLVM 8.1.0 (clang-802.0.42)] on darwin\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "\n",
    "Now try telling python to do something:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 410,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Running a Python Script\n",
    "\n",
    "This is a simple python script, which we'll save as tut1.py:\n",
    "\n",
    "```python\n",
    "#!/usr/bin/env python\n",
    "print(\"hello world\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make the script executable:\n",
    "\n",
    "```bash\n",
    "bash$ chmod +x tut1.py\n",
    "bash$\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Run the script from the command prompt:\n",
    "\n",
    "```bash\n",
    "bash$ ./tut1.py\n",
    "hello world\n",
    "bash$\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You have just written and executed your first python program!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Variables in Python\n",
    "\n",
    "You create a variable just by assigning to it. No var or other\n",
    "instantiation keywords. No declaration, just assign."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 371,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n",
    "y = \"foo\"\n",
    "pi = 3.14159265"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Numbers in Python\n",
    "\n",
    "Integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 372,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.3333333333333335\n"
     ]
    }
   ],
   "source": [
    "x = 10\n",
    "y = 3\n",
    "print(x/y) # prints 3.33333333\n",
    "           # (notice that integer division gives you a float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floating Point:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 373,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.44879895000000003\n"
     ]
    }
   ],
   "source": [
    "x = 3.14159265\n",
    "y = 7\n",
    "print(x/y) # prints 0.44879895000000003"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Control Flow\n",
    "\n",
    "Blocks are defined in python by indenting the code.\n",
    "\n",
    "The `if` statement executes the indented code block if the condition\n",
    "evaluates to `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 374,
   "metadata": {},
   "outputs": [],
   "source": [
    "condition = True\n",
    "statement = \"statement\"\n",
    "\n",
    "if condition:\n",
    "    statement\n",
    "elif condition:\n",
    "    statement\n",
    "else:\n",
    "    statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Another form of if is the ternary operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 375,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is now equal to 5\n"
     ]
    }
   ],
   "source": [
    "y = 7\n",
    "x = 5 if y>1 else 10 # x is now equal to 5\n",
    "print(\"x is now equal to \" + str(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops\n",
    "\n",
    "The for loop iterates over a sequence:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 376,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bob\n",
      "sam\n",
      "ben\n",
      "sue\n",
      "bev\n"
     ]
    }
   ],
   "source": [
    "for name in [ \"bob\", \"sam\", \"ben\", \"sue\", \"bev\" ]:\n",
    "    print(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use the range function to use a numeric counter:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 377,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print(i) # prints 0, 1, 2, 3, 4, 5, 6, 7, 8, 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The while loop iterates as long as a condition is true:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 378,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "i = 0\n",
    "while i < 10:\n",
    "    print(i)\n",
    "    i = i+1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Exiting a Loop\n",
    "\n",
    "The `continue` statement skips to the next iteration of the loop and\n",
    "continues looping:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 379,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(i) # prints 0 1 2 4 5 6 7 8 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `break` statement skips out of the loop without executing any more\n",
    "iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 380,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i == 3:\n",
    "        break\n",
    "    print(i) # prints 0 1 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Else\n",
    "\n",
    "The `else` is not just used after `if`, but can follow a loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 381,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "else\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    pass # this statement does nothing! use it as a placeholder\n",
    "else:\n",
    "    print(\"else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `else` block is only executed after the loop condition evaluates\n",
    "as `False`, but not following a `break`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 382,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "done\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    if i == 3:\n",
    "        break\n",
    "else:\n",
    "    print(\"else\")   # this line is skipped\n",
    "\n",
    "print(\"done\")       # prints \"done\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sequence Types\n",
    "\n",
    "There are six sequence types in python: str, unicode, list, tuple, buffer, xrange.\n",
    "We are going to talk about str, list, tuple."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access elements of a sequence (such as a string) using brackets. The indexes\n",
    "start with zero:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 383,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b\n",
      "a\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "x = \"bar\"\n",
    "print(x[0]) # b\n",
    "print(x[1]) # a\n",
    "print(x[2]) # r"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This may look familiar like arrays in other languages."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings are written using single or double quotes. Strings with double\n",
    "quotes can contain apostrophes or single quotes. Strings with single quotes\n",
    "can contain double quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 384,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "14\n",
      "t\n"
     ]
    }
   ],
   "source": [
    "x = \"this is a test\"\n",
    "print( len(x) ) # prints 14\n",
    "print( x[10] )  # prints t\n",
    "y = \"we're home!\"\n",
    "z = 'sam says \"hi\"'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lists and Tuples\n",
    "\n",
    "Lists are constructed with brackets and every element should be the same\n",
    "type. Lists can be changed and appened (mutable)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 385,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new\n"
     ]
    }
   ],
   "source": [
    "mylist = [ \"foo\", \"bar\", \"baz\", \"wow\" ]\n",
    "mylist[3] = \"new\"\n",
    "print( mylist[3] ) # prints \"new\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are created with parentheses. They can not be appended nor can elements\n",
    "be replaced (immutable).  You would have to create a new tuple with different\n",
    "elements instead."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 386,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo\n",
      "TypeError!\n"
     ]
    }
   ],
   "source": [
    "mytuple = (1, \"foo\", 3.14159265)\n",
    "print( mytuple[1] ) # prints \"foo\"\n",
    "try:\n",
    "    mytuple[1] = \"bar\" # TypeError: 'tuple' object does not support item assignment\n",
    "except TypeError:\n",
    "        print(\"TypeError!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 387,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq = [ \"apple\", \"banana\", \"pear\", \"grape\", \"plum\" ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Slice `seq[ start : stop ]` copies a sequence from the original sequence, where\n",
    "`start` is the index of the first element to copy, and `stop` is the index of the\n",
    "element after the last element to copy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 388,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['banana', 'pear']"
      ]
     },
     "execution_count": 388,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq[1:3] # ['banana', 'pear']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Negative indexes count backwards from the end of the list. This works for\n",
    "indexing single elements or slices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 389,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 389,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq[1:-1] # ['banana', 'pear', 'grape']\n",
    "seq[-3:3] # ['pear']\n",
    "seq[-1:1] # []"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You may omit either index in the slice to read from the start or to the end\n",
    "of the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 390,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['apple', 'banana', 'pear', 'grape', 'plum']"
      ]
     },
     "execution_count": 390,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seq[2:]  # ['pear', 'grape', 'plum']\n",
    "seq[:-3] # ['apple', 'banana']\n",
    "seq[:]   # copy the entire list!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dictionaries\n",
    "\n",
    "A dictionary maps keys to values. It is an unordered collection of key/value\n",
    "pairs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 391,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = { \"foo\": 37, \"bar\": 99, \"baz\": 42, \"woo\": 0 }"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Access a key using bracket notation. You can add new keys this way too:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 392,
   "metadata": {},
   "outputs": [],
   "source": [
    "d[\"foo\"] # 37\n",
    "d[\"what\"] = 45"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remove a key using `del` operator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 393,
   "metadata": {},
   "outputs": [],
   "source": [
    "del d[\"bar\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the `in` operator to check if a key exists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 394,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 394,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"foo\" in d # True\n",
    "\"noo\" in d # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Comprehensions\n",
    "\n",
    "A list comprehension is a construct that generates a new list by\n",
    "transforming a list.\n",
    "\n",
    "The syntax: `[ expression for item in list if conditional ]`\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 395,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 395,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x+1 for x in range(10) if x % 2 == 0] # [ 1, 3, 5, 7, 9 ]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions\n",
    "\n",
    "Define a function using `def`. Returning a value works similarly to other\n",
    "languages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 396,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube( x ):\n",
    "    return x * x * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function vs Global Scope\n",
    "\n",
    "Variables in a function are assumed to be local unless marked as global:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 397,
   "metadata": {},
   "outputs": [],
   "source": [
    "glob = 0\n",
    "def doSomething( x ):\n",
    "    global glob\n",
    "    glob += x\n",
    "    print(glob)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Global variables are visible within a function but assignment creates a new\n",
    "local which shadows the global."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 398,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 398,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "meaning_of_life = 42\n",
    "def life(x):\n",
    "    if x == meaning_of_life:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "life(39) # false\n",
    "life(42) # true"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Function Arguments\n",
    "\n",
    "Function arguments can have default values. The arguments are positional, so\n",
    "those with defaults must be specified last in the argument list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 399,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 5\n"
     ]
    }
   ],
   "source": [
    "def myfunc( x, y=8, z=5 ):\n",
    "    print(x, y, z)\n",
    "\n",
    "myfunc( 1, 2 ) # prints (1, 2, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you call a function you can specify arguments by name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 400,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7 8 9\n"
     ]
    }
   ],
   "source": [
    "myfunc(7, z=9) # prints (7, 8, 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can use `*args` and `**kwargs` to capture arguments without specifying\n",
    "them in advance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 401,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 12, 'b': 'abc'}\n"
     ]
    }
   ],
   "source": [
    "def my_function(**kwargs):\n",
    "    print (kwargs)\n",
    "\n",
    "my_function(a=12, b=\"abc\") # {'a': 12, 'b': 'abc'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda Forms\n",
    "\n",
    "You can create an anonymous function in python using lambda:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "64"
      ]
     },
     "execution_count": 402,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = lambda x: x**2 # ** is the exponent operator\n",
    "\n",
    "g(8) # 64"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Map / Reduce\n",
    "\n",
    "Map transforms a sequence into another sequence. This is equivalent to a\n",
    "list comprehension. Comprehensions are usually considered more 'pythonic':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9]"
      ]
     },
     "execution_count": 403,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map( lambda x: x**2, [1,2,3] ) # [1, 4, 9]\n",
    "\n",
    "[ x**2 for x in [1,2,3] ]      # [1, 4, 9]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reduce transforms a sequence into a single value. The lambda function takes\n",
    "two arguments which are the first two elements of the list, and in later\n",
    "iterations they are the result of the last call and the next element of the\n",
    "list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102"
      ]
     },
     "execution_count": 404,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import functools\n",
    "\n",
    "f = lambda a,b: a if (a > b) else b\n",
    "\n",
    "functools.reduce(f, [47,11,42,102,13]) # 102"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[The reduce example is from an online course.](http://www.python-course.eu/lambda.php)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules\n",
    "\n",
    "Use the `import` keyword to import functions from another module:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 405,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "82"
      ]
     },
     "execution_count": 405,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import random\n",
    "from math import floor\n",
    "floor( random.random() * 100 ) # ???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You create your own modules by creating a new python file (`*.py`), then you can\n",
    "import it using the filename minus the extension.\n",
    "\n",
    "```python\n",
    "# for file mymodule.py containing function 'myfunction'\n",
    "import mymodule                 # mymodule.myfunction()\n",
    "import mymodule.myfunction      # mymodule.myfunction()\n",
    "from mymodule import myfunction # myfunction()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "# Packages\n",
    "\n",
    "A package is a directory with multiple modules and an `__init__.py` in it. You\n",
    "can import the entire package or individual modules or functions.\n",
    "\n",
    "```bash\n",
    "bash$ ls -la mypackage/\n",
    "total 0\n",
    "drwxr-xr-x  4 sherman  sherman  136 Jul 29 08:44 .\n",
    "drwxr-xr-x  9 sherman  sherman  306 Jul 29 08:44 ..\n",
    "-rw-r--r--  1 sherman  sherman    0 Jul 29 08:44 __init__.py\n",
    "-rw-r--r--  1 sherman  sherman    0 Jul 29 08:44 mymodule.py\n",
    "```\n",
    "\n",
    "```python\n",
    "# we want to use function 'myfunction'\n",
    "import mypackage                          # mypackage.mymodule.myfunction()\n",
    "import mypackage.mymodule                 # mypackage.mymodule.myfunction()\n",
    "from mypackage import mymodule            # mymodule.myfunction()\n",
    "from mypackage.mymodule import myfunction # myfunction()\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[python tutorial](https://docs.python.org/2/tutorial/modules.html)\n",
    "\n",
    "[about modules and packages](https://www.learnpython.org/en/Modules_and_Packages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes\n",
    "\n",
    "Everything in python is an object."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Create a class using the class keyword:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def myfunc(self, x):\n",
    "        print(x)\n",
    "\n",
    "m = MyClass()\n",
    "\n",
    "m.myfunc(4) # 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use an `__init__` function for a constructor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 7\n"
     ]
    }
   ],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, foo, bar):\n",
    "        self.foo = foo\n",
    "        self.bar = bar\n",
    "    def printme(self):\n",
    "        print(self.foo, self.bar)\n",
    "\n",
    "m = MyClass(5, 7)\n",
    "m.printme() # (5, 7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Class Participation!\n",
    "\n",
    "An exercise commonly used in job interviews is Fizz Buzz. We're going to\n",
    "write a Fizz Buzz solution in python using the skills you just learned.\n",
    "\n",
    "With the numbers 1 through 100, print 'Fizz' if the number is a multiple of\n",
    "3, or print 'Buzz' if the number is a multiple of 5. If the number is both a\n",
    "multiple of 3 and a multiple of 5, print 'Fizzbuzz'. If the number is not a\n",
    "multiple of either 3 or 5, print the number."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 408,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "fizz\n",
      "4\n",
      "buzz\n",
      "fizz\n",
      "7\n",
      "8\n",
      "fizz\n",
      "buzz\n",
      "11\n",
      "fizz\n",
      "13\n",
      "14\n",
      "fizzbuzz\n",
      "16\n",
      "17\n",
      "fizz\n",
      "19\n",
      "buzz\n",
      "fizz\n",
      "22\n",
      "23\n",
      "fizz\n",
      "buzz\n",
      "26\n",
      "fizz\n",
      "28\n",
      "29\n",
      "fizzbuzz\n",
      "31\n",
      "32\n",
      "fizz\n",
      "34\n",
      "buzz\n",
      "fizz\n",
      "37\n",
      "38\n",
      "fizz\n",
      "buzz\n",
      "41\n",
      "fizz\n",
      "43\n",
      "44\n",
      "fizzbuzz\n",
      "46\n",
      "47\n",
      "fizz\n",
      "49\n",
      "buzz\n",
      "fizz\n",
      "52\n",
      "53\n",
      "fizz\n",
      "buzz\n",
      "56\n",
      "fizz\n",
      "58\n",
      "59\n",
      "fizzbuzz\n",
      "61\n",
      "62\n",
      "fizz\n",
      "64\n",
      "buzz\n",
      "fizz\n",
      "67\n",
      "68\n",
      "fizz\n",
      "buzz\n",
      "71\n",
      "fizz\n",
      "73\n",
      "74\n",
      "fizzbuzz\n",
      "76\n",
      "77\n",
      "fizz\n",
      "79\n",
      "buzz\n",
      "fizz\n",
      "82\n",
      "83\n",
      "fizz\n",
      "buzz\n",
      "86\n",
      "fizz\n",
      "88\n",
      "89\n",
      "fizzbuzz\n",
      "91\n",
      "92\n",
      "fizz\n",
      "94\n",
      "buzz\n",
      "fizz\n",
      "97\n",
      "98\n",
      "fizz\n",
      "buzz\n"
     ]
    }
   ],
   "source": [
    "for x in range(100):\n",
    "    n = x+1\n",
    "    if n % 5 == 0 and n % 3 == 0:\n",
    "        print(\"fizzbuzz\")\n",
    "    elif n % 3 == 0:\n",
    "        print(\"fizz\")\n",
    "    elif n % 5 == 0:\n",
    "        print(\"buzz\")\n",
    "    else:\n",
    "        print(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x10a8c2e10>"
      ]
     },
     "execution_count": 409,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def prn(w):\n",
    "    print(w)\n",
    "\n",
    "map( prn,\n",
    "    [ ( \"fizzbuzz\" if x % 15 == 0 else\n",
    "       ( \"fizz\" if x % 3 == 0 else\n",
    "        ( \"buzz\" if x % 5 == 0 else\n",
    "         x) ) ) for x in\n",
    "     [x+1 for x in range(100)] ])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Done!\n",
    "\n",
    "You have now completed the tutorial mission. That means you are now\n",
    "qualified to write python code!\n",
    "\n",
    "Congratulations on your new skill!"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}