02-Python-functions-modules.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np #We will use numpy in this lecture"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Tutorial II: Logic, functions, loops, and modules\n",
    "\n",
    "In this lecture, we will explore how to control workflow in a code using conditionals and loops. \n",
    "For more information, we recommend reviewing some of the online documentation available at https://docs.python.org/3/tutorial/controlflow.html. \n",
    "We will also see how to make code more modular by creating user-defined functions and modules. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Conditionals & Comparisons in Python\n",
    "    \n",
    "### Conditionals in Python    \n",
    "0. In Python, there are no \"case\" or \"switch\" options that are available in other languages, but we can get the same functionality by using dictionary mappings. However, this is beyond the scope of this tutorial. \n",
    "1. You will find that most things can be done using the if/elif/else syntax:\n",
    "```\n",
    "if condition:\n",
    "    #do stuff\n",
    "elif condition: #elif is interpreted as \"else if\"\n",
    "    #do stuff\n",
    "else:\n",
    "    #do stuff\n",
    "```       \n",
    "\n",
    "***All parts of the conditional are indented.*** \n",
    "Unlike other languages that use terms like \"end\" or \"end if\" (or perhaps make use of brackets like \"{ }\") to signify the block of code corresponding to an if-elseif-else, ***Python interprets everything in terms of indenting.*** \n",
    "This is also true in for-loops as we will see below.\n",
    "       \n",
    "### Comparison operators  (*LET a=3, b=5*)\n",
    "==:\tIf the values of two operands are equal, then the condition becomes true.\t*(a == b) is not true.*\n",
    "\n",
    "!=:\tIf values of two operands are not equal, then condition becomes true.  *(a != b) is true.* (Alternatively, one could use `<>` in place of `!=`, but this is not very common.)\n",
    "\n",
    " \">\":\tIf the value of left operand is greater than the value of right operand, then condition becomes true.\t*(a > b) is not true.*\n",
    "\n",
    "\"<\": If the value of left operand is less than the value of right operand, then condition becomes true.\t*(a < b) is true.*\n",
    "\n",
    "\">=\":\tIf the value of left operand is greater than or equal to the value of right operand, then condition becomes true.\t*(a >= b) is not true.*\n",
    "\n",
    "\"<=\":\tIf the value of left operand is less than or equal to the value of right operand, then condition becomes true.\t*(a <= b) is true.*\n",
    "\n",
    "We can use **and** and **or** to combine sets of comparison operators and **not** to negate a statement. \n",
    "\n",
    "Try changing different values of `x` in the code snippets below and see what happens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 1.3 # Try different values\n",
    "\n",
    "if x >= 0 and not(x == 2 or x == 3):\n",
    "    f = np.power(x,.5)/((x-2.0)*(x-3.0))\n",
    "    print( f )\n",
    "elif x < 0:\n",
    "    print( 'Square root of negative number' )\n",
    "    f = np.nan\n",
    "elif x == 2.0:\n",
    "    print( 'Division by zero with different limits' )\n",
    "    f = np.nan"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 1\n",
    "\n",
    "Complete the code below to evaluate\n",
    "$$\n",
    "    f(x) = \\begin{cases}\n",
    "                1 + x, & x\\in[-1,0], \\\\\n",
    "                1 - x, & x\\in(0, 1], \\\\\n",
    "                0, & \\text{else}.\n",
    "            \\end{cases}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = -.25 # Try different values\n",
    "\n",
    "if -1 <= x and :\n",
    "    f = \n",
    "elif :\n",
    "    f = \n",
    "else: \n",
    "    f = \n",
    "    \n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions in Python (Motivation) \n",
    "In the code snippets above, a value of `x` serves as the input into a conditional statement that determines what output value `f` should be assigned based on the value of `x`. If we wish to use this functionality many times in the code, we would probably like to avoid writing the if/elif/else structure at each point where it is to be used for a variety of reasons including, but not limited to, the following:\n",
    "\n",
    "- If we ever decide to change how `f` is computed, then we would have to find/replace every instance of it within the code (likely leading to errors, or worse yet, code that does not crash but gives wrong outputs).\n",
    "\n",
    "- Even the most terse scientific code can easily become hundreds (if not thousands) of lines long, and we want to avoid making the code more difficult to read, use, and debug than is absolutely necessary. \n",
    "\n",
    "This motivates the development of user-defined functions in Python. The basic syntax is shown below.\n",
    "\n",
    "```\n",
    "def functionname( parameters ):\n",
    "   \"\"\"function_docstring\"\"\"\n",
    "   function_suite\n",
    "   return [expression]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A brief discussion on docstrings and commenting in code\n",
    "The (triple) quotes is where you put in a documentation string for your function.  It is entirely optional, but it is always a good idea to document your code even when it is entirely in the developmental/testing phase. There are some best practices that you can read about at https://docs.python.org/devguide/documenting.html or http://docs.python-guide.org/en/latest/writing/documentation/. \n",
    "\n",
    "Good tools such as Sphinx http://www.sphinx-doc.org/en/1.4.8/ can turn properly documented code into easy to read/navigate html files to help expand the community of users for any code you develop. For example, see http://ut-chg.github.io/BET/ where Sphinx was used to generate the documentation. These tools are outside the scope of this tutorial, but we highly recommend that you learn a bit about them before attemping to make very sophisticated software packages. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### parameters and keyword arguments in a function\n",
    "Notice that in the definition of the function, there is a `parameters` variable, which is often a list of parameters (as shown below). These are normally ordered **UNLESS** you supplement them with *keyword args* in the function call (i.e., when you actually use the function you may specify which argument corresponds to which parameter).  \n",
    "The next few code snippet illustrates this."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def myfun1(x,y):\n",
    "    if x < y:\n",
    "        z = x + 2*y\n",
    "    else:\n",
    "        z = x - 2*y\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1(2,3) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1(2.0,3.0) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1(3.0,2.0) ) #switching order of inputs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1(x=2,y=3.0) ) #keyword argument"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1(y=3.0,x=2.0) ) #switching the order of inputs of keyword arguments does nothing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Try printing myfun1(x=2,3.0). \n",
    "\n",
    "print( myfun1(x=2,3.0) )\n",
    "\n",
    "# The take home message? \n",
    "# Once you commit to using keywords in a function call, \n",
    "# then you better be all in."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1('silly ','test') )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "z = myfun1(2,3)\n",
    "print( z )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obviously Python does not use type-checking for functions, but it allows useful types of polymorphism.\n",
    "\n",
    "Python also allows to set defaults within the parameter list of a function call.  Let's tweak `myfun1` a little.\n",
    "\n",
    "Defaults need to **come after** functions parameters with non-default values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def myfun2(x=1,y=2):\n",
    "    if x<y:\n",
    "        z = x + 2*y\n",
    "    else:\n",
    "        z = x - 2*y\n",
    "    return z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print( myfun2() )\n",
    "print( myfun2(1.0) )\n",
    "print( myfun2(y=3) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**We can even pass a function to another function!**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( myfun1( myfun2(), myfun2(y=3) ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mini-exercise 2\n",
    "\n",
    "Complete the code below that either converts a temperature given in Celsius to Fahrenheit, a temperature given in Fahrenheit to Celsius, or if two temperatures are given (one in Celsius and one in Fahrenheit) will check if they are the same."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def tempFunc(F=None, C=None):\n",
    "    if F == None and C == None:\n",
    "        print('You want nothing?')\n",
    "    elif F == None: #So C is given\n",
    "        print( str(C) + ' Celsius = ' \n",
    "              + str(C * 9/5 + 32) + ' Fahrenheit' )\n",
    "    elif : #So F is given\n",
    "        print( )\n",
    "    else: #So F and C are both given\n",
    "        if np.abs(F - (C*9/5+32)) < np.finfo(np.float32).eps:\n",
    "            print('Those temperatures are the same!')\n",
    "        else:\n",
    "            print('Those temperatures are different!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tempFunc(F=212, C = 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python is pass by reference OR pass by value\n",
    "\n",
    "First, we want to say that it is okay if this does not make perfect sense the first (ten) time(s) you work through this. \n",
    "For more information on this, we encourage you to do some searching online (the answers provided here: https://stackoverflow.com/questions/373419/whats-the-difference-between-passing-by-reference-vs-passing-by-value are a good place to start) and playing around with the simple code below to build intuition.\n",
    "***Basically, there is very little substitute for some time and patience in learning this correctly. Here, we seek to just build some basic intuition about what is going on so that you can be aware of some potential pitfalls.***\n",
    "\n",
    "### Metaphorically speaking...\n",
    "Suppose you are the function and I am passing you information metaphorically in terms of information written on paper:\n",
    "\n",
    "   * Call by value is where I copy something from one piece of paper onto another piece of paper and hand the copy to you. Maybe the information includes that `x=5`. This information is now on a piece of paper which I have given to you, so now it is effectively your piece of paper. You are now free to write on that piece of paper to use that information however you please. Maybe you decide to act upon this information by multiplying the variable `x` by 2, so that you write that now `x=10` on your piece of paper. Suppose you return that piece of paper to me. Does this change what was written on my piece of paper? No! However, I may choose to use your information to then update the information on my original paper.\n",
    "   \n",
    "   \n",
    "   * Call by reference is when I give you my original paper which has something written down in it like `x=5`. Now, if you decide that the value of `x` should be double so that you erase and replace `x=5` with `x=10` and then give me the paper back, my paper now contains this updated information about `x` regardless if I wanted it to or not. I guess if I did not want that information to be there, then I should have passed by value.\n",
    "\n",
    "### Technically speaking...\n",
    "####  *Pass by reference*\n",
    "This means Python passes the reference to the variable, not just the value.  This can cause some different behavior when certain *in place* operators are used.  Classes, numpy arrays, etc. are passed by reference.\n",
    "\n",
    "#### *Pass by value* \n",
    "This means Python passes the value and creates a new copy within the function. Variables that are strings, floats, and ints are passed by value (*they are immutable data types* meaning that the value is left unchanged by the function).\n",
    "\n",
    "Python variables created within a function also have local *scope*.\n",
    "- *scope* usually refers to the visibility of variables. In other words, which parts of your program can see or use it.  ***Local scope*** usually means only within the called function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def scope_test(var):\n",
    "    print()\n",
    "    print( 'The variable passed to scope_test is ' +\n",
    "           '\\n var = ', var)\n",
    "    var *= 2 #if var is mutable, replaces in place (pass-by-reference)\n",
    "    print()\n",
    "    print( 'Within scope_test, the passed variable is ' +\n",
    "          'changed to \\n var = ', var)\n",
    "    a = 3\n",
    "    print()\n",
    "    print('Within scope_test, we set the variable \\n a =', a)\n",
    "    return"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 2 #An integer is an immutable data type\n",
    "\n",
    "print( 'Before scope_test,\\n a =', a )\n",
    "scope_test(a)\n",
    "print()\n",
    "print( 'After scope_test,\\n a =', a )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.ones([2,2]) # numpy arrays are mutable\n",
    "\n",
    "print( 'Before scope_test, \\n a =', a )\n",
    "scope_test(a)\n",
    "print()\n",
    "print( 'After scope_test, \\n a =', a )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.ones([2,2]) # numpy arrays are mutable\n",
    "\n",
    "print( 'Before scope_test, \\n a =', a )\n",
    "scope_test(2*a)\n",
    "print()\n",
    "print( 'After scope_test(2*a), \\n a =', a )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Wait a minute...\n",
    "\n",
    "What if I want to do local work to a *mutable* data type (i.e. a numpy array) but not have the change reflected back after function exit?  \n",
    "\n",
    "The answer is to ***not*** use *in place* operators like +=, \\*=, etc.  `var = var*2` creates a local copy of var and multiplies 2 to every entry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def scope_test2(var):\n",
    "    var = var * 2  #if mutable, creates local copy of var.\n",
    "    return "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = np.eye(3) # creates 3x3 array with a_ii = 1, 0 otherwise.\n",
    "print('Before scope_test2,\\n a =', a)\n",
    "scope_test2(a)\n",
    "print()\n",
    "print('After scope_test2,\\n a =', a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Looping in Python\n",
    "\n",
    "### For loops\n",
    "\n",
    "**Syntax** \n",
    "```\n",
    "for iterator in list:\n",
    "    #indent for the loop\n",
    "    #do cool stuff in the loop\n",
    "#noindent to close the loop'\n",
    "```\n",
    "The list can be strings, for example:\n",
    "```\n",
    "for string in ('Alpha','Romeo','Sailor','Foxtrot'):\n",
    "    #string takes on values 'Alpha', 'Romeo', etc. in order.\n",
    "    print string\n",
    "```\n",
    "    \n",
    "\n",
    "You will commonly use the ``range`` command to build lists of numbers for iterating (see https://docs.python.org/3/library/functions.html#func-range).\n",
    "\n",
    "**SYNTAX** \n",
    "```\n",
    "range(stop)  #assumes start=0\n",
    "range(start, stop[, step])\n",
    "```\n",
    "\n",
    "Note that it **DOES NOT** execute the stop value.\n",
    "\n",
    "Let's  sum the first 20 terms of the geometric series corresponding to $2^{-n}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# You may want to create a new code block above this one to print out what the range function is doing\n",
    "\n",
    "partial_sum = 0\n",
    "for n in range(20):   #identical to range(0,20) or range(0,20,1)\n",
    "    partial_sum += 2**(-n)\n",
    "    print( 'Sum from n=0 to ' + str(n) + ' of 2^{-n} = ', partial_sum )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print( 'Now start subtracting from the sum' )\n",
    "    \n",
    "for n in range(19,-1,-1): \n",
    "    partial_sum -= 2**(-n)  \n",
    "    print( 'Sum from n=0 to ' + str(n-1) + ' of 2^{-n} = ', partial_sum )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While loops \n",
    "\n",
    "We often use ***while*** loops for iterative methods, such as fixed-point iterations. These are typically used when we are unsure exactly how many iterations a process should take.\n",
    "\n",
    "```\n",
    "while condition:   #this condition is true\n",
    "    do something cool\n",
    "    update condition, or use break or continue for loop control\n",
    "#no indent as at end of loop\n",
    "```\n",
    "If the the ``condition`` never becomes false, then this will result in an infinite loop, so be careful. It is therefore fairly common practice to include some type of counter which tracks the number of iterations, and negating the condition if the counter reaches a specified value.\n",
    "\n",
    "You can also exit from any for loop by using ``break`` to exit the innermost loop, and ``continue`` to continue to the next iteration of this loop\n",
    "\n",
    "Let's look at an example where we are trying to iterate a logistic equation \n",
    "$$\n",
    "    x_{n+1}=a\\cdot x_n (1-x_n)\n",
    "$$\n",
    "until we arrive at a fixed point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math as m\n",
    "\n",
    "a = 2.0\n",
    "xnew = .1\n",
    "tol = 1E-8\n",
    "doit = True  #boolean True and False \n",
    "it = 1\n",
    "while doit and it <= 5:\n",
    "    it += 1\n",
    "    xold = xnew\n",
    "    xnew *= a * (1-xnew)\n",
    "    if m.fabs(xnew-xold) > tol:\n",
    "        print('Iterating, X = ', xnew)\n",
    "        continue  #play it again, Sam\n",
    "    else:\n",
    "        break\n",
    "    print('This is skipped if the continue command is not commented out above.')\n",
    "print(\"Fixed Point=\",xnew)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Modules\n",
    "\n",
    "### What is it?\n",
    "* A file containing Python definitions and statements.\n",
    "* The file name is the module name with the suffix .py appended.\n",
    "* Within a module, the module's name is available as the valuable of the global variable *__name__*.\n",
    "\n",
    "### When to use:\n",
    "* Your script gets very long and you want to have easier maintenance. \n",
    "* You want to reuse a function in several programs or scripts without copy/paste.\n",
    "* Performance reasons.\n",
    "\n",
    "Let's look at an example:\n",
    "\n",
    "Go to the Home tab and left click on ``differences.py`` and then look at the code cell below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline   \n",
    "'''\n",
    "differences.py was included in the repo and should be located within \n",
    "the same directory as this lecture\n",
    "'''\n",
    "import differences as diff # We import the module just like we import numpy\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def myfun(x=0):\n",
    "    return np.exp(-x**2)*np.sin(np.pi*x)\n",
    "\n",
    "def myder(x=0):\n",
    "    return np.exp(-x**2)*(np.pi*np.cos(np.pi*x)-2*x*np.sin(np.pi*x))\n",
    "    \n",
    "x = np.linspace(0,1,100)\n",
    "\n",
    "fprime_FD = diff.for_diff(myfun,x,.1) #forward difference approximation to the derivative\n",
    "fprime_BD = diff.back_diff(myfun,x,.1) #backward difference approximation to the derivative\n",
    "fprime_CD = diff.cent_diff(myfun,x,.1) #centered difference approximation to the derivative"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.figure(0)\n",
    "plt.plot(x,myfun(x))\n",
    "plt.title('$f(x) = e^{-x^2}\\sin(\\pi x)$')\n",
    "\n",
    "fig1 = plt.figure(1, figsize=(15, 6)) # for plots of forward difference approx\n",
    "fig2 = plt.figure(2, figsize=(15, 6)) # for plots of backward difference approx\n",
    "fig3 = plt.figure(3, figsize=(15, 6)) # for plots of centered difference approx\n",
    "\n",
    "axes1_1 = fig1.add_subplot(1, 2, 1) #the first plot in a 1x3 array\n",
    "axes2_1 = fig1.add_subplot(1, 2, 2) #the second plot in a 1x3 array\n",
    "\n",
    "axes1_1.plot(x,myder(x),label='$f^\\prime$')\n",
    "axes1_1.plot(x,fprime_FD,label='FD approx of $f^\\prime$')\n",
    "axes1_1.legend(loc='upper right', fontsize=14)\n",
    "\n",
    "axes2_1.plot(x,myder(x)-fprime_FD)\n",
    "axes2_1.set_title('Error in the approximate derivative')\n",
    "\n",
    "# Omitted similar plots for fprime_BD and fprime_CD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Where does a module file need to go?\n",
    "\n",
    "Say you are trying to `import spam`.\n",
    "\n",
    "When imported, the interpreter searches for spam in locations in the following order:\n",
    "1. A built-in module with that name. \n",
    "2. *spam.py* in a list of directories given by the variable *sys.path*. \n",
    "    1. The directory containing the input script (or the current directory when no file is specified).\n",
    "    2. PYTHONPATH (a list of directory names, syntax as shell variable PATH).\n",
    "    3. The installation-dependent default.\n",
    "\n",
    "## Generalizations of Modules: Packages\n",
    "\n",
    "Packages (i.e., libraries) are modules with a *directory* structure.\n",
    "You can even make packages with subpackages and simply exploit the dot.dot reference to navigate through the package to get to the function you want (e.g. matplotlib.pyplot.plot).  \n",
    "If you want to develop a well-comparmentalized package you can look at online help: https://python-packaging.readthedocs.io/en/latest/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise: Make and use your own module\n",
    "\n",
    "(1) Go to the Home tab in your browser and create a new text file. \n",
    "\n",
    "(2) Copy/paste the `myfun1` and `myfun2` into this file and save the file as `myModule.py`.\n",
    "\n",
    "(3) Create a new Notebook from the Home tab, and in a code cell within that Notebook import your module as `myMod` and execute some of the function calls seen here using `myMod.myfun1` or `myMod.myfun2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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": 0
}