Learning Python 4 - Functions and Generators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Python - Notebook 4 - Functions and Generators\n",
    "\n",
    "A compendium of introductory topics, illustrative examples, best practices, tips and tricks.  \n",
    "\n",
    "Though most of the content here is my own explorations and my own dumb ideas, I have chosen to organize this series of Notebooks roughly based on the organization of Mark Lutz' authoritative (and massive) book _Learning Python._  These notebooks are aligned with the numbered major parts of his book.  This notebook aligns with his chapters covering Python __Functions and Generators.__\n",
    "\n",
    "Please see the accompanying notebooks for complementary and more complex topics.\n",
    "\n",
    "It is considered good form to try to use content from \"Monty Python\" in examples.  As the programming topics get more complex, I believe reaching for \"Monty Python\" examples eventually leads to some obscure or illogical example code.\n",
    "As a naval history buff and a gaming enthusiast, I would love to someday write the world's greatest warship game program in Python.  So, I am reaching into the world of ships and fleets for concepts to use as coding examples.  Warships have many things that directly connect with object oriented concepts.  We can start with the point that warships are designed and constructed in classes. \n",
    "I hope you find this approach useful!\n",
    "## Notebook Structure\n",
    "This notebook is compact enough that I've tried to make every cell independent.  There is a \"root\" is marked as Cell Zero.  It contains a summary of all the IMPORT statements used throughout this notebook.  \n",
    "\n",
    "Python notation sometimes conflicts with Jupyter markdown notation.  (I'm looking at you, dunders!)  When I want to emphasize a Python command, method, parameter, or so forth, I will capitalize in the narrative.\n",
    "\n",
    "## Table of Contents\n",
    "\n",
    "+ [Code Formatting](#CodeFormatting)\n",
    "+ [Scope](#Scope)\n",
    "  +  Scope Best Practices\n",
    "  + Scope in Iteration\n",
    "  + Maker Functions or \"Closures\"\n",
    "  + Special Design Pattern with Lambda for GUI\n",
    "  + Diagnosing Scope"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Major Learnings\n",
    "Explorations have highlighted a few of the most interesting things about functions in Python.\n",
    "- The DEF statement is executable.  Named functions are not available until defined.  Since they are executable, definitions are subject to program control, such as IF statements.\n",
    "- Function definitions create objects, which can be treated as other objects.  Function objects may have arbitrary attributes assigned, which can be used to store data.\n",
    "- LAMBDA creates a function and returns it as a result\n",
    "- GLOBAL declares module-level variables\n",
    "- NONLOCAL declares enclosing (nested?) function variables\n",
    "- Arguments are passed by assignment (object reference)\n",
    "- Arguments are passed by position, unless programmed otherwise\n",
    "- Arguments, return values, and variables are not declared in advance.  (Polymorphism.)\n",
    "\n",
    "## Getting Started\n",
    "Before we get going, let's import everything we need, check a few details, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "#-----------------------------------------------------------------\n",
      "3.5.2 |Anaconda 4.2.0 (64-bit)| (default, Jul  5 2016, 11:41:13) [MSC v.1900 64 bit (AMD64)]\n",
      "3.5.2\n"
     ]
    }
   ],
   "source": [
    "# Base Cell 0 (Zero)\n",
    "# Here is a gathering place for all imports, though the cells below include these individually as needed.\n",
    "\n",
    "import sys\n",
    "import platform\n",
    "from pprint import pprint\n",
    "import numpy\n",
    "import math\n",
    "import scipy\n",
    "\n",
    "# Display Python Version\n",
    "#  I guess we won't be using any 3.6 features today, such as the f-string feature.\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print (sys.version)\n",
    "print (platform.python_version())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Code Formatting\n",
    "<a id=CodeFormatting></a>\n",
    "Here are some reminders on how to format Python code.  Line continuation is important, as it is considered bad form\n",
    "to let a line get long enough to require horizontal scrolling in text editors and these notebooks.\n",
    "https://www.python.org/dev/peps/pep-0008/\n",
    "\n",
    "https://docs.python.org/3/reference/lexical_analysis.html#implicit-line-joining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True!\n"
     ]
    }
   ],
   "source": [
    "# Comment\n",
    "l_string = '''abc\n",
    "                  def'''    #Triple quote captures everything, including LF\n",
    "\n",
    "# Line Continuation with Backslash\n",
    "a = '1' + '2' + '3' + \\\n",
    "    '4' + '5'\n",
    "\n",
    "x = 2     \n",
    "s1 = (x + x**2/2 + x**3/3 +\n",
    "     x**4/4 + x**5/5 +\n",
    "     x**6/6 + x**7/7 +\n",
    "     x**8/8)            \n",
    "\n",
    "# Line Continuation with Open Parentheses #Python allows line continuation within open braces, brackets, parentheses.\n",
    "a = ('1' + '2' + '3' +\n",
    "    '4' + '5')    \n",
    "s2 = (x + x**2/2 + x**3/3 \n",
    "     + x**4/4 + x**5/5 \n",
    "     + x**6/6 + x**7/7 \n",
    "     + x**8/8)     \n",
    "\n",
    "# If Condition Line Continuation with Open Parentheses\n",
    "if (s1 == s2 and s2 >0 and x == 2\n",
    "    and s1 > 0):\n",
    "    print (\"True!\")\n",
    "else:\n",
    "    print (\"False.\")\n",
    "\n",
    "# Assigning multiple variables simultaneously.\n",
    "#    I suppose this makes the code listing slightly shorter, and keeps one from abusing the \"=\" key.\n",
    "#    However, I find this an invitation to scrimp on documentation.  What are all these variables and their values?\n",
    "#    (Okay, I may have exxagerated for effect.)\n",
    "\n",
    "a, b, c, d, e, f, g = 0,1,2,3,4,5,6\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Scope\n",
    "<a id=Scope></a>\n",
    "This demonstrates Python basic scope management.  Scope is about _name_ management, or name spaces.\n",
    "\n",
    "Python uses _lexical scoping._  The scope of a variable is entirely determined by where in the code it is used.\n",
    "\n",
    "A simple rule for scope based upon where a variable is assigned:\n",
    "- Variables assigned within a function definition (DEF) is _local_ to that function\n",
    "- Variables assigned in an enclosing function defintion (outer nested DEF) is _nonlocal_ to inner nested functions.\n",
    "- Variables assigned outside all function definitions is _global_ to the entire file.\n",
    "\n",
    "Functions define a local scope and modules define a global scope, with the following details:\n",
    "- The enclosing module defines a global scope.  There isn't really any universal global scope.  \"Global\" means \"module.\"\n",
    "- Global scope relates to single module only.  There isn't really any universal global scope.  \"Global\" means \"module.\"\n",
    "- Assigned names are local only, unless declared otherwise.\n",
    "  - Assignment makes a variable local, including displacing something named higher up.\n",
    "- All names not assigned locally are assumed specifically to be either local to the enclosing function, global, or built-in. \n",
    "  - Modifying a variable defined higher up changes the global object. \n",
    "- Each function call creates a new local scopee.  (This is how recursion works.)\n",
    "\n",
    "Variable scope follows the LEGB search rule:\n",
    "\n",
    "Local -> Enclosed -> Global -> Build-In\n",
    "\n",
    "This rule is sometimes called the LNGB rule:\n",
    "\n",
    "Local -> Nonlocal -> Global -> Build-In\n",
    "\n",
    "The \"E / N\" part may have multiple search passes, as there may be a hierarchy of nested function definitions. \n",
    "\n",
    "These rules all apply to variable names.  Attribute search for objects will follow an inheritance search pat.\n",
    "\n",
    "http://nbviewer.jupyter.org/github/rasbt/python_reference/blob/master/tutorials/scope_resolution_legb_rule.ipynb\n",
    "\n",
    "https://sebastianraschka.com/notebooks/python-notebooks.html\n",
    "\n",
    "### Other Scopes\n",
    "There are a small number of scopes outside of the LEGB rule.\n",
    "- Comprehension variables have their own local scope.  The variable in a conventional FOR loop is not such a variable.\n",
    "- Exception variables in TRY / EXCEPT structures.\n",
    "- Local variables in CLASS statements.\n",
    "\n",
    "### Scope Best Practices\n",
    "- Global variables should rarely be referenced from within a function, and never change.\n",
    "- Don't re-define built in names, unless you really mean to.\n",
    "\n",
    "http://pychecker.sourceforge.net/\n",
    "\n",
    "### Scope in Iteration\n",
    "Variables used in loops live beyond the life of the loop.  This is sometimes called scope leakage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i in for loop:  0\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  1\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  2\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  3\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  4\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "4 2\n"
     ]
    }
   ],
   "source": [
    "# Scope in iteration.  Note that loop iteration variables retain values after loop completes.\n",
    "i = 3   # Variable is set before loop\n",
    "for i in range (5):                           # Variable is used within loop\n",
    "    print (\"i in for loop: \", i)\n",
    "    for j in range (3):                       # Another variable is used within loop\n",
    "        print (\"j in inner for loop: \", j)\n",
    "        \n",
    "print (\"\\n#\" + 65*'-')\n",
    "# Note variable values remain after loop\n",
    "print (i, j)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Maker Functions or \"Closures\"\n",
    "A maker function uses logic to create a function object, which can then be used by following code.\n",
    "Maker functions are nested functions.\n",
    "\n",
    "\"Action\" functions created by maker functions have a kind of \"memory\" about their local scope.  \n",
    "This seems like a \"light weight\" class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n",
      "27\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Define the maker function, which creates a nested function\n",
    "def math_maker(N):\n",
    "    def math_action(x):\n",
    "        return x**N\n",
    "    return math_action\n",
    "\n",
    "i = 2\n",
    "f = math_maker(i)\n",
    "\n",
    "i = 3\n",
    "g = math_maker(i)\n",
    "\n",
    "print (f(3))    # f will return something squared\n",
    "print (g(3))    # g will return something cubed\n",
    "\n",
    "# Accomplish the same thing with LAMBDA function\n",
    "def maths_maker(N):\n",
    "    return lambda X: X**N\n",
    "\n",
    "i = 2    \n",
    "h = maths_maker(i)\n",
    "\n",
    "print (h(3))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Special Scope Design Pattern with Lambda for GUI\n",
    "The following is a design pattern Lutz says is found in GUI management code.  It hightlights the important of \n",
    "nested functions.  (If you come from a background of ancient functional programming, being able to call a data unit\n",
    "as a function is pretty exiciting!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[<function make_actions.<locals>.<lambda> at 0x0000000004B98158>,\n",
      " <function make_actions.<locals>.<lambda> at 0x0000000004DD80D0>,\n",
      " <function make_actions.<locals>.<lambda> at 0x0000000004DD8E18>,\n",
      " <function make_actions.<locals>.<lambda> at 0x0000000004DD8B70>,\n",
      " <function make_actions.<locals>.<lambda> at 0x0000000004DD89D8>]\n",
      "<function make_actions.<locals>.<lambda> at 0x0000000004B98158>\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "16\n",
      "<function make_actions2.<locals>.<lambda> at 0x0000000004DD8268>\n",
      "0\n",
      "1\n",
      "4\n",
      "9\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "# This first chunk of code demonstrates the problem.\n",
    "# Both examples below seek to create a list of functions that each remember the variable \"i\" from the enclosing scope.\n",
    "#    This function builds a list, where every element of the list is a function itself.  \n",
    "#     We use lambda to define the function \"embedded\" in the list.  No need to name a function that is going to be nameless.\n",
    "#     The unnamed function squares its operand\n",
    "def make_actions():\n",
    "    actions_list = []\n",
    "    for i in range(5):\n",
    "        actions_list.append(lambda x: i ** x )\n",
    "    return actions_list\n",
    "\n",
    "acts_list = make_actions()\n",
    "pprint (acts_list)\n",
    "print (acts_list[0])\n",
    "print (acts_list[0](2))  # We always get same result because \"i\" above always remembers last value\n",
    "print (acts_list[1](2))\n",
    "print (acts_list[2](2))\n",
    "print (acts_list[3](2))\n",
    "print (acts_list[4](2))\n",
    "\n",
    "\n",
    "# This second chunk of code demonstrates a common dsign pattern for the solution.\n",
    "def make_actions2():\n",
    "    actions_list = []\n",
    "    for i in range(5):\n",
    "        actions_list.append(lambda x, i=i: i ** x )\n",
    "    return actions_list\n",
    "\n",
    "acts_list = make_actions2()\n",
    "print (acts_list[0])\n",
    "print (acts_list[0](2))  # This one works because a local \"i\" is created \n",
    "print (acts_list[1](2))\n",
    "print (acts_list[2](2))\n",
    "print (acts_list[3](2))\n",
    "print (acts_list[4](2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nested Functions with Local and NonLocal Variables\n",
    "Our Python development team leader says that he will kick out of the source code repository anybody he finds using nested functions.  When pressed, he admitted they might be used in the case of something extraordinary that couldn't possibly be done any other way.  However, he promised testing and maintenanc problems, and developing this section has borne that out.\n",
    "\n",
    "That said, Lutz has led me here, so let's thrash this out.  Here is what I am finding by wrestling with this topic.\n",
    "\n",
    "Python Philosophy:  Every function has its own name space.  Data should be passed to functions as arguments.  If there are extraordinary reasons a function should \"know\" or \"see\" variables from higher in the hiearchy, we have methods with difficult and dangerous repurcussions.\n",
    "\n",
    "In nested functions, each \"deep\" function can \"read\" the value of variables defined in higher level functions.\n",
    "However, a \"deep\" function cannot change the value of a variable defined higher unless it is declared NONLOCAL.\n",
    "\n",
    "My summary of the rules discovered for these controls:\n",
    "1. Module-level variables may be read by nested functions.\n",
    "2. Local function variables may re-use Module-level variable names, but will only have local function scope.\n",
    "3. Local function may change module-level variables, but only by using GLOBAL statement.\n",
    "4. Functions cannot change the scope of a variable in execution.  (Python acts like conventional compiler here.)\n",
    "5. Local function may create and populate new module-level variables using GLOBAL statement.\n",
    "6. Function-level variables may be read by deeper nested functions.\n",
    "7. Local function variables may re-use higher-nested function variable names, but will only have local function scope.\n",
    "8. >Local function may change higher-nested function variables, but only by using NONLOCAL statement.\n",
    "9. >Functions cannot change the scope of a variable in execution.  (Python acts like conventional compiler here.)\n",
    "10. >Local function may NOT create and populate new higher-nested function-level variables using NONLOCAL.\n",
    "\n",
    "Rules 4 and 8 are really the same rule, but constrain similar behavior by different scope structures.\n",
    "\n",
    "Rule 10 is the opposite of its corrolary Rule 5.\n",
    "\n",
    "These examples have way more code than needed to prove the bullet points, but leave something to work with for more complex testing later.\n",
    "Some tests for our code to explore:\n",
    "- What happens when deep functions change global variables?  Error, or a new temporary local with same name?\n",
    "- What happens when deep functions change higher nonlocal variables?  Error, or a new temporarly local variable?\n",
    "- Do re-used variable names need to be declared early in the function?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 1:  Module-level variables may be read by nested functions.\n",
      "RULE 6:  Function-level variables may be read by deeper nested functions.\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From low_Func, after variable changes:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Low return is  5\n",
      "From med_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Medium return is  50\n",
      "From high_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "High return is  500\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n"
     ]
    }
   ],
   "source": [
    "# Rule 1:  Module-level variables may be read by nested functions.\n",
    "# Rule 1:  Module-level variables may be read by nested functions.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "#   We're changing values here, but not declaring any scope.\n",
    "print ('RULE 1:  Module-level variables may be read by nested functions.')\n",
    "print ('RULE 6:  Function-level variables may be read by deeper nested functions.\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "\n",
    "            # Changes go here\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 2:  Local variables with same name may re-use Module-level variable names...\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  25\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From low_Func, after variable changes:\n",
      "m1 is  25\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Low return is  5\n",
      "From med_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Medium return is  50\n",
      "From high_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "High return is  500\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n"
     ]
    }
   ],
   "source": [
    "# Rule 2:  Local function variables may re-use Module-level variable names, but will only have local function scope.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "#   We're changing values here, but not declaring any scope.\n",
    "print ('RULE 2:  Local function variables may re-use Module-level variable names, but...\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            m1 = 25  # <<<< Module variable name is re-used.  This must be done before useing the local variable.\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "\n",
    "            # m1 = 25     # This doesn't over-write the value of this variable, only creates a new one at this low level.\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 3:  gloobal Local function variables may re-use Module-level variable names, but...\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From low_Func, after variable changes:\n",
      "m1 is  25\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Low return is  5\n",
      "From med_Func, after calling functions:\n",
      "m1 is  25\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Medium return is  50\n",
      "From high_Func, after calling functions:\n",
      "m1 is  25\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "High return is  500\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, after calling functions:\n",
      "m1 is  25\n",
      "m2 is  2000\n",
      "m3 is  3000\n"
     ]
    }
   ],
   "source": [
    "# Rule 3:  Local function may change module-level variables, but only by using GLOBAL statement.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "\n",
    "print ('RULE 3:  Local function may change module-level variables, but only by using GLOBAL statement.\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            global m1 # <<<< Make module-level variable available in local scope  \n",
    "\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            \n",
    "            m1 = 25  # <<<< Module variable value is changed.\n",
    "\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 4:  Functions cannot change the scope of a variable in execution.\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'm1' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-7138b8af42c7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     68\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm2 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm3 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 70\u001b[0;31m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhigh_Func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     71\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'High return is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     72\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"\\n#\"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m65\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;34m'-'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-7138b8af42c7>\u001b[0m in \u001b[0;36mhigh_Func\u001b[0;34m()\u001b[0m\n\u001b[1;32m     52\u001b[0m         \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B100 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     53\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;36m50\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 54\u001b[0;31m     \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmed_Func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     55\u001b[0m     \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Medium return is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     56\u001b[0m     \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'From high_Func, after calling functions:'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-7138b8af42c7>\u001b[0m in \u001b[0;36mmed_Func\u001b[0;34m()\u001b[0m\n\u001b[1;32m     41\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B100 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     42\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 43\u001b[0;31m         \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlow_Func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     44\u001b[0m         \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Low return is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     45\u001b[0m         \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'From med_Func, after calling functions:'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-14-7138b8af42c7>\u001b[0m in \u001b[0;36mlow_Func\u001b[0;34m()\u001b[0m\n\u001b[1;32m     18\u001b[0m             \u001b[0mB1\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'= From low_Func, before doing anything:'\u001b[0m\u001b[1;33m)\u001b[0m   \u001b[1;31m# We can read the variables from the higher functions.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm1 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm1\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# <<<< Program blows up here because Python has looked ahead and seen name re-use coming.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm2 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm3 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'm1' referenced before assignment"
     ]
    }
   ],
   "source": [
    "# Rule 4:  Functions cannot change the scope of a variable in execution.\n",
    "#    This is where Python stops acting like an interpreter and starts acting like a compiler.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "#   We're changing values here, but not declaring any scope.  Same problem can be generated even when declaring scope.\n",
    "print ('RULE 4:  Functions cannot change the scope of a variable in execution.\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1) # <<<< Program blows up here because Python has looked ahead and seen name re-use coming.\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "\n",
    "            m1 = 25     # This attempts to re-use a variable name after it has already been used in different scope.\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 5:  Local function may create and populate new module-level variables using GLOBAL statement.\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From low_Func, after variable changes:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "m4 is  4400\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Low return is  5\n",
      "From med_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "m4 is  4500\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "Medium return is  50\n",
      "From high_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "m4 is  4400\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "High return is  500\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "m4 is  4400\n"
     ]
    }
   ],
   "source": [
    "# Rule 5:  Local function may create and populate new module-level variables using GLOBAL statement.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "\n",
    "print ('RULE 5:  Local function may create and populate new module-level variables using GLOBAL statement.\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            global m4 # <<<< Make new module-level variable  \n",
    "\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            \n",
    "            m4 = 4400  # <<<< Module variable value is changed.\n",
    "\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('m4 is ', m4)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        m4 = 4500  # <<<< Note that higher-level function can change new global variable without defining scope.\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('m4 is ', m4)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('m4 is ', m4)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "print ('m4 is ', m4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 7:  Local function variables may re-use higher-nested function variable names, but...\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  35\n",
      "A100 is  100\n",
      "B100 is  30\n",
      "From low_Func, after variable changes:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  35\n",
      "A100 is  100\n",
      "B100 is  30\n",
      "Low return is  5\n",
      "From med_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  30\n",
      "Medium return is  50\n",
      "From high_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "High return is  500\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n"
     ]
    }
   ],
   "source": [
    "# Rule 7:  Local function variables may re-use higher-nested function variable names, but will only have local function scope.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "#   We're changing values here, but not declaring any scope.\n",
    "print ('RULE 7:  Local function variables may re-use higher-nested function variable names, but...\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B100 = 30  <<<< Function variable name is re-used.  This must be done before using the local variable.\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            B10 = 35  # <<<< Function variable name is re-used.  This must be done before using the local variable.\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "\n",
    "            # m1 = 25     # This doesn't over-write the value of this variable, only creates a new one at this low level.\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 9:  Local function may change higher-nested function variables, but only by using NONLOCAL statement.\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From low_Func, after variable changes:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  225\n",
      "Low return is  5\n",
      "From med_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A10 is  10\n",
      "B10 is  20\n",
      "A100 is  100\n",
      "B100 is  225\n",
      "Medium return is  50\n",
      "From high_Func, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A100 is  100\n",
      "B100 is  225\n",
      "High return is  500\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, after calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n"
     ]
    }
   ],
   "source": [
    "# Rule 8:  Local function may change higher-nested function variables, but only by using NONLOCAL statement.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "\n",
    "print ('RULE 8:  Local function may change higher-nested function variables, but only by using NONLOCAL statement.\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            nonlocal B100 # <<<< Make module-level variable available in local scope  \n",
    "\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            \n",
    "            B100 = 225  # <<<< Module variable value is changed.\n",
    "\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        # B100 = 325  # <<<< NONLOCAL claim from lower level doesn't apply at this level of nesting!\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 9:  Functions cannot change the scope of a variable in execution.\n",
      "#-----------------------------------------------------------------\n",
      "===== From Module, before calling functions:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "= From low_Func, before doing anything:\n",
      "m1 is  1000\n",
      "m2 is  2000\n",
      "m3 is  3000\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n"
     ]
    },
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'B10' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-88ac03c3fd28>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm2 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     70\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'm3 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mm3\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 71\u001b[0;31m \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mhigh_Func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     72\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'High return is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     73\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"\\n#\"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m65\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;34m'-'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-28-88ac03c3fd28>\u001b[0m in \u001b[0;36mhigh_Func\u001b[0;34m()\u001b[0m\n\u001b[1;32m     53\u001b[0m         \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B100 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     54\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[1;36m50\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 55\u001b[0;31m     \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mmed_Func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     56\u001b[0m     \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Medium return is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     57\u001b[0m     \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'From high_Func, after calling functions:'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-28-88ac03c3fd28>\u001b[0m in \u001b[0;36mmed_Func\u001b[0;34m()\u001b[0m\n\u001b[1;32m     42\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B100 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     43\u001b[0m             \u001b[1;32mreturn\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 44\u001b[0;31m         \u001b[0mg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mlow_Func\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     45\u001b[0m         \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'Low return is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mg\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     46\u001b[0m         \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'From med_Func, after calling functions:'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-28-88ac03c3fd28>\u001b[0m in \u001b[0;36mlow_Func\u001b[0;34m()\u001b[0m\n\u001b[1;32m     25\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B1 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB1\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     26\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'A10 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mA10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 27\u001b[0;31m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B10 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB10\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# <<<< Program blows up here because Python has looked ahead and seen name re-use coming.\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     28\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'A100 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mA100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     29\u001b[0m             \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m'B100 is '\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mB100\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'B10' referenced before assignment"
     ]
    }
   ],
   "source": [
    "# Rule 9:  Functions cannot change the scope of a variable in execution.\n",
    "#    Same text as Rule 4, but applicable at other scope levels.\n",
    "#    This is where Python stops acting like an interpreter and starts acting like a compiler.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "#   We're changing values here, but not declaring any scope.  Same problem can be generated even when declaring scope.\n",
    "print ('RULE 9:  Functions cannot change the scope of a variable in execution.\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1) # <<<< Program blows up here because Python has looked ahead and seen name re-use coming.\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10) # <<<< Program blows up here because Python has looked ahead and seen name re-use coming.\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "\n",
    "            B10 = 25     # This attempts to re-use a variable name after it has already been used in different scope.\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RULE 10:  Local function may create and populate new higher-nested function-level variables....\n",
      "#-----------------------------------------------------------------\n"
     ]
    },
    {
     "ename": "SyntaxError",
     "evalue": "no binding for nonlocal 'B20' found (<ipython-input-29-61c0651d74f8>, line 18)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-29-61c0651d74f8>\"\u001b[0;36m, line \u001b[0;32m18\u001b[0m\n\u001b[0;31m    nonlocal B20 # <<<< Make new module-level variable\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m no binding for nonlocal 'B20' found\n"
     ]
    }
   ],
   "source": [
    "# Rule 10:  Local function may NOT create and populate new higher-nested function-level variables using NONLOCAL statement.\n",
    "#  Here is a structure of 3 nested functions.  Changing a variable from medium function makes it local only to lowest.\n",
    "\n",
    "print ('RULE 10:  Local function may NOT create and populate new higher-nested function-level variables....\\n#' + 65*'-')\n",
    "# Set module-level variables\n",
    "m1 = 1000\n",
    "m2 = 2000\n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            nonlocal B20 # <<<< Make new module-level variable  \n",
    "\n",
    "            print ('= From low_Func, before doing anything:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            \n",
    "            B20 = 80  # <<<< Module variable value is changed.\n",
    "\n",
    "            \n",
    "            print ('From low_Func, after variable changes:')   # We can read the variables from the higher functions.\n",
    "            print ('m1 is ', m1)\n",
    "            print ('m2 is ', m2)\n",
    "            print ('m3 is ', m3)\n",
    "            print ('m4 is ', m4)\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('B20 is ', B20)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        m4 = 4500  # <<<< Note that higher-level function can change new global variable without defining scope.\n",
    "        print ('Low return is ', g)\n",
    "        print ('From med_Func, after calling functions:')\n",
    "        print ('m1 is ', m1)\n",
    "        print ('m2 is ', m2)\n",
    "        print ('m3 is ', m3)\n",
    "        print ('m4 is ', m4)\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('Medium return is ', g)\n",
    "    print ('From high_Func, after calling functions:')\n",
    "    print ('m1 is ', m1)\n",
    "    print ('m2 is ', m2)\n",
    "    print ('m3 is ', m3)\n",
    "    print ('m4 is ', m4)\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "m3 = 3000   # Module level variable defined after function defintions but before calls.\n",
    "\n",
    "print ('===== From Module, before calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "g = high_Func()\n",
    "print ('High return is ', g)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "print ('===== From Module, after calling functions:')\n",
    "print ('m1 is ', m1)\n",
    "print ('m2 is ', m2)\n",
    "print ('m3 is ', m3)\n",
    "print ('m4 is ', m4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "From low_Func:\n",
      "A1 is  1\n",
      "B1 is  2\n",
      "A10 is  10\n",
      "B10 is  25\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From med_Func:\n",
      "A10 is  10\n",
      "B10 is  25\n",
      "A100 is  100\n",
      "B100 is  200\n",
      "From high_Func:\n",
      "A100 is  100\n",
      "B100 is  200\n"
     ]
    }
   ],
   "source": [
    "#  Here is same structure structure of 3 nested functions.  \n",
    "def high_Func():\n",
    "    A100 = 100\n",
    "    B100 = 200\n",
    "    def med_Func():\n",
    "        A10 = 10\n",
    "        B10 = 20\n",
    "        B1 = 3\n",
    "        def low_Func():\n",
    "            A1 = 1\n",
    "            B1 = 2\n",
    "            nonlocal B10\n",
    "            B10 = 25     # This does over-write the value of this variable, because is has been made NONLOCAL.\n",
    "            print ('From low_Func:')   # We can read the variables from the higher functions.\n",
    "            print ('A1 is ', A1)\n",
    "            print ('B1 is ', B1)\n",
    "            print ('A10 is ', A10)\n",
    "            print ('B10 is ', B10)\n",
    "            print ('A100 is ', A100)\n",
    "            print ('B100 is ', B100)\n",
    "            return 5\n",
    "        g = low_Func()\n",
    "        print ('From med_Func:')\n",
    "        print ('A10 is ', A10)\n",
    "        print ('B10 is ', B10)\n",
    "        print ('A100 is ', A100)\n",
    "        print ('B100 is ', B100)\n",
    "        return 50\n",
    "    g = med_Func()\n",
    "    print ('From high_Func:')\n",
    "    print ('A100 is ', A100)\n",
    "    print ('B100 is ', B100)\n",
    "    return 500\n",
    "\n",
    "g = high_Func()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Diagnosing Scope\n",
    "Python is a dynamic language, unlike many common languages that are historically static.  Scope can change on the fly as a program as run.  The GLOBALS and LOCAL methods can be used to diagnose scope changes and surprises.\n",
    "\n",
    "GLOBALS returns a dictionary of the current global symbols table (global variables and their values.)  It can be a mess to look at, but can be modified during run time!\n",
    "\n",
    "LOCALS returns a dictionary of the current local symbols table (local variables and their values.)  It can be a mess to look at, but can be modified during run time!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "link in for loop:  0\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "link in for loop:  1\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "link in for loop:  2\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "link in for loop:  3\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "link in for loop:  4\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "4 2\n",
      "True\n",
      "False\n",
      "True\n",
      "4\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "4 2\n",
      "True\n",
      "False\n",
      "True\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Testing variables in scope.  Note that this test probably doesn't work the way you think it does!\n",
    "i = 3\n",
    "for link in range (5):\n",
    "    print (\"link in for loop: \", link)\n",
    "    for j in range (3):\n",
    "        print (\"j in inner for loop: \", j)\n",
    "        \n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Note variable values remain after loop\n",
    "print (link, j)\n",
    "print ('link' in globals())\n",
    "print ('ink' in globals())  # This is not a GREP like operation\n",
    "print ('j' in globals())\n",
    "print (globals()['link'])\n",
    "# pprint (globals())        # This generates a ton of output\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Note variable values remain after loop\n",
    "print (link, j)\n",
    "print ('link' in locals())\n",
    "print ('ink' in locals())   # This is not a GREP like operation\n",
    "print ('j' in locals())\n",
    "print (locals()['link'])   # Variabble in GLOBALS and LOCALS, but what is its value?\n",
    "# pprint (locals())        # This generates a ton of output\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "#-----------------------------------------------------------------\n",
      "4 2\n",
      "True\n",
      "True\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "7 2\n",
      "7\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "# Changing variables directly within the name space.  \n",
    "i = 3\n",
    "for link in range (5):\n",
    "    # print (\"link in for loop: \", link)\n",
    "    for j in range (3):\n",
    "        pass\n",
    "        # print (\"j in inner for loop: \", j)\n",
    "        \n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Note variable values remain after loop\n",
    "print (link, j)\n",
    "print ('link' in globals())\n",
    "print ('link' in locals())\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "globals()['link'] = 7\n",
    "print (link, j)    #Note change in value!\n",
    "print (globals()['link'])\n",
    "print (locals()['link'])   # Variabble in GLOBALS and LOCALS, but what is its value?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Accessing Variables in Modules\n",
    "Variables in modules need to be accessed via prefixes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pi from the math module is:  3.141592653589793\n",
      "Pi from the numpy module is:  3.141592653589793\n",
      "Pi from the scipy module is:  3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "import numpy\n",
    "import math\n",
    "import scipy\n",
    "\n",
    "print('Pi from the math module is: ', math.pi)\n",
    "print('Pi from the numpy module is: ', numpy.pi)\n",
    "print('Pi from the scipy module is: ', scipy.pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "i in for loop:  0\n",
      "True\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  1\n",
      "True\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  2\n",
      "True\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  3\n",
      "True\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "i in for loop:  4\n",
      "True\n",
      "j in inner for loop:  0\n",
      "j in inner for loop:  1\n",
      "j in inner for loop:  2\n",
      "4 2\n",
      "True\n",
      "True\n",
      "k in function loop:  0\n",
      "k in function loop:  1\n",
      "k in function loop:  2\n",
      "k in function loop:  3\n"
     ]
    }
   ],
   "source": [
    "# Scope in iteration.  Note that loop iteration variables retain values after loop completes.\n",
    "i = 3\n",
    "for i in range (5):\n",
    "    print (\"i in for loop: \", i)\n",
    "    print ('i' in locals())\n",
    "    for j in range (3):\n",
    "        print (\"j in inner for loop: \", j)\n",
    "print (i, j)\n",
    "print ('i' in globals())\n",
    "print ('i' in locals())\n",
    "def irritate():\n",
    "    for k in range (i):\n",
    "        print (\"k in function loop: \", k)\n",
    "    return\n",
    "l = irritate()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "loc in foo(): True\n",
      "loc in global: False\n",
      "glob in global: True\n",
      "\n",
      "#-----------------------------------------------------------------\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'i' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-3552049353d6>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     13\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"\\n#\"\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m65\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;34m'-'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 15\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mi\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     16\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mtype\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     17\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mglobals\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'i' is not defined"
     ]
    }
   ],
   "source": [
    "#print(globals()) # prints global namespace\n",
    "#print(locals()) # prints local namespace\n",
    "\n",
    "glob = 1\n",
    "\n",
    "def foo():\n",
    "    loc = 5\n",
    "    print('loc in foo():', 'loc' in locals())\n",
    "\n",
    "foo()\n",
    "print('loc in global:', 'loc' in globals())    \n",
    "print('glob in global:', 'foo' in globals())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (i)\n",
    "print (type(globals()))\n",
    "print (globals())\n",
    "print (type(locals()))\n",
    "print (\"\")\n",
    "print (locals())\n",
    "print (i in globals())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "<a id=Functions></a>\n",
    "One important feature of Python functions is the ability to pass a list of arguments or a list of named arguments.  The Python docuemntation syntax for this is \"\\*args\" and \"\\**kwargs.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "<class 'tuple'>\n",
      "(4, '5')\n",
      "1 2 3\n",
      "<class 'dict'>\n",
      "{'continent': 'North America', 'city': 'Austin', 'state': 'Texas', 'county': 'Travis'}\n"
     ]
    }
   ],
   "source": [
    "def demo_func1(i, j, k, *args):\n",
    "    print (i, j, k)\n",
    "    print (type(args))             # Note that args is a tuple of arguments\n",
    "    print (args)\n",
    "    \n",
    "def demo_func2(i, j, k, **kwargs):\n",
    "    print (i, j, k)\n",
    "    print (type(kwargs))           # Note that kwargs is a dictionary of key word arguments\n",
    "    print (kwargs)\n",
    "    \n",
    "i = demo_func1(1, 2, 3, 4, \"5\")\n",
    "\n",
    "i = demo_func2(1, 2, 3, city=\"Austin\", county=\"Travis\", state=\"Texas\", continent=\"North America\")\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Iterators, Iterables, and Generators\n",
    "<a id=Iterators></a>\n",
    "Iteration means taking each item of something, one after the other.  This means some kind of collection with some kind of order (sequence.)  Iteration implies looping, whether implicit or explicit."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterables\n",
    "Iterables are sequences where it is possible to visit each element of the sequence, and perform some operation on that element (and move on.)\n",
    "\n",
    "Official Definition:\n",
    "\n",
    "An iterable is an object capable of returning its members one at a time. Examples of iterables include all sequence types (such as list, str, and tuple) and some non-sequence types like dict, file objects, and objects of any classes you define with an __iter__() or __getitem__() method. Iterables can be used in a for loop and in many other places where a sequence is needed (zip(), map(), ...). When an iterable object is passed as an argument to the built-in function iter(), it returns an iterator for the object. This iterator is good for one pass over the set of values. When using iterables, it is usually not necessary to call iter() or deal with iterator objects yourself. The for statement does that automatically for you, creating a temporary unnamed variable to hold the iterator for the duration of the loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators\n",
    "Iterables are sequences where it is possible to visit each element of the sequence, and perform some operation on that element (and move on.)\n",
    "\n",
    "Official Definition:\n",
    "\n",
    "An object representing a stream of data. Repeated calls to the iterator’s __next__() method (or passing it to the built-in function next()) return successive items in the stream. When no more data are available a StopIteration exception is raised instead. At this point, the iterator object is exhausted and any further calls to its __next__() method just raise StopIteration again. Iterators are required to have an __iter__() method that returns the iterator object itself so every iterator is also iterable and may be used in most places where other iterables are accepted. One notable exception is code which attempts multiple iteration passes. A container object (such as a list) produces a fresh new iterator each time you pass it to the iter() function or use it in a for loop. Attempting this with an iterator will just return the same exhausted iterator object used in the previous iteration pass, making it appear like an empty container."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generators\n",
    "There are two types of generators: \n",
    "- Named generator functions\n",
    "- Nameless generator expressions\n",
    "\n",
    "Generator functions are a type of function that can be called repeatedly/iterably and performs a YIELD instead of a return.  Generator expressions are single-line expressions that are similar to list expressions.  In fact, list comprehensions can be thought of as generator expressions wrapped in a list constructor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2470"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Simple nameless generator used in place of a function parameter\n",
    "sum(i**2 for i in range(20))   # Generates sum of squares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The L Word\n",
    "<a id=Lambdas></a>\n",
    "Lambda, map(), filter(), and reduce() are functional programming capabilites and structures.  They have been reported to be added to Python at the request of LISP fans.\n",
    "\n",
    "\n",
    "### Lambda Functions\n",
    "\n",
    "The lambda operator provides a nameless \"throw away\" function which is usually embeddeed in larger expressions and operations.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Lambda syntax:\n",
    "#  function_name = lambda parameters: expresssion\n",
    "f = lambda x, y : x * y\n",
    "print (f(2,4))\n",
    "\n",
    "\n",
    "# Lambda expression can include conditional structures\n",
    "f = lambda a,b: a if (a > b) else b\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map Function\n",
    "The map function applies a function to every element in a sequence (list, iterable.)  If multiple iterables are provided, they are operated upon in parallel.  Multiple functions can also be supplied to the mapping process.\n",
    "\n",
    "In Python 3, the map() function produces a map object, which can be directly iterated.  If an actual list object is needed, the list() function should be used to build the list from the map objects.\n",
    "\n",
    "The equivalent of a map() operation can probably be built with list comprehensions and can *always* be built with loops.  The use of map() may provide shorter, clearer code.  However, where complex use of map() is required, building the equivalent larger looping code block will probably run faster (and may be easier to understand, update,  and correct.)\n",
    "\n",
    "https://www.dotnetperls.com/map-python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 15.5, 22.2, 38.8, 43.3)\n",
      "<map object at 0x0000000004CE9278>\n",
      "<map object at 0x0000000004CE95F8>\n",
      "[32.0, 59.900000000000006, 71.96000000000001, 101.84, 109.94]\n",
      "[0.0, 15.500000000000004, 22.200000000000006, 38.800000000000004, 43.3]\n",
      "[32.0, 59.900000000000006, 71.96000000000001, 101.84, 109.94]\n",
      "[-17.77777777777778, -9.166666666666668, -5.444444444444445, 3.7777777777777763, 6.277777777777777]\n",
      "[18, 14, 14, 14]\n",
      "[17, 10, 19, 23]\n",
      "[19, 18, 9, 5]\n",
      "[0, 0]\n",
      "[1, 2]\n",
      "[4, 4]\n",
      "[9, 6]\n",
      "[16, 8]\n"
     ]
    }
   ],
   "source": [
    "# Map syntax:\n",
    "#  result_seq = map(function, input_sequence)\n",
    "# Examples with temperature conversions.\n",
    "def fahrenheit(T):\n",
    "    return ((float(9)/5)*T + 32)\n",
    "def celsius(T):\n",
    "    return (float(5)/9)*(T-32)\n",
    "temps = (0, 15.5, 22.2, 38.8, 43.3)\n",
    "print (temps)\n",
    "\n",
    "F = map(fahrenheit, temps)\n",
    "C = map(celsius, F)\n",
    "print (F)                    # In Python 3, map() produces a map object, which can be directly iterated.\n",
    "print (C)\n",
    "\n",
    "F = list(map(fahrenheit, temps))\n",
    "C = list(map(celsius, F))   # In Python 3, it is necessary to build a list from the object.\n",
    "print (F)\n",
    "print (C)\n",
    "\n",
    "F = list(map(lambda x: (float(9)/5)*x + 32, temps))\n",
    "print (F)\n",
    "C = list(map(lambda x: (float(5)/9)*(x-32), temps))\n",
    "print (C)\n",
    "\n",
    "# map() can accept multiple iterables as input.\n",
    "a = [1,2,3,4]\n",
    "b = [17,12,11,10]\n",
    "c = [-1,-4,5,9]\n",
    "print (list(map(lambda x,y:x+y, a,b)))\n",
    "print (list(map(lambda x,y,z:x+y+z, a,b,c)))\n",
    "print (list(map(lambda x,y,z:x+y-z, a,b,c)))\n",
    "\n",
    "# map() can accept multiple function definitions as input.\n",
    "def multiply(x):\n",
    "    return (x*x)\n",
    "def add(x):\n",
    "    return (x+x)\n",
    "\n",
    "funcs = [multiply, add]\n",
    "for i in range(5):\n",
    "    value = list(map(lambda x: x(i), funcs))\n",
    "    print(value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter Function\n",
    "The filter() function provides a way to filter a list by some criteria and remove elements based upon the criteria match.\n",
    "\n",
    "In Python 3, the filter() function produces a filter object, which can be directly iterated. If an actual list object is needed, the list() function should be used to build the list from the filter objects.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<filter object at 0x0000000004CE3B38>\n",
      "[1, 1, 3, 5, 13, 21, 55]\n",
      "[0, 2, 8, 34]\n"
     ]
    }
   ],
   "source": [
    "# Filter Syntax\n",
    "# result_sequence = filter(boolean_function, input_sequence)\n",
    "#   Example sorting Fibonacci members\n",
    "fibonacci_seq = [0,1,1,2,3,5,8,13,21,34,55]\n",
    "result = filter(lambda x: x % 2, fibonacci_seq)\n",
    "print (result)\n",
    "print(list(result))\n",
    "result = filter(lambda x: x % 2 == 0, fibonacci_seq)\n",
    "print (list(result))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce Function\n",
    "\n",
    "The reduce() function repetitively applies a function to a sequence until the sequence is reduced to a single result.  The simplest example would be a summation function that sums all the elements and arrives at a final total.\n",
    "\n",
    "reduce() is not a built-in function, and must be imported for use.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "102\n"
     ]
    }
   ],
   "source": [
    "# Reduce Syntax:\n",
    "# single_result = reduce(function, input_sequence) \n",
    "from functools import reduce\n",
    "print (reduce((lambda x, y: x * y), [1, 2, 3, 4]))\n",
    "\n",
    "# Note conditional structure in lambda expression\n",
    "f = lambda a,b: a if (a > b) else b\n",
    "print (reduce(f, [47,11,42,102,13]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Printing in Python 3\n",
    "<a id=Printing></a>\n",
    "This demonstrates basic Python results string handling capabilities.  Please see _Python Intermediate Topics Student Notebook_ for a deeper exploration of the FORMAT method.\n",
    "\n",
    "### Printing Results and Variables with Formatting\n",
    "Please see _Python Intermediate Topics Student Notebook_ for a deeper exploration of the FORMAT method.\n",
    "https://docs.python.org/3/library/functions.html?highlight=print#print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta']\n",
      "['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']\n",
      "<class 'list'>\n",
      "Number is:  25\n",
      "Name is:  Alex\n",
      "Len: 6\n",
      "Min: Atlanta\n",
      "My number is: 25, and my name is: Alex\n",
      "My number is: 25, and my name is: Alex\n",
      "My number is: 25. 'My name is: Alex.  My father's name is Alex.\n"
     ]
    }
   ],
   "source": [
    "early_list = list() #Create empty list\n",
    "early_list = [\"Houston\", \"Austin\", \"Huston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\"]\n",
    "\n",
    "\n",
    "num = 25\n",
    "name = 'Alex'\n",
    "\n",
    "print ( early_list)\n",
    "print ( dir(early_list))\n",
    "print ( type(early_list))\n",
    "\n",
    "# Perl or script-style printing\n",
    "print ('Number is: ', num)\n",
    "print ('Name is: ', name)\n",
    "\n",
    "# Python string format method printing\n",
    "print ( 'Len: {}'.format(len(early_list))) # Len = element count\n",
    "print ( 'Min: {}'.format(min(early_list))) # Min = alphabettically lowest\n",
    "\n",
    "print('My number is: {}, and my name is: {}'.format(num,name))\n",
    "print('My number is: {one}, and my name is: {two}'.format(one=num,two=name)) # Prevents sequencing issues\n",
    "\n",
    "print('My number is: {one}.'.format(one=num), sep=\"&\", end=\" \") # The separator characters can be changed.\n",
    "print(\"'My name is: {two}.  My father's name is {two}.\".format(two=name)) # Allows variable to be printed multiple times.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "   ### Perl-Style Printing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number is:  25\n",
      "Name is:  Alex\n",
      "Last Name: Rube First Name:Goldberg\n"
     ]
    }
   ],
   "source": [
    "num = 25\n",
    "name = 'Alex'\n",
    "print ('Number is: ', num)\n",
    "print ('Name is: ', name)\n",
    "\n",
    "a = \"Rube\"\n",
    "b = \"Goldberg\"\n",
    "print (\"Last Name: \"+ a +\" First Name:\"+ b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### My Best Practices for Formatting Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#=================================================================\n",
      "#-----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "bar_string = \"#\" + 65*'='   # Multipled string can be multiple character\n",
    "line_string = \"#\" + 65*'-' # Multipled string can be multiple character\n",
    "print (\"#\" + 65*'=')\n",
    "print (\"#\" + 65*'-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exception Handling\n",
    "<a id=Exceptions></a>\n",
    "This demonstrates the use of exception handling for standard exceptions.  (No custom or user-defined exceptions.) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "First File Read Example\n",
      "Dagnabbit!\n",
      "We're done with this pass.\n",
      "\n",
      "Second File Read Example\n",
      "Dagnabbit!  IO Error!  Exception Message:  [Errno 2] No such file or directory: 'example.txt'\n",
      "We're done with this pass.\n",
      "\n",
      "Third File Read Example\n",
      "We're done with this pass.\n",
      "\n",
      "Fourth File Read Example\n",
      "This would be where we would do clean up in all cases.\n",
      "We're done with this pass.\n",
      "\n",
      "Fourth File Read Example\n",
      "Dagnabbit!  IO Error!  Exception Message:  [Errno 2] No such file or directory: 'example.txt'\n",
      "This would be where we would do clean up in all cases.\n",
      "We're done with this pass.\n",
      "\n",
      "First Expanded Example\n",
      "Dagnabbit!  ZDE Error!  Exception Message:  division by zero\n",
      "This would be where we would do clean up in all cases.\n",
      "We're done with this pass.\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "\n",
    "# Simple general exception handling, to catch all errors on file open.\n",
    "print (\"\\nFirst File Read Example\")\n",
    "filename = 'example.txt'\n",
    "try:   \n",
    "    input_file = open(filename, 'r')\n",
    "except:\n",
    "    print (\"Dagnabbit!\")        \n",
    "print (\"We're done with this pass.\")\n",
    "\n",
    "# Simple specific exception handling, with error message capture to catch all errors on file open.\n",
    "print (\"\\nSecond File Read Example\")\n",
    "filename = 'example.txt'\n",
    "try:   \n",
    "    input_file = open(filename, 'r')\n",
    "except IOError as exception_message:\n",
    "    print (\"Dagnabbit!  IO Error!  Exception Message: \", exception_message)        \n",
    "print (\"We're done with this pass.\")\n",
    "\n",
    "# Simple specific exception handling, with error message capture to catch all errors on file open.\n",
    "print (\"\\nThird File Read Example\")\n",
    "filename = 'raven.txt'\n",
    "try:   \n",
    "    input_file = open(filename, 'r')\n",
    "except IOError as exception_message:\n",
    "    print (\"Dagnabbit!  IO Error!  Exception Message: \", exception_message)     \n",
    "else:\n",
    "    data_string = input_file.read()  # Read the contents of the file into single string.\n",
    "print (\"We're done with this pass.\")\n",
    "\n",
    "# Complete TRY construct elements, to deal with errors on file open.\n",
    "print (\"\\nFourth File Read Example\")\n",
    "filename = 'raven.txt'\n",
    "try:   \n",
    "    input_file = open(filename, 'r')\n",
    "except IOError as exception_message:\n",
    "    print (\"Dagnabbit!  IO Error!  Exception Message: \", exception_message)     \n",
    "else:\n",
    "    data_string = input_file.read()  # Read the contents of the file into single string.\n",
    "finally:\n",
    "    print (\"This would be where we would do clean up in all cases.\")\n",
    "print (\"We're done with this pass.\")\n",
    "\n",
    "# Complete TRY construct elements, to deal with errors on file open.\n",
    "print (\"\\nFourth File Read Example\")\n",
    "filename = 'example.txt'\n",
    "try:   \n",
    "    input_file = open(filename, 'r')\n",
    "except IOError as exception_message:\n",
    "    print (\"Dagnabbit!  IO Error!  Exception Message: \", exception_message)     \n",
    "else:\n",
    "    data_string = input_file.read()  # Read the contents of the file into single string.\n",
    "finally:\n",
    "    print (\"This would be where we would do clean up in all cases.\")\n",
    "print (\"We're done with this pass.\")\n",
    "\n",
    "# Complete TRY construct elements, to deal with errors on file open.\n",
    "print (\"\\nFirst Expanded Example\")\n",
    "filename = 'raven.txt'\n",
    "try:   \n",
    "    input_file = open(filename, 'r')\n",
    "    infinity = 1/0\n",
    "except (IOError, FileNotFoundError) as exception_message:                 # Can trap for multiple exceptions\n",
    "    print (\"Dagnabbit!  IO Error!  Exception Message: \", exception_message)     \n",
    "except ZeroDivisionError as exception_message:\n",
    "    print (\"Dagnabbit!  ZDE Error!  Exception Message: \", exception_message) \n",
    "except:                                                                   # Can trap all other exceptions.\n",
    "    print(\"Unexpected error:\", sys.exc_info()[0])\n",
    "else:\n",
    "    data_string = input_file.read()  # Read the contents of the file into single string.\n",
    "    input_file.close\n",
    "finally:\n",
    "    print (\"This would be where we would do clean up in all cases.\")\n",
    "print (\"We're done with this pass.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful Functions\n",
    "<a id=UsefulFunctions></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions I Wrote\n",
    "Most of these I brought over from my Perl corpus.  We will see if we really need them much here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f_dash_date():\n",
    "    \"Returns a string with the current date in US format separated with dashes.\"\n",
    "    date_string = str(datetime.datetime.now().strftime('%m_%d_%Y'))\n",
    "    return date_string\n",
    "def f_slash_date():\n",
    "    \"Returns a strong with the current date in US format separated with slashes.\"\n",
    "    date_string = str(datetime.datetime.now().strftime('%m/%d/%Y'))\n",
    "    return date_string      \n",
    "def f_dash_timestamp():\n",
    "    \"Returns a string with the current date and time for log entries.\"\n",
    "    date_string = str(datetime.datetime.now().strftime('%m_%d_%Y_%H:%M:%S'))    \n",
    "    return date_string    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions I Harvested"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from tkinter import *\n",
    "\n",
    "root = Tk()\n",
    "\n",
    "w = Label(root, text=\"Hello Tkinter!\")\n",
    "w.pack()\n",
    "\n",
    "root.mainloop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Appendix\n",
    "<a id=\"Appendix\"></a>\n",
    "\n",
    "Welcome!  This notebook (and its sisters) was developed for me to practice some Python and data science fundamentals, and for me to explore and notate some interesting tricks, quirks, and lessons learned the hard way.\n",
    "\n",
    "### Data on Ships\n",
    "As described earlier, I've been using US naval ship information in this notebook as practice data.  US naval ships each have a unique identifying \"hull number,\" making it is easy to build many common Python data structures around ship characteristics.  More information about US \"hull numbers\" is available from:\n",
    "\n",
    "http://www.navweaps.com/index_tech/index_ships_list.php\n",
    "\n",
    "### Jupyter Features and Controls\n",
    "<a id=\"Jupyter\"></a>\n",
    "I recommend using one of the excellent Jupyter cheat sheets, but here are a few key features and controls.\n",
    "#### Keyboard Shortcuts\n",
    "Use ESC to enter command mode.  From command mode, use ENTER to jump to edit mode.\n",
    "\n",
    "Use CMD+SHIFT+P to show command palette from any mode.\n",
    "##### Command Mode\n",
    "    - ENTER  Jump to edit mode\n",
    "    - H      Display help panel\n",
    "    - M      Make cell Markdown cell\n",
    "    - R      Make cell Raw cell\n",
    "    - Y      Make cell Code cell\n",
    "    - J      Select cell below (Like VI)\n",
    "    - K      Select cell above (Like VI)\n",
    "    - A      Insert new cell above (Like VI)\n",
    "    - B      Insert new cell below (Like VI)\n",
    "    - DD     Delete cell (Like VI)\n",
    "    - X      Cut cell\n",
    "    - C      Copy cell\n",
    "    - V      Paste cell below\n",
    "    - Z      Undo last cell deletion\n",
    "    - S      Save and checkpoint\n",
    "    - OO     Restart kernal\n",
    "##### Edit Mode\n",
    "    - ESC    Jump to command mode\n",
    "    - CTL+]  Indent entire row (from anywhere in row)\n",
    "    - CTL+[  Dedent entire row (from anywhere in row)\n",
    "    - CTL+A  Select all\n",
    "    - CTL+Z  Undo\n",
    "    - CTL+Y  Redo\n",
    "##### Magic and other Meta Tools\n",
    "    - %lsmagic    List Magic commands\n",
    "    - %magic      Display Magic quick user's guide\n",
    "    - %quickref   Display Magic quick refernce\n",
    "    - ?Objectname Display details about selected named program object\n",
    "    - %pwd        Display present working directory\n",
    "    - %env        Display or set OS shell environment information\n",
    "    - %debug      Jump into Python debugger\n",
    "    - %pdb        Interact with Python debugger\n",
    "\n",
    "\\\\( P(A \\mid B) = \\frac{P(B \\mid A) \\, P(A)}{P(B)} \\\\)\n",
    "\n",
    "### Tell Me I'm an Idiot!\n",
    "I welcome coaching, constructive criticism, and insight into more efficient, effective, or Pythonic ways of accomplishing results!\n",
    "\n",
    "Sincerely,\n",
    "\n",
    "*Carl Gusler*\n",
    "\n",
    "Austin, Texas\n",
    "\n",
    "carl.gusler@gmail.com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [conda root]",
   "language": "python",
   "name": "conda-root-py"
  },
  "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": 1
}