Learning Python 2 - Types and Operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Python - Notebook 2 - Types and Operations\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 __Types and Operations.__\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",
    "## Table of Contents\n",
    "\n",
    "+ [Code Formatting](#CodeFormatting)\n",
    "+ [Numerics](#Numerics)\n",
    "+ [Strings](#Strings)\n",
    "+ [Lists](#Lists)\n",
    "+ [Tuples](#Tuples)\n",
    "+ [Dictionaries](#Dicts)\n",
    "+ [Sets](#Sets)\n",
    "+ [Files](#Files)\n",
    "+ [Appendix](#Appendix)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 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 datetime\n",
    "import string\n",
    "import copy\n",
    "import math\n",
    "import reprlib\n",
    "from collections import namedtuple\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",
    "https://www.python.org/dev/peps/pep-0008/\n",
    "https://docs.python.org/3/reference/lexical_analysis.html#implicit-line-joining"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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",
    "\n",
    "# No-Op for adding detailed code to structure later\n",
    "#   Three-dot ellipsis for no-op\n",
    "\n",
    "if x> 0:\n",
    "    ...\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numerics\n",
    "<a id=Numerics></a>\n",
    "This demonstrates some of the less comon numeric operations and capabilities in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " Pi constant:  3.141592653589793\n",
      "\n",
      " e constant:  2.718281828459045\n",
      "\n",
      " Pi constant:  3.141592653589793\n",
      "\n",
      " Pi constant:  3.141592653589793\n",
      "2\n",
      "-1\n",
      "1\n",
      "-2\n",
      "2.5\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "1.6666666666666667\n",
      "1\n",
      "-2\n",
      "-2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "# Numeric constants are available from the 'math' module.\n",
    "\n",
    "print ('\\n Pi constant: ', math.pi)      # \n",
    "print ('\\n e constant: ', math.e)      # \n",
    "print ('\\n Pi constant: ', math.pi)      # \n",
    "print ('\\n Pi constant: ', math.pi)      # \n",
    "\n",
    "\n",
    "# Different or infrequently used aritmetic expressions\n",
    "\n",
    "# MODULO or division remainder\n",
    "''' 'When either a or n is negative, \n",
    "the naive definition breaks down and programming languages differ in how these values are defined.' '''\n",
    "\n",
    "print (5 % 3) # Remainder or MODULO operation\n",
    "print (5 % -3) \n",
    "print (-5 % 3)\n",
    "print (-5 % -3)\n",
    "print (5.5 % 3)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Integer or Floor Division\n",
    "print (5 / 3)\n",
    "print (5 // 3)  # Integer or floor division\n",
    "print (-5 // 3)\n",
    "print (5 // -3)\n",
    "print (-5 // -3)\n",
    "\n",
    "# Binary\n",
    "# Hexadecmial\n",
    "# Octal\n",
    "# Decimal\n",
    "#     Danger!   Here be hamsters!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Strings in Python 3\n",
    "<a id=Strings></a>\n",
    "This demonstrates Python basic string handling capabilities.  Who needs regular expressions when there are so many great string methods!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Supporting Modules\n",
    "The following modules are used to support common string data operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import datetime\n",
    "import string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Generation and Manipulation\n",
    "\n",
    "For string literals and escape codes, see Python Essnt'l Reference p27.\n",
    "\n",
    "String constants are available from the 'string' module.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Whereforearthou Romeo?\"\n",
      "#=================================================================\n",
      "#-----------------------------------------------------------------\n",
      "\n",
      " ASCII constant:  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
      "\n",
      " Digits constant:  0123456789\n",
      "\n",
      " Punctuation constant:  !\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~\n"
     ]
    }
   ],
   "source": [
    "l_string = '\"Whereforearthou Romeo?\"'   # Single quote is preferred string delimiter\n",
    "print (l_string)\n",
    "l_string = \"Carl's Code\"                # Double quote is equivalent string delimiter\n",
    "\n",
    "l_string = '''abc\n",
    "                  def'''    #Triple quote captures everything, including LF\n",
    "\n",
    "a_string = \"\\tDrink Tab!\\n\"  # Quotes can contain escape sequences for tabs, line returns, etc.\n",
    "\n",
    "a_sting = r\"C:\\directory\\file.txt\"   # Raw strings allow use of special characters without conversion to escape sequences\n",
    "\n",
    "\n",
    "\n",
    "bar_string = \"#\" + 65*'='   # Multipled string can be multiple character\n",
    "line_string = \"#\" + 65*'-' # Multipled string can be multiple character\n",
    "print (bar_string)\n",
    "print (line_string)\n",
    "\n",
    "# String constants from 'string' module.\n",
    "print ('\\n ASCII constant: ', string.ascii_letters)      # Requires STRING library/module\n",
    "print ('\\n Digits constant: ', string.digits)      # Requires STRING library/module\n",
    "print ('\\n Punctuation constant: ', string.punctuation)      # Requires STRING library/module\n",
    "\n",
    "#   l_string =  \"Tennessee\"\n",
    "# Forward Index  012345678\n",
    "# Reverse Index -987654321 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion to Strings\n",
    "  The goal of STR is to be readable.\n",
    "  The goal of REPR is to be unambiguous."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "['Indiana', 'Montana', 'Carolina', 'Iowa']\n",
      "42\n",
      "<class 'str'>\n",
      "('Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta')\n",
      "74\n",
      "<class 'str'>\n",
      "{'pecan', 'oak', 'walnut', 'cypress', 'cedar', 'pine'}\n",
      "54\n",
      "<class 'str'>\n",
      "{'DD263': 'Spruance', 'DD985': 'Cushing'}\n",
      "41\n"
     ]
    }
   ],
   "source": [
    "name_list = [\"Indiana\", \"Montana\",\"Carolina\",\"Iowa\"]   \n",
    "name_string = str(name_list) # Converts list to string, brackets and all\n",
    "print ( type(name_string))\n",
    "print (name_string)\n",
    "print (len(name_string))\n",
    "\n",
    "early_tuple = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "early_string = str(early_tuple) # Converts tuple to string, brackets and all\n",
    "print ( type(early_string))\n",
    "print (early_string)\n",
    "print (len(early_string))\n",
    "\n",
    "tree_set = {\"oak\", \"pine\", \"cypress\", \"cedar\", \"pecan\", \"walnut\"}\n",
    "tree_string = str(tree_set)  # Converts set to string, brackets and all\n",
    "print ( type(tree_string) )\n",
    "print (tree_string)\n",
    "print (len(tree_string))   \n",
    "\n",
    "#  Convert dictionary to string.  Watch out for change in dict syntax!\n",
    "destroyer_dict = dict(DD263=\"Spruance\", DD985=\"Cushing\")\n",
    "destroyer_string = str(destroyer_dict) # Converts dict to string, brackets and all\n",
    "print (type(destroyer_string))\n",
    "print (destroyer_string)\n",
    "print (len(destroyer_string))      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']\n",
      "<class 'str'>\n",
      "Len: 25\n",
      "Min: \n",
      "\n",
      "Max: f\n",
      "3.1415926\n",
      "[(1, 'a'), (2, 'b'), (3, 'c'), (4, '\\n'), (5, ' '), (6, ' '), (7, ' '), (8, ' '), (9, ' '), (10, ' '), (11, ' '), (12, ' '), (13, ' '), (14, ' '), (15, ' '), (16, ' '), (17, ' '), (18, ' '), (19, ' '), (20, ' '), (21, ' '), (22, ' '), (23, 'd'), (24, 'e'), (25, 'f')]\n"
     ]
    }
   ],
   "source": [
    "print ( dir(l_string))\n",
    "print ( type(l_string))\n",
    "print ( 'Len: {}'.format(len(l_string))) # Len = character count\n",
    "print ( 'Min: {}'.format(min(l_string))) # Min = alphabettically lowest\n",
    "print ( 'Max: {}'.format(max(l_string))) # Max = alphabettically highest\n",
    "                                         # Case matters!\n",
    "print ( str(3.1415926))        # Convert numbers to strings before print   \n",
    "\n",
    "# The enumerate function makes it possible to index a string, or create a list of index tuples\n",
    "print (list(enumerate(l_string,1)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Indexing, Slicing, and Manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
      "\n",
      " ab\n",
      "\n",
      " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX\n",
      "\n",
      " hijkl\n",
      "\n",
      "\n",
      " \n",
      "\n",
      " QPONMLKJIHGFEDCBAzyxwvutsrqponmlkjihgfe\n",
      ">>>\n",
      "\n",
      " QRSTUVW\n",
      "\n",
      " VW\n",
      "\n",
      " fed\n",
      "\n",
      " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTU\n"
     ]
    }
   ],
   "source": [
    "#  Syntax is stringue[start : stop: step]       The stop number is a \"column\" index, not a step counter\n",
    "\n",
    "\n",
    "#       for any index n, s[:n] + s[n:] == s\n",
    "\n",
    "#   l_string =  \"Tennessee\"\n",
    "# Forward Index  012345678\n",
    "# Reverse Index -987654321 \n",
    "\n",
    "# Some notes  borrowed from the Web:\n",
    "\n",
    "# Indexes enumerate the elements, slices enumerate the spaces between the elements.\n",
    "\n",
    "# Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]\n",
    "# Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]\n",
    "#                    +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]\n",
    "#                    | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]\n",
    "#                    +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]\n",
    "# Slice from front:  :   1   2   3   4   5   :    a[-2]==4\n",
    "# Slice from rear:   :  -5  -4  -3  -2  -1   :\n",
    "\n",
    "asctr = string.ascii_letters\n",
    "\n",
    "# Demo of rules and quirks of indexing and slicing:\n",
    "print ('\\n', asctr)\n",
    "print ('\\n', asctr[0:2])      # Stop value is non-inclusive!\n",
    "print ('\\n', asctr[0:-2])    # Stop value is non-inclusive, forward or back!\n",
    "\n",
    "print ('\\n', asctr[7:12])\n",
    "print (asctr[7:5])            # Start/stop out of range.  Nonesense slice results in nothing returned, and no errors.\n",
    "\n",
    "print ('\\n', asctr[-10:3])    # Start/stop out of range.  Nonesense slice results in nothing returned, and no errors.\n",
    "print ('\\n', asctr[-10:3:-1])    # Works this time, with negative step.\n",
    "print ( \">>>\")  \n",
    "print ('\\n', asctr[-10:-3])    # With positive step, Slice always works from left to right!  Stop is still non-inclusive\n",
    "\n",
    "print ('\\n', asctr[-5:-3])    # Reverse slice requires negative range\n",
    "print ('\\n', asctr[5:2:-1])    # Reverse step requires negative range\n",
    "\n",
    "# Name slices for simplicity and readability!\n",
    "take_five = slice(None, -5)    # You have to have the 'None'\n",
    "print ('\\n', asctr[take_five])  # Cut out the last five\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      ">>>\n",
      "\n",
      " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX\n",
      "\n",
      " fghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
      "\n",
      " abc\n",
      "\n",
      " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX\n",
      "\n",
      " acegikmoqsuwyACEGIKMOQSUWY\n",
      "\n",
      " ZXVTRPNLJHFDBzxvtrpnljhfdb\n",
      "\n",
      " abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n"
     ]
    }
   ],
   "source": [
    "#  Syntax is stringue[start : stop: step]       The stop number is a \"column\" index, not a step counter\n",
    "\n",
    "\n",
    "#       for any index n, s[:n] + s[n:] == s\n",
    "\n",
    "#   l_string =  \"Tennessee\"\n",
    "# Forward Index  012345678\n",
    "# Reverse Index -987654321 \n",
    "\n",
    "# Some notes  borrowed from the Web:\n",
    "\n",
    "# Indexes enumerate the elements, slices enumerate the spaces between the elements.\n",
    "\n",
    "# Index from rear:    -6  -5  -4  -3  -2  -1      a=[0,1,2,3,4,5]    a[1:]==[1,2,3,4,5]\n",
    "# Index from front:    0   1   2   3   4   5      len(a)==6          a[:5]==[0,1,2,3,4]\n",
    "#                    +---+---+---+---+---+---+    a[0]==0            a[:-2]==[0,1,2,3]\n",
    "#                    | a | b | c | d | e | f |    a[5]==5            a[1:2]==[1]\n",
    "#                    +---+---+---+---+---+---+    a[-1]==5           a[1:-1]==[1,2,3,4]\n",
    "# Slice from front:  :   1   2   3   4   5   :    a[-2]==4\n",
    "# Slice from rear:   :  -5  -4  -3  -2  -1   :\n",
    "\n",
    "asctr = string.ascii_letters\n",
    "\n",
    "# Common and special uses of indexing and slicing:\n",
    "print ( \">>>\")            \n",
    "print ('\\n', asctr[0:-2])    # Stop value is non-inclusive, forward or back!\n",
    "\n",
    "print ('\\n', asctr[5:])    # Slice to end, starting with SIXTH item\n",
    "print ('\\n', asctr[:3])    # Slice from beginning, stopping to include third (excluding fourth and beyond)item\n",
    "print ('\\n', asctr[:-2])    # Slice from beginning, stopping to exlude last two items\n",
    "print ('\\n', asctr[::2])    # Slice from beginning to end, stride by 2\n",
    "print ('\\n', asctr[::-2])    # Slice from end to beginning, based on reverse stride of 2\n",
    "\n",
    "print ('\\n', asctr[:])    # Slice everything"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Methods\n",
    "There are a very large number of string methods available.  Here are some typical, useful, and unusual ones.\n",
    "https://docs.python.org/3/library/stdtypes.html#string-methods\n",
    "\n",
    "As strings are immutable, most string methods return a copy and do not modify the subject string itself."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "what do we do now?\n",
      "What do we do now?\n",
      "18\n",
      "what do we do now?\n",
      "what do we do now?\n",
      "18\n",
      "  now is the time for all good men to come to the aid of their country.  england expects every man to do his duty!  \n",
      "  now is the time for all good men to come to the aid of their country.  england expects every man to do his duty!  \n",
      "  Now Is The Time For All Good Men To Come To The Aid Of Their Country.  England Expects Every Man To Do His Duty!  \n",
      "Now is the time for all good men to come to the aid of their country.  England expects every man to do his duty!\n",
      "  nOW IS THE TIME FOR ALL GOOD MEN TO COME TO THE AID OF THEIR COUNTRY.  eNGLAND EXPECTS EVERY MAN TO DO HIS DUTY!  \n",
      "['Now', 'is', 'the', 'time', 'for', 'all', 'good', 'men', 'to', 'come', 'to', 'the', 'aid', 'of', 'their', 'country.', 'England', 'expects', 'every', 'man', 'to', 'do', 'his', 'duty!']\n",
      "['  Now is the time for all good men to come to the aid of their country', '  England expects every man to do his duty!  ']\n",
      "  England expects every man to do his duty!  \n",
      "iNows\n",
      "Now>is>the>time>for>all>good>men>to>come>to>the>aid>of>their>country.>England>expects>every>man>to>do>his>duty!\n",
      "Now is the time for all good men to come to the aid of their country. England expects every man to do his duty!\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "False\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#       \n",
    "phrase = \"  Now is the time for all good men to come to the aid of their country.  England expects every man to do his duty!  \"\n",
    "phrase2 = \"what do we do now?\"\n",
    "print (phrase2)\n",
    "print (phrase2.capitalize())    #Don't forget the parentheses on the method!\n",
    "print (len(phrase2))\n",
    "print (phrase2)\n",
    "phrase2.capitalize()  # This method returns a COPY\n",
    "print (phrase2)\n",
    "print (len(phrase2))\n",
    "\n",
    "print (phrase.capitalize())    #Don't forget the parentheses on the method!\n",
    "print (phrase.casefold())   # This method returns a COPY\n",
    "print (phrase.title())   \n",
    "print (phrase.strip())   \n",
    "print (phrase.swapcase())   \n",
    "print (phrase.split())          # Returns a list of a couple dozen\n",
    "print (phrase.split('.'))          # Returns a list of two\n",
    "print (phrase.split('.')[1])\n",
    "print (phrase.split()[0].join(phrase.split()[1]))\n",
    "print ('>'.join(phrase.split()))\n",
    "print (' '.join(phrase.split()))   # Put Humpty Dumpty back together again with spaces between\n",
    "\n",
    "print (phrase.isalnum())    \n",
    "print (phrase.isalpha())    \n",
    "print (phrase.isdecimal())  \n",
    "print (phrase.isdigit())  \n",
    "print (phrase.isidentifier())  \n",
    "print (phrase.islower())  \n",
    "print (phrase.isnumeric())\n",
    "print (phrase.isprintable())\n",
    "print (phrase.isspace())\n",
    "print (phrase.istitle())\n",
    "print ((phrase.title().istitle()))\n",
    "print (phrase.isupper())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Catalog of String Methods and Functions\n",
    "Regex is great, but I can accomplish 95% of what I need with these tools.\n",
    "(I am leaving out Unicode tools for now.  I will likely include all Unicode techniques in an \"advanced\" notebook.\n",
    "\n",
    "Here is an catalog of string methods, organized by the following groups:\n",
    "- Conversion\n",
    "- Searching\n",
    "- Formatting\n",
    "- Parsing\n",
    "- Transformation\n",
    "- Testing\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n",
      "5\n",
      "5\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "4\n",
      "9\n",
      "-1\n",
      "-1\n",
      "-1\n",
      "9\n",
      "9\n",
      "-1\n",
      "9\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "What do we do now?\n",
      "________Main________\n",
      "001     002     003\n",
      "Left________________\n",
      "lower\n",
      "Left\n",
      "_______________Right\n",
      "Right\n",
      "Center\n",
      "wHY WOULD WE DO tHIS?\n",
      "Losing Your Mind In 3 Easy Lessons\n",
      "UPPER\n",
      "000042\n",
      "-00042\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "['Now', 'is', 'the', 'time', 'for', 'all', 'good', 'men', 'to', 'come', 'to', 'the', 'aid', 'of', 'their', 'country.', 'England', 'expects', 'every', 'man', 'to', 'do', 'his', 'duty!']\n",
      "['  Now is the time for all good men to come to the aid of their country.  England expects every', 'man', 'to', 'do', 'his', 'duty!']\n",
      "('what do ', 'we', ' do now?')\n",
      "('what do ', 'we', ' do now?')\n",
      "['Now is the time for all good men to come to the aid of their country.', '  England expects every man to do his duty!']\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "<class 'list'>\n",
      "['t', 'h', 'e', ' ', 'c', 'a', 't', ' ', 'i', 'n', ' ', 't', 'h', 'e', ' ', 'h', 'a', 't', ' ', 'a', 't', 'e', ' ', 't', 'h', 'e', ' ', 'r', 'a', 't', ' ', 'i', 'n', ' ', 't', 'h', 'e', ' ', 'b', 'a', 'g']\n",
      "the cat in the hat ate the rat in the bag\n",
      "www.ibm.com\n",
      "Saul Goodman, \n",
      "Tennessee\n",
      "this cat in this hat ate this rat in the bag\n",
      "this cat in this hat ate this rat in this bag\n",
      "ib\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "phrase = \"  Now is the time for all good men to come to the aid of their country.  England expects every man to do his duty!  \"\n",
    "phrase1 = \"Now is the time for all good men to come to the aid of their country.\\n  England expects every man to do his duty!\"\n",
    "phrase2 = \"what do we do now?\"\n",
    "#---------------------------------------------------------------------\n",
    "# Conversion\n",
    "#   eval, int, repr\n",
    "print (8 * int('4'))              # INT converts string to integer\n",
    "print (eval('1 + 4'))             # EVAL evaluates contents of string\n",
    "print (repr(1 + 4))\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "#---------------------------------------------------------------------\n",
    "# Searching\n",
    "#    count, find, index, rfind, rindex\n",
    "\n",
    "S = 'the cat in the hat ate the rat in the bag'\n",
    "print (S.count('the'))\n",
    "\n",
    "S = 'Whamalamadingdong'\n",
    "print (S.find('ding'))\n",
    "print (S.find('ding', 10))        # Start searching too deep into the string\n",
    "print (S.find('ding', 1, 5))      # Stop searching too deep into the string\n",
    "print (S.find('battery'))         # FIND returns -1 on no resulsts\n",
    "\n",
    "print (S.index('ding'))           # INDEX generates Value Error exception on no results\n",
    "\n",
    "print (S.rfind('ding'))\n",
    "print (S.rfind('battery'))         # RFIND returns -1 on no resulsts\n",
    "\n",
    "print (S.rindex('ding'))           # INDEX generates Value Error exception no resulsts\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "#---------------------------------------------------------------------\n",
    "# Formatting\n",
    "#    capitalize, center, expandtabs, ljust, lstrip, lower rjust, rstrip, strip, swapcase, title, upper, zfill\n",
    "print (phrase2.capitalize())\n",
    "\n",
    "print ('Main'.center(20,'_'))\n",
    "\n",
    "print ('001\\t002\\t003'.expandtabs(tabsize=8))\n",
    "\n",
    "print ('Left'.ljust(20,'_'))\n",
    "\n",
    "print ('LOWER'.lower())\n",
    "\n",
    "print ('    Left'.lstrip())\n",
    "\n",
    "print ('Right'.rjust(20,'_'))\n",
    "\n",
    "print ('Right    '.rstrip())\n",
    "\n",
    "print ('     Center  '.strip())\n",
    "\n",
    "print ('Why would we do This?'.swapcase())\n",
    "\n",
    "print ('Losing your mind in 3 easy lessons'.title())\n",
    "\n",
    "print ('upper'.upper())\n",
    "\n",
    "print ('42'.zfill(6))\n",
    "\n",
    "print ('-42'.zfill(6))\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "#---------------------------------------------------------------------\n",
    "# Parsing\n",
    "#    split, partition, rpartition, rsplit, splitlines\n",
    "cols = phrase.split()             # Split string into word list.  Split on default space character.\n",
    "print (cols)\n",
    "\n",
    "cols = phrase.rsplit(maxsplit=5)             # Split string into word list.  Split on default space character.\n",
    "print (cols)\n",
    "\n",
    "print (phrase2.partition('we'))   # Split string into 3 pieces at search point.\n",
    "print (phrase2.rpartition('we'))   # Split string into 3 pieces at search point.\n",
    "\n",
    "print (phrase1.splitlines())      # Split string into separate lines at various line separation characters.\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "#---------------------------------------------------------------------\n",
    "# Transformation\n",
    "#    join, lstrip, replace, rstrip, strip\n",
    "\n",
    "S = 'the cat in the hat ate the rat in the bag'\n",
    "L = list(S)         # Split string into character list\n",
    "print (type(L))\n",
    "print (L)\n",
    "#                     Manipulate list here\n",
    "s = ''.join(L)       # Join list back into string\n",
    "print (s)\n",
    "\n",
    "print ('https://www.ibm.com'.lstrip('htps:/'))\n",
    "\n",
    "print ('Saul Goodman, Esq.'.rstrip('Esq,.'))\n",
    "\n",
    "S = 'Three'\n",
    "S = S.replace('hr', 'enness')        # Replace one string with another, on first occurrence\n",
    "print (S)\n",
    "\n",
    "S = 'the cat in the hat ate the rat in the bag'\n",
    "print (S.replace('the', 'this', 3))  # Replace one phrase with another, on first 3 occurences\n",
    "S = 'the cat in the hat ate the rat in the bag'\n",
    "print (S.replace('the', 'this', -1))  # Replace one phrase with another. Negative count replaces all.\n",
    "\n",
    "print ('www.ibm.com'.strip('cmowz.'))\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "#---------------------------------------------------------------------\n",
    "# Testing\n",
    "#    Testing methods and functions all return Boolean values\n",
    "#        in\n",
    "#        is_   alnum, alpha, decimal, digit, identifier, lower, numeric, printable, space, title, upper \n",
    "#        startswith, endswith\n",
    "\n",
    "print ('spam' in 'spamarama')\n",
    "\n",
    "print ('abc124'.isalnum())       # Test for alphanumeric, NOT test for all numeric\n",
    "print ('abcd'.isalpha())         # Test for alphabetic\n",
    "print ('1234'.isdecimal())       # Test for decimal.  Definitions of \"decimal\" and \"digit\" are complicated.\n",
    "print ('12345'.isdigit())\n",
    "print ('abcd,./<>?!@#$%^&*()12'.islower())   # It appears that non-alpha characters are considered lower case\n",
    "print ('123456789'.isnumeric())  # Test for numerals, excluding sign, decimal, comma, etc.\n",
    "print (' '.isspace())\n",
    "print ('What The Heck?'.istitle())\n",
    "print ('ABCD,./<>?!@#$%^&*()12'.isupper())   # It appears that non-alpha characters are considered upper case\n",
    "\n",
    "print ('Alpha'.startswith(('Al', 'Ral')))    # Can search for entries in a tuple\n",
    "print ('Omega'.endswith(('ga', 'ra')))       # Can search for entries in a tuple\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String Formatting\n",
    "Python V3 string formatting uses the string format method.  Overall syntax is:\n",
    "\n",
    "    string.format(arguments)\n",
    "\n",
    "General syntax looks like:\n",
    "\n",
    "    'Name is {fieldname1!s:_<12} {fieldname2!s:_<18}'.format(arg1, keyword=arg2) \n",
    "\n",
    "The string contains literal text and __replacement fields__ delimited by braces {}.  The formatting language is contained within the replacement fields.  The full syntax is structured as follows:\n",
    "\n",
    "The __replacement field__ {} may contain, in sequence:\n",
    "\n",
    "    An optional field name\n",
    "    An optional conversion indicator, preceded by !\n",
    "    An optional format specifier, preceded by :\n",
    "\n",
    "The __conversion indicator__ ! may contain one letter to indicate the type of textual conversion.  This is a forced conversion\n",
    "as the format method performs most routine conversions.  Syntax is:\n",
    "\n",
    "    argument!s calls str() on the argument first, to convert to string.\n",
    "    argument!r calls repr() on the argument first, to conver to text representation\n",
    "    argument!a calls ascii() on the argument first, to convert to ascii representation\n",
    "\n",
    "The __format specifier__ : may contain several specific characters controlling formatting of the final string.  The format specificaion \"mini language\" is described further below.\n",
    "\n",
    "___\n",
    "\n",
    "The __format specifier__ syntax is:\n",
    "\n",
    "[[fill]align][sign][#][0][width][grouping_option][.precision][type]\n",
    "\n",
    "    Fill:  Any character\n",
    "    Align: - < > ^ = - Left, right, and center alignment, and = for numeric padding after the sign\n",
    "    Sign:   + - <space> - \n",
    "    #:    Causes \"alternate form\" to be used for numeric conversions\n",
    "    0:    Enables sign-aware zero padding for numeric data\n",
    "    Width:    Integer providing width of formatted field.\n",
    "    Grouping Option\n",
    "    Precision:   Integer providing sig figures after decimal for floating point, or truncation for strings.\n",
    "    Type:  Single letter indicating presentation type, primarily for numeric data types.\n",
    "___\n",
    "\n",
    "For more information:\n",
    "\n",
    "https://docs.python.org/3/library/string.html\n",
    "\n",
    "https://pyformat.info/\n",
    "\n",
    "https://www.digitalocean.com/community/tutorials/how-to-use-string-formatters-in-python-3\n",
    "\n",
    "https://github.com/ulope/pyformat.info\n",
    "\n",
    "#### Basic Formatting\n",
    "Basic formatting is concerned with placing the replacement fields within the main text string, \n",
    "and clearly assigning argumnets for each replacement field."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "uno - dos - tres\n",
      "1 2 3\n",
      "quatro - tres - dos\n",
      "4 4 4\n",
      "uno - dos - tres\n",
      "Message for you, sir!\n",
      "Message for you, sir!\n",
      "5 25 125\n",
      "\n",
      "Result is 15\n",
      "\n",
      "Result is 15\n",
      "\n",
      "Result is 15\n",
      "\n",
      "Result is j*i\n",
      "\n",
      "Result is 'j*i'\n"
     ]
    }
   ],
   "source": [
    "# Basic Formatting\n",
    "\n",
    "    \n",
    "    # Arguments as individual literals\n",
    "    #   Individual relative positional\n",
    "    #   Formatting is string to string, so no conversion necessary\n",
    "print ('{} - {} - {}'.format('uno', 'dos', 'tres'))\n",
    "\n",
    "    #   Formatting is numeric to string, handeld routinely by the FORMAT method.\n",
    "print ('{} {} {}'.format(1,2,3))\n",
    "\n",
    "    #   Indexed positional - Position index starts at zero!\n",
    "print ('{3} - {2} - {1}'.format('uno', 'dos', 'tres', 'quatro'))\n",
    "\n",
    "print ('{3} {3} {3}'.format(1,2,3,4))\n",
    "\n",
    "    # Keywords as arguments to name replacement fields\n",
    "print ('{un} - {duo} - {tre}'.format(un='uno', duo='dos', tre='tres', quat='quatro'))    \n",
    "\n",
    "    # Arguments as variables\n",
    "who = 'you'    \n",
    "print ('Message for {}, sir!'.format(who))    \n",
    "\n",
    "    # String and Arguments as variables\n",
    "string = 'Message for {}, sir!'\n",
    "who = 'you'  \n",
    "print(string.format(who))\n",
    "\n",
    "    # Calculations as Arguments\n",
    "i = 5\n",
    "print(\"{} {} {}\".format(i, i*i, i*i*i))    \n",
    "\n",
    "j = 3\n",
    "print (\"\\nResult is {}\".format(j*i))\n",
    "\n",
    "print (\"\\nResult is {!s}\".format(j*i))\n",
    "\n",
    "print (\"\\nResult is {!r}\".format(j*i))\n",
    "\n",
    "print (\"\\nResult is {}\".format(\"j*i\"))\n",
    "print (\"\\nResult is {!r}\".format(\"j*i\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Padding and Aligning\n",
    "Padding and aligning uses the format specification language within the replacement field. The colon indicates the start of the format specification langauge within the replacement field.  Padding and aligning use the fill and align symbols."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0123456789012\n",
      "|Message     |\n",
      " 0123456789012\n",
      "|Message     |\n",
      " 0123456789012\n",
      "|     Message|\n",
      " 0123456789012\n",
      "|Message_____|\n",
      " 0123456789012\n",
      "|Message-----|\n",
      " 0123456789012\n",
      "|  Message   |\n",
      "#-----------------------------------------------------------------\n",
      "\n",
      "  1    1     1\n",
      "  2    4     8\n",
      "  3    9    27\n",
      "  4   16    64\n",
      "  5   25   125\n",
      "  6   36   216\n",
      "  7   49   343\n",
      "  8   64   512\n",
      "  9   81   729\n",
      " 10  100  1000\n",
      " 11  121  1331\n"
     ]
    }
   ],
   "source": [
    "# Padding and Aligning\n",
    "#   Left Alignment\n",
    "print (' 0123456789012')\n",
    "print ('|{:<12}|'.format('Message'))\n",
    "\n",
    "#   Left Alignment - Default\n",
    "print (' 0123456789012')\n",
    "print ('|{:12}|'.format('Message'))\n",
    "\n",
    "#   Right Alignment\n",
    "print (' 0123456789012')\n",
    "print ('|{:>12}|'.format('Message'))\n",
    "\n",
    "#   Left Alignment with Padding with underscore\n",
    "print (' 0123456789012')\n",
    "print ('|{:_<12}|'.format('Message'))\n",
    "\n",
    "#   Left Alignment with Padding with hyphen\n",
    "print (' 0123456789012')\n",
    "print ('|{:-<12}|'.format('Message'))\n",
    "\n",
    "#   Center Alignment  (Note extra padding space on right side for uneven character count match)\n",
    "print (' 0123456789012')\n",
    "print ('|{:^12}|'.format('Message'))\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "#   Padding and aligning for clarity\n",
    "print ()\n",
    "for i in range(1,12):\n",
    "    print(\"{:3d} {:4d} {:5d}\".format(i, i*i, i*i*i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Truncating and Padding\n",
    "Truncating and padding uses the format specification language within the replacement field. The colon indicates the start of the format specification langauge within the replacement field.  Truncating uses the width and precision controls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " 0123456789012\n",
      "|Mess        |\n",
      " 0123456789012\n",
      "|        Mess|\n",
      " 0123456789012\n",
      "|________Mess|\n",
      " 0123456789012\n",
      "|    Mess    |\n",
      " 0123456789012\n",
      "|____Mess____|\n"
     ]
    }
   ],
   "source": [
    "#   Truncating String with Default Left Alignment\n",
    "print (' 0123456789012')\n",
    "print ('|{:12.4}|'.format('Message'))\n",
    "\n",
    "#   Truncating String with Right Alignment\n",
    "print (' 0123456789012')\n",
    "print ('|{:>12.4}|'.format('Message'))\n",
    "\n",
    "#   Truncating String with Right Alignment and Padding\n",
    "print (' 0123456789012')\n",
    "print ('|{:_>12.4}|'.format('Message'))\n",
    "\n",
    "#   Truncating String with Center Alignment\n",
    "print (' 0123456789012')\n",
    "print ('|{:^12.4}|'.format('Message'))\n",
    "\n",
    "#   Truncating String with Center Alignment and Padding\n",
    "print (' 0123456789012')\n",
    "print ('|{:_^12.4}|'.format('Message'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numbers\n",
    "Formatting numbers uses the format specification language within the replacement field. The colon indicates the start of the format specification langauge within the replacement field.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|512|\n",
      "|00512|\n",
      "| +512|\n",
      "|+0512|\n",
      "|512    |\n",
      "|____512|\n",
      "|    -12|\n",
      "|-    12|\n",
      "|     12|\n",
      "|+    12|\n",
      "|3.141593|\n",
      "| 3.141592654|\n",
      "|____3.141592654|\n",
      "|  3.141592654  |\n",
      "|003.14|\n"
     ]
    }
   ],
   "source": [
    "# Integers (Decimal)\n",
    "print('|{:d}|'.format(512))        # d for Integer\n",
    "\n",
    "print('|{:05d}|'.format(512))        # Zero is special character for sign-aware numberic padding\n",
    "\n",
    "print('|{:+5d}|'.format(512))        # + mandates inclusion of sign\n",
    "\n",
    "print('|{:+05d}|'.format(512))        #\n",
    "\n",
    "print('|{:<7d}|'.format(512))      # 7 for Width, < for Alignment, d for Integer\n",
    "\n",
    "print('|{:_>7d}|'.format(512))\n",
    "\n",
    "print('|{: 7d}|'.format(-12))     # Space for disappearing floating leading sign\n",
    "\n",
    "print('|{:=7d}|'.format(-12))     # = for disappearing leading sign (not floating)\n",
    "\n",
    "print('|{:=7d}|'.format(12))     # =  for disappearing leading sign (not floating)\n",
    "\n",
    "print('|{:=+7d}|'.format(12))     # =+ for mandated leading sign (not floating)\n",
    "\n",
    "# Floating Point\n",
    "print('|{:f}|'.format(3.141592653589793)) # f for Floating Point with default precision of 6\n",
    "\n",
    "print('|{:12.9f}|'.format(3.141592653589793)) # f for Floating Point, with width of 12 and precision of 9\n",
    "\n",
    "print('|{:_>15.9f}|'.format(3.141592653589793))  # With underscore for fill and with alignment\n",
    "\n",
    "print('|{:^15.9f}|'.format(3.141592653589793))\n",
    "\n",
    "print('|{:06.2f}|'.format(3.141592653589793))  # Zero is special character for sign-aware numberic padding"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Numeric Conversions\n",
    "Formatting with numeric conversions uses the format specification language within the replacement field. The colon indicates the start of the format specification langauge within the replacement field. The final Type character specifies the numeric conversion. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "|1000000000|\n",
      "|1000|\n",
      "|1e240|\n",
      "|1E240|\n"
     ]
    }
   ],
   "source": [
    "print('|{:b}|'.format(512))        # Binary\n",
    "print('|{:o}|'.format(512))        # Octal\n",
    "print('|{:x}|'.format(123456))        # Hexadecimal with lower case\n",
    "print('|{:X}|'.format(123456))        # Hexadecimal with upper case\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### DateTime and Objects Controlling Their Own Rendering\n",
    "This example works through the use of the __format__() magic method. \n",
    "Needs more research!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2001-10-10 11:12\n",
      "2001-10-10_11:12\n",
      "<class 'datetime.datetime'>\n",
      "2001-10-10 11:12:00\n"
     ]
    }
   ],
   "source": [
    "from datetime import datetime\n",
    "print ('{:%Y-%m-%d %H:%M}'.format(datetime(2001, 10, 10, 11, 12)))\n",
    "\n",
    "print ('{:%Y-%m-%d_%H:%M}'.format(datetime(2001, 10, 10, 11, 12)))\n",
    "\n",
    "print (type(datetime(2001, 10, 10, 11, 12)))\n",
    "print (datetime(2001, 10, 10, 11, 12))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formatting Dictionaries and Lists Using Named Placeholders\n",
    "\n",
    "The use of keyword arguments or \"double asterisk kwargs\" enables passing a dictionary to the format method.\n",
    "\n",
    "Keyword arguments or double asterisk kwargs (\"star star data\" in the first example below) is the mechanism for passing a dictionary to a function expecting a parameter.)  (\"Dig in this dictionary and find it for yourself.\")\n",
    "\n",
    "https://www.digitalocean.com/community/tutorials/how-to-use-args-and-kwargs-in-python-3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "George Foreman!\n",
      "32 64\n"
     ]
    }
   ],
   "source": [
    "# Formatting contents from a dictionary\n",
    "data = {'first': 'George', 'last': 'Foreman!'}\n",
    "print ('{first} {last}'.format(**data))\n",
    "\n",
    "# Formatting contents from a list\n",
    "data = [2, 4, 8, 16, 32, 64]\n",
    "print ('{d[4]} {d[5]}'.format(d=data))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Formatting Nested Data Structures\n",
    "This capabilitiy supports accessing containers that support __getitem__ and __getattribute__, such as dictionaries, tuples, and lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "George Foreman\n"
     ]
    }
   ],
   "source": [
    "person = {'first': 'George', 'last': 'Foreman'}\n",
    "print ('{p[first]} {p[last]}'.format(p=person))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists in Python 3\n",
    "<a id=Lists></a>\n",
    "This demonstrates basic Python list management capabilities.\n",
    "\n",
    "### List Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "early_list = []     #Create empty list\n",
    "early_list = list() #Create empty list\n",
    "early_list = [\"Houston\", \"Austin\", \"Huston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\"]\n",
    "\n",
    "#   early_list = [\"Houston\", \"Austin\", \"Huston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\"]\n",
    "# Forward Index = 0          1         2          3               4              5 \n",
    "# Reverse Index = -6          -5        -4         -3              -2             -1 \n",
    "\n",
    "hull_list = [\"BB50\", \"BB51\",\"BB52\",\"BB53\"]\n",
    "name_list = [\"Indiana\", \"Montana\",\"Carolina\",\"Iowa\"]\n",
    "\n",
    "matrix = [\n",
    "    [1, 2, 3, 4],\n",
    "    [5, 6, 7, 8],\n",
    "    [9, 10, 11, 12],\n",
    "]              "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print ('BB50' in hull_list)\n",
    "print ('BB58' in hull_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Variables as Names and Objects\n",
    "Python variables work differently than other popular languages in both scope and another aspect of variable naming.\n",
    "There is a good chance the variable naming characteristic will eventually bite you when you aren't paying attention to \"variable assignment.\"  List variables can especially surprise the unwary.  \n",
    "\n",
    "In Python, variables are names bound to objects, which makes \"variable assignment\" different than in other languages.  As objects, sometimes Python variables can seem to appear to behave as pointers, with different variables seeming to \"point\" to the same object.\n",
    "\n",
    "Mark Lutz covers this well in his _Learning Python_ book.  Mark describes Python's dynamic typing, shared references, and object references, which some programmers call \"weak referencing.\"\n",
    "\n",
    "The behavior explored below is specifically part of shared referencing.  Attention must be paid to shared references and the difference between equality and identity. \n",
    "\n",
    "For deeper insight:\n",
    "\n",
    "http://scottlobdell.me/2013/08/understanding-python-variables-as-pointers/\n",
    "\n",
    "http://www.python-course.eu/python3_deep_copy.php\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n",
      "1754792560\n",
      "1754792560\n",
      "#-----------------------------------------------------------------\n",
      "5\n",
      "12\n",
      "1754792560\n",
      "1754792784\n",
      "#=================================================================\n",
      "['apple', 'pear', 'banana']\n",
      "['apple', 'pear', 'banana']\n",
      "80620424\n",
      "80620424\n",
      "#-----------------------------------------------------------------\n",
      "['apple', 'pear', 'banana', 'carrot']\n",
      "['apple', 'pear', 'banana', 'carrot']\n",
      "80620424\n",
      "80620424\n",
      "#=================================================================\n",
      "['water', 'tea', 'milk']\n",
      "['water', 'tea', 'milk']\n",
      "80538568\n",
      "80621704\n",
      "#-----------------------------------------------------------------\n",
      "['water', 'tea', 'milk']\n",
      "['water', 'tea', 'milk', 'tequila']\n"
     ]
    }
   ],
   "source": [
    "a = 5           #First:  variable assignment with simple integers\n",
    "b = a\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the same object!\n",
    "print (line_string)\n",
    "b = 12\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are NO LONGER the same object!\n",
    "print (bar_string)\n",
    "a = [\"apple\", \"pear\", \"banana\"]    #Second:  variable assignment with lists\n",
    "b = a            #This may not do what you think it does!\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the same object!\n",
    "print (line_string)\n",
    "b.append(\"carrot\")\n",
    "print (a)        #What the heck?!  Where did that carrot come from?\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are STILL the SAME object!\n",
    "print (bar_string)\n",
    "#    If you wanted to make a COPY of another list for separate manipulation, here is what you wanted:\n",
    "a = [\"water\", \"tea\", \"milk\"]    \n",
    "b = list(a)            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!\n",
    "print (line_string)\n",
    "b.append(\"tequila\")\n",
    "print (a)        #Much better\n",
    "print (b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversion to Lists\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0123456789\n",
      "['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']\n",
      "#-----------------------------------------------------------------\n",
      "['Only']\n",
      "[]\n",
      "['Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta']\n",
      "#-----------------------------------------------------------------\n",
      "['FFG60', 'FFG54', 'FFG56', 'FFG31']\n",
      "#-----------------------------------------------------------------\n",
      "['BB33', 'BB45', 'BB61', 'BB56', 'BB35']\n",
      "#-----------------------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "import string\n",
    "# Converting Strings to Lists\n",
    "num_string = string.digits \n",
    "num_list = list(num_string)\n",
    "print (num_string)\n",
    "print (num_list)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Converting Tuples to Lists\n",
    "singleton_tuple = (\"Only\",)  # Note trailing comma\n",
    "test_list = list(singleton_tuple)\n",
    "print (test_list)\n",
    "\n",
    "early_tuple = tuple() #Create empty Tuple\n",
    "test_list = list(early_tuple)\n",
    "print (test_list)\n",
    "\n",
    "early_tuple = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "test_list = list(early_tuple)\n",
    "print (test_list)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Converting Dictionaries to Lists\n",
    "frigate_dict = {\"FFG54\":\"Ford\", \"FFG60\":\"Davis\", \"FFG31\":\"Stark\", \"FFG56\":\"Simpson\"}\n",
    "test_list = list(frigate_dict)\n",
    "print (test_list)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "battleship_dict_in_dict = {\"BB35\":{\"name\":\"Texas\", \"length\":573, \"guns\":10},\n",
    "    \"BB61\":{\"name\":\"Iowa\", \"length\":887, \"guns\":9},\n",
    "    \"BB56\":{\"name\":\"Alaska\", \"length\":729, \"guns\":12},                               \n",
    "    \"BB33\":{\"name\":\"Arkansas\", \"length\":562, \"guns\":12},                               \n",
    "    \"BB45\":{\"name\":\"Colorado\", \"length\":624, \"guns\":8}\n",
    "    }\n",
    "test_list = list(battleship_dict_in_dict)  # Note that lower levels of nesting are lost.  It is just a dict.\n",
    "print (test_list)\n",
    "print (\"#\" + 65*'-')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__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",
      "#-----------------------------------------------------------------\n",
      "Len: 6\n",
      "Min: Atlanta\n",
      "Max: Walnut Creek\n",
      "[('BB50', 'Indiana'), ('BB51', 'Montana'), ('BB52', 'Carolina'), ('BB53', 'Iowa')]\n",
      "[(1, 'Houston'), (2, 'Austin'), (3, 'Huston'), (4, 'Walnut Creek'), (5, 'Kansas City'), (6, 'Atlanta')]\n"
     ]
    }
   ],
   "source": [
    "print ( dir(early_list))\n",
    "print ( type(early_list))\n",
    "print (line_string)\n",
    "print ( 'Len: {}'.format(len(early_list))) # Len = element count\n",
    "print ( 'Min: {}'.format(min(early_list))) # Min = alphabettically lowest\n",
    "print ( 'Max: {}'.format(max(early_list))) # Max = alphabettically highest\n",
    "\n",
    "# ZIP creates a ZIP object, which can be converted into a list of tuples\n",
    "ship_tuple_list = list(zip(hull_list, name_list))\n",
    "print ( ship_tuple_list)\n",
    "\n",
    "# The ENUMERATE function is used to expand a list with an embedded index\n",
    "numbered_list = list(enumerate(early_list, start=1))\n",
    "print (numbered_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Indexing, Slicing, Insertion, Replacement and Manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Houston', 'Austin']\n",
      "[]\n",
      "['Austin', 'Huston']\n",
      "['Atlanta', 'Kansas City', 'Walnut Creek']\n",
      ">>>\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek']\n",
      "['Atlanta']\n",
      "['Houston', 'Austin', 'Huston']\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta']\n",
      "['Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta']\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "['Houston', 'Austin', 'Houston', 'Walnut Creek', 'Olathe', 'Overland Park', 'Atlanta']\n",
      "['Houston', 'Austin', 'Houston', 'Pasadena', 'Walnut Creek', 'Olathe', 'Overland Park', 'Atlanta']\n",
      "['Houston', 'Austin', 'Houston', 'Walnut Creek', 'Olathe', 'Overland Park', 'Atlanta']\n"
     ]
    }
   ],
   "source": [
    "early_list = [\"Houston\", \"Austin\", \"Huston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\"]\n",
    "print ( early_list[0:2])    # Slice end value is non-inclusive!\n",
    "\n",
    "print ( early_list[-1:-3])    # Slice always works from left to right!\n",
    "print ( early_list[-5:-3])    # Reverse slice requires negative range\n",
    "print ( early_list[5:2:-1])    # Reverse step requires negative range\n",
    "\n",
    "print ( \">>>\")            \n",
    "print ( early_list[0:-2])    # Slice end value is non-inclusive, forward or back!\n",
    "\n",
    "print ( early_list[5:])    # Slice to end, inclusive\n",
    "print ( early_list[:3])    # Slice from beginning\n",
    "print ( early_list[:])    # Slice everything\n",
    "early_list[2] = \"Houston\"   #List item replacement   \n",
    "print (early_list)\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "early_list[4:5] = ['Olathe', 'Overland Park']       # Replacement with insertion\n",
    "print (early_list)\n",
    "early_list[3:3] = ['Pasadena']       # Insertion without replacement (Note insertion BEFORE indexed place)\n",
    "print (early_list)\n",
    "early_list[3:4] = []       # Deletion by inserting nothing\n",
    "print (early_list)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Methods - Selected simple representational methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton', 'Omaha']\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton', 'Omaha', 'S', 'h', 'a', 'w', 'n', 'e', 'e']\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton', 'Omaha', 'S', 'h', 'a', 'w', 'n', 'e', 'e', 'Shawnee']\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton', 'Omaha']\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton']\n",
      "['Houston', 'Austin', 'Tucson', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton']\n",
      "#-----------------------------------------------------------------\n",
      "0\n",
      "1\n",
      "9\n",
      "9\n",
      "#-----------------------------------------------------------------\n",
      "['Houston', 'Austin', 'Huston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Boca Raton', 'Austin', 'Jollyville']\n",
      "#-----------------------------------------------------------------\n",
      "#=================================================================\n",
      "#-----------------------------------------------------------------\n",
      "['Jollyville', 'Austin', 'Boca Raton', 'Atlanta', 'Kansas City', 'Walnut Creek', 'Huston', 'Austin', 'Houston']\n",
      "['Atlanta', 'Austin', 'Austin', 'Boca Raton', 'Houston', 'Huston', 'Jollyville', 'Kansas City', 'Walnut Creek']\n",
      "#-----------------------------------------------------------------\n",
      "[1, 2, 3, [4, 5, ['target']]]\n",
      "[4, 5, ['target']]\n",
      "['target']\n",
      "target\n",
      "['xyz', 'abc', 'zara', 'xyz', 123]\n"
     ]
    }
   ],
   "source": [
    "early_list = [\"Houston\", \"Austin\", \"Huston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\"]\n",
    "early_list.append(\"Boca Raton\")    #note parenthesis\n",
    "early_list.append(\"Omaha\")    #note parenthesis\n",
    "print ( early_list)\n",
    "\n",
    "extend_test_string = list(early_list)   #NOTE!  This is how you duplicate a list to another variable\n",
    "extend_test_string.extend(\"Shawnee\")\n",
    "print (extend_test_string)     #Note how extend disassembles string\n",
    "extend_test_string.extend([\"Shawnee\"])\n",
    "print (extend_test_string)     #Note how extend does not disassemble a list\n",
    "\n",
    "print ( early_list)            \n",
    "del early_list[-1]            # Item can be removed by index (or by value - see below)\n",
    "print ( early_list)\n",
    "\n",
    "early_list.insert(2, \"Tucson\")\n",
    "print ( early_list)\n",
    "early_list.remove(\"Tucson\")   # Item can be removed by value (or by index - see above)\n",
    "early_list.extend([\"Austin\", \"Jollyville\"])     # Note adding a list, not just adding elements.\n",
    "\n",
    "print (line_string)\n",
    "birth = early_list.index(\"Houston\")\n",
    "print (birth)\n",
    "first_return = early_list.count(\"Houston\")\n",
    "print (first_return)\n",
    "dupl_list = early_list.copy()   #Watch out for shallow and deep copies!   \n",
    "print (len(early_list))\n",
    "print (len(dupl_list))\n",
    "\n",
    "print (line_string)\n",
    "print ( early_list)\n",
    "print (line_string)\n",
    "print (bar_string)\n",
    "\n",
    "early_list.reverse()\n",
    "print (line_string)\n",
    "print ( early_list)\n",
    "early_list.sort()  # Method permanently changes the list\n",
    "print ( early_list)\n",
    "\n",
    "print (line_string)\n",
    "nest = [1,2,3,[4,5,['target']]]\n",
    "print (nest)\n",
    "print (nest[3])\n",
    "print (nest[3][2])      # The last element is still a list!  (With one element)\n",
    "print (nest[3][2][0])   # Selecting the element and not the short list!\n",
    "\n",
    "aList = [123, 'xyz', 'zara', 'abc', 'xyz'];\n",
    "\n",
    "aList.reverse();\n",
    "print (aList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Sorting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Atlanta', 'Austin', 'Houston', 'Huston', 'Kansas City', 'Walnut Creek']\n",
      "['Walnut Creek', 'Kansas City', 'Huston', 'Houston', 'Austin', 'Atlanta']\n"
     ]
    }
   ],
   "source": [
    "early_list = [\"Houston\", \"Austin\", \"Huston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\"]\n",
    "print (sorted(early_list))           \n",
    "print (sorted(early_list, key=str.lower, reverse=True))  #SORTED is usually the best tool for sorting\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Comprehensions\n",
    "Build complex lists with a single line of code.  Could have been more accurately called \"List Constructors.\"\n",
    "Can also be seen as a way to transform one list into another list.  From coding perspective, this is just \"flattening\" one or more nested loops into a single line of code.  This enables lists to bee built using any iterable, including strings and tuples.\n",
    "+ Can use an existing list to construct a new list.\n",
    "+ Can be nested.\n",
    "+ Can contain conditionals\n",
    "+ Can mix different types of data within the list (as with any list.)\n",
    "\n",
    "The programmer can frequently accomplish the same thing with map() and a lambda function. However, there are cases when programmer cannot use map() and will have to use a list comprehension, or vice versa. When code logic could use either, then it can often be  preferable to use a list comprehension, because that approach can be more efficient and easier to read.\n",
    "\n",
    "The programmer cannot use list comprehensions when the construction rule is too complicated to be expressed with \"for\" and \"if\" statements, or if the construction rule can change dynamically at runtime. In this case, coder may use map() and / or filter() with an appropriate function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 3, 4, 6, 8, 12, 14]\n",
      "[2, 4, 6, 8, 12, 14]\n",
      "['3.1', '3.14', '3.142', '3.1416', '3.14159']\n",
      "[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]\n",
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n",
      "<map object at 0x0000000004CE1588>\n",
      "[2, 6, 10, 14, 22]\n"
     ]
    }
   ],
   "source": [
    "prime_list = [1,2,3,5,7,11]\n",
    "\n",
    "#  We are building a list, so the identity statement is structured as a list constructor.\n",
    "prime_incr_list = [n+1 for n in [1,2,3,5,7,11,13]]    \n",
    "print (prime_incr_list)\n",
    "\n",
    "#  Note the use of a conditional in the constructor\n",
    "even_prime_incr_list = [n+1 for n in [1,2,3,5,7,11,13] if (n+1)%2==0]\n",
    "print (even_prime_incr_list)\n",
    "\n",
    "PI = 3.1415926\n",
    "print ([str(round(PI, i)) for i in range(1, 6)])    #RANGE is your friend in list comprehensions!\n",
    "print (matrix)\n",
    "\n",
    "#  Constructors can be nested\n",
    "print ([[row[i] for row in matrix] for i in range(4)])  # Nested\n",
    "\n",
    "doubled_primes = map(lambda n: n * 2, filter(lambda n: n % 2 == 1, prime_list))\n",
    "print (doubled_primes)\n",
    "doubled_primes = [n * 2 for n in prime_list if n % 2 == 1]\n",
    "print (doubled_primes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Traversing and Looping"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for i, v in enumerate(['tic', 'tac', 'toe']):\n",
    "    print(i, v)\n",
    "    \n",
    "print (enumerate(['tic', 'tac', 'toe']))  # The enumerate object is an iterator of a list of tuples\n",
    "list(enumerate(['tic', 'tac', 'toe']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### List Techniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Convert list with redundant entries into list of unique entries by passing through a set\n",
    "unique_list = list(set(early_list))  # May destroy sort order\n",
    "print (unique_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples in Python 3\n",
    "<a id=Tuples></a>\n",
    "This demonstrates basic Python tuple management capabilities.\n",
    "\n",
    "### Tuple Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "singleton_tuple = (\"Only\",)  # Note trailing comma\n",
    "print ( type(singleton_tuple))\n",
    "early_tuple = ()     #Create empty tuple\n",
    "early_tuple = tuple() #Create empty Tuple\n",
    "early_tuple = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "    \n",
    "# Forward Index = 0          1         2          3               4              5 \n",
    "# Reverse Index = -6          -5        -4         -3              -2             -1 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Variable Names as Objects and References\n",
    "Tuples have the same \"variable assignment\" behavior as the other Python objects.  However, this may be less of an issue since tuples are immutable and not vulnerable to the issue of changing a copy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "80345992\n",
      "80345992\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "b = a\n",
    "print (id(a))\n",
    "print (id(b))   #Note that these are both the same object.\n",
    "print (a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "print ('Houston' in a)\n",
    "print ('Chicago' in a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conversions to Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('W', 'h', 'a', 't', ' ', 'n', 'o', 'w', '?')\n",
      "('What now?',)\n",
      "('What now?', 'Sucker!')\n"
     ]
    }
   ],
   "source": [
    "# Convert strings to tuples\n",
    "a_Tuple = tuple(\"What now?\")\n",
    "print (a_Tuple)\n",
    "\n",
    "# Convert lists to tuples\n",
    "a_Tuple = tuple([\"What now?\"])\n",
    "print (a_Tuple)\n",
    "\n",
    "a_Tuple = tuple([\"What now?\", \"Sucker!\"])\n",
    "print (a_Tuple)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index']\n",
      "<class 'tuple'>\n",
      "Len: 6\n",
      "Min: Atlanta\n",
      "Max: Walnut Creek\n",
      "Max:   Walnut Creek\n",
      "[(1, 'Houston'), (2, 'Austin'), (3, 'Houston'), (4, 'Walnut Creek'), (5, 'Kansas City'), (6, 'Atlanta')]\n",
      "((1, 'Houston'), (2, 'Austin'), (3, 'Houston'), (4, 'Walnut Creek'), (5, 'Kansas City'), (6, 'Atlanta'))\n"
     ]
    }
   ],
   "source": [
    "print ( dir(early_tuple))\n",
    "print ( type(early_tuple))\n",
    "print ( 'Len: {}'.format(len(early_tuple))) # Len = element count\n",
    "print ( 'Min: {}'.format(min(early_tuple))) # Min = alphabettically lowest\n",
    "print ( 'Max: {}'.format(max(early_tuple))) # Max = alphabettically highest\n",
    "print ( \"Max:  \", max(early_tuple))\n",
    "\n",
    "# The enumerate function makes it possible to index a tuple, create a list of index tuples, or create a tuple of index tuples\n",
    "print (list(enumerate(early_tuple,1)))\n",
    "\n",
    "print (tuple(enumerate(early_tuple,1)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Tuple Indexing, Slicing, and Manipulation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Houston', 'Austin')\n",
      "()\n",
      "('Austin', 'Houston')\n",
      "('Atlanta', 'Kansas City', 'Walnut Creek')\n",
      ">>>\n",
      "('Houston', 'Austin', 'Houston', 'Walnut Creek')\n",
      "('Atlanta',)\n",
      "('Houston', 'Austin', 'Houston')\n",
      "('Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta')\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "('Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Texas', 'Texas', 'Texas', 'California', 'Kansas', 'Georgia')\n",
      "('Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta', 'Houston', 'Austin', 'Houston', 'Walnut Creek', 'Kansas City', 'Atlanta')\n"
     ]
    }
   ],
   "source": [
    "print ( early_tuple[0:2])    # Slice end value is non-inclusive!\n",
    "\n",
    "print ( early_tuple[-1:-3])    # Slice always works from left to right!\n",
    "print ( early_tuple[-5:-3])    # Reverse slice requires negative range\n",
    "print ( early_tuple[5:2:-1])    # Reverse step requires negative range\n",
    "\n",
    "print ( \">>>\")            \n",
    "print ( early_tuple[0:-2])    # Slice end value is non-inclusive, forward or back!\n",
    "\n",
    "print ( early_tuple[5:])    # Slice to end, inclusive\n",
    "print ( early_tuple[:3])    # Slice from beginning\n",
    "print ( early_tuple[:])    # Slice everything\n",
    "\n",
    "print (\"\\n#\" + 65*'-')\n",
    "a = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "b = (\"Texas\", \"Texas\", \"Texas\", \"California\", \"Kansas\", \"Georgia\")\n",
    "print (a + b)             # Tuple Concatenation\n",
    "print (a * 3)             # Tuple Repetition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Tuple Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print ( early_tuple.count(\"Houston\") )    # Count occurences\n",
    "print ( early_tuple.index(\"Houston\") )    # Find first occurence"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Sorting\n",
    "As immutable, tuples cannot be **directly** sorted, but may be indirectly sorted."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Atlanta', 'Austin', 'Houston', 'Houston', 'Kansas City', 'Walnut Creek')\n"
     ]
    }
   ],
   "source": [
    "a = (\"Houston\", \"Austin\", \"Houston\", \"Walnut Creek\", \"Kansas City\", \"Atlanta\")\n",
    "print (tuple(sorted(list(a))))          #SORTED is usually the best tool for sorting \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuple Comprehensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4, 6, 8, 12)\n",
      "<generator object <genexpr> at 0x0000000004CBDDB0>\n",
      "(2, 4, 6, 8, 12, 14)\n"
     ]
    }
   ],
   "source": [
    "prime_tuple = (1,2,3,5,7,11)\n",
    "prime_incr_tuple = tuple(n+1 for n in prime_tuple)    \n",
    "print (prime_incr_tuple)\n",
    "\n",
    "prime_incr_tuple = (n+1 for n in prime_tuple)    \n",
    "print (prime_incr_tuple)\n",
    "\n",
    "even_prime_incr_tuple = tuple(n+1 for n in [1,2,3,5,7,11,13] if (n+1)%2==0)\n",
    "print (even_prime_incr_tuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Tuple Techniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Tuple Unpacking\n",
    "list_of_tuples = [{1,2},(3,4),(5,6),(7,8)]\n",
    "for item in list_of_tuples:\n",
    "    print (item)\n",
    "    \n",
    "for (l,r) in list_of_tuples:\n",
    "    print (l,r)\n",
    "\n",
    "for l,r in list_of_tuples:\n",
    "    print (l)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Named Tuples\n",
    " Named Tuples are introduced in Section 2 of the book but are part of a separate library and not really part of the base code.  (In other words, aren't one of the core data structures.)\n",
    " \n",
    " Named Tuple basics are displayed here, but are covered in more detail in my notebook named *Python Intermediate Topics Student Notebook*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "American\n",
      "John\n",
      "British\n",
      "<class '__main__.Pythonista'>\n",
      "Pythonista(name='Graham', nationality='British')\n",
      "Graham\n",
      "Graham\n",
      "Graham\n",
      "<class '__main__.Pythonista'>\n",
      "Pythonista(name='John', nationality='British')\n",
      "<class '__main__.Pythonista'>\n",
      "Pythonista(name='Terry', nationality='American')\n",
      "<class '__main__.Pythonista'>\n",
      "Pythonista(name='Michael', nationality='British')\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "<class '__main__.idle_dict'>\n",
      "idle_dict(instrument='Guitar', name='Eric', nationality='British')\n",
      "Guitar\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "# Regular Tuple \n",
    "smothers1 = (\"Tom\", \"American\")     # Tuple of first name and nationality\n",
    "print (smothers1[1])   # Show nationality of member (Index by integer 1)\n",
    "\n",
    "# Named Tuples (with pre-defined structure)\n",
    "Pythonista = namedtuple('Pythonista', 'name nationality')  # Class Definition syntax\n",
    "\n",
    "cleese = Pythonista(name=\"John\", nationality='British')  # Object creation with keywords\n",
    "chapman = Pythonista(\"Graham\", \"British\")    # Object creation with positional parameters\n",
    "\n",
    "gillist = [\"Terry\", \"American\"]\n",
    "gilliam = Pythonista._make(gillist)   # Object creation using _make method and list of parameters\n",
    "\n",
    "pal_dict = {'name' : 'Michael', 'nationality' : 'British'}\n",
    "palin = Pythonista(**pal_dict)   # Object creation using a dictionary matching the class definition\n",
    "\n",
    "print (cleese.name)      # Object reference with keyword\n",
    "print (cleese.nationality)\n",
    "\n",
    "print (type(chapman))\n",
    "print (chapman)\n",
    "print (chapman.name)    # Object reference with keyword\n",
    "print (chapman[0])      # Object reference with integer index\n",
    "print (getattr(chapman, 'name'))   # Object reference with GETATTR method\n",
    "\n",
    "print (type(cleese))\n",
    "print (cleese)\n",
    "\n",
    "print (type(gilliam))\n",
    "print (gilliam)\n",
    "\n",
    "print (type(palin))\n",
    "print (palin)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Named Tuple WITHOUT pre-defined structure\n",
    "idle_dict = {'name' : 'Eric', 'instrument' : 'Guitar', 'nationality' : 'British'}  # Note extra named field\n",
    "idle = namedtuple('idle_dict', idle_dict.keys())(**idle_dict) # Object creation from dictionary\n",
    "print (type(idle))\n",
    "print (idle)\n",
    "print (idle.instrument)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries in Python 3\n",
    "<a id=Dicts></a>\n",
    "This demonstrates basic Python dictionary management capabilities."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Import Supporting Modules\n",
    "The following modules are used to support common dictionary operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import reprlib\n",
    "import pprint"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "tree_dict = {}     #Create empty dict, NOT empty set\n",
    "empty_dict = dict() #Create empty dict\n",
    "\n",
    "# Generation Syntax Method #1:  Traditional\n",
    "battleship_dict = {\"BB35\":\"Texas\", \"BB61\":\"Iowa\"}\n",
    "\n",
    "destroyer_dict = dict(DD263=\"Spruance\", DD985=\"Cushing\")\n",
    "\n",
    "# Generation Syntax Method #2:  Assignment by Keys\n",
    "destroyer_dict[\"DD992\"]=\"Fletcher\"   # Note square brackets\n",
    "\n",
    "# Generation Syntax Method #3:  Keyword Argument Form\n",
    "missile_destroyer_dict = dict(DDG10=\"Sampson\", DDG11 = \"Sellers\")\n",
    "\n",
    "# Generation Syntax Method #4:  Key/Value Tuple Assignment\n",
    "frigate_dict = {(\"FFG54\", \"Ford\"), (\"FFG60\", \"Davis\"), (\"FFG31\", \"Stark\"), (\"FFG56\",\"Simpson\")}\n",
    "\n",
    "battleship_dict_in_dict = {\"BB35\":{\"name\":\"Texas\", \"length\":573, \"guns\":10},\n",
    "    \"BB61\":{\"name\":\"Iowa\", \"length\":887, \"guns\":9},\n",
    "    \"BB56\":{\"name\":\"Alaska\", \"length\":729, \"guns\":12},                               \n",
    "    \"BB33\":{\"name\":\"Arkansas\", \"length\":562, \"guns\":12},                               \n",
    "    \"BB45\":{\"name\":\"Colorado\", \"length\":624, \"guns\":8}\n",
    "    }\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Add, Read, Copy, and Delete Dictionary Entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'BB61': 'Iowa', 'BB35': 'Texas', 'BB37': 'Oklahoma', 'BB38': 'Pennsylvania', '51': 'Hood', 'BB36': 'Nevada', 'BB47': 'Washington'}\n"
     ]
    }
   ],
   "source": [
    "# Add dictionary entries\n",
    "battleship_dict[\"51\"]=\"Hood\"\n",
    "battleship_dict.update({\"BB36\":\"Nevada\"})\n",
    "battleship_dict.update(dict(BB37=\"Oklahoma\", BB38=\"Pennsylvania\"))\n",
    "battleship_dict.update(BB47=\"Washington\")\n",
    "\n",
    "print (battleship_dict)\n",
    "\n",
    "# Read dictionary entries\n",
    "\n",
    "# Copy dictionary entries\n",
    "\n",
    "\n",
    "# Delete dictionary entries\n",
    "del battleship_dict[\"BB38\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Variable Names as Objects and References\n",
    "Python variables work differently than other popular languages in both scope and another aspect of variable naming.\n",
    "There is a good chance the variable naming characteristic will eventually bite you when you aren't paying attention to \"variable assignment.\"  Dictionary variables can especially surprise the unwary.  \n",
    "\n",
    "In Python, variables are names bound to objects, which makes \"variable assignment\" different than in other languages.  As objects, sometimes Python variables can seem to appear to behave as pointers, with different variables seeming to \"point\" to the same object.\n",
    "\n",
    "Mark Lutz covers this well in his _Learning Python_ book.  Mark describes Python's dynamic typing, shared references, and object references, which some programmers call \"weak referencing.\"\n",
    "\n",
    "The behavior explored below is specifically part of shared referencing.  Attention must be paid to shared references and the difference between equality and identity. \n",
    "\n",
    "For deeper insight:\n",
    "\n",
    "http://scottlobdell.me/2013/08/understanding-python-variables-as-pointers/\n",
    "\n",
    "http://www.python-course.eu/python3_deep_copy.php\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "80604360\n",
      "80604360\n",
      "True\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'California': 'Poppy', 'Alaska': 'Spruce'}\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'California': 'Poppy', 'Alaska': 'Spruce'}\n",
      "80604360\n",
      "80604360\n",
      "True\n",
      "#-----------------------------------------------------------------\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "80382344\n",
      "80580936\n",
      "False\n",
      "#-----------------------------------------------------------------\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "80604616\n",
      "80604360\n",
      "False\n",
      "#-----------------------------------------------------------------\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "{'Alabama': 'Pine', 'Texas': 'Pecan', 'Alaska': 'Spruce'}\n",
      "80580936\n",
      "80076744\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = {\"Alabama\":\"Pine\", \"Texas\":\"Pecan\", \"Alaska\":\"Spruce\"}\n",
    "b = a                       # This doesn't copy the dictionary!\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))               # They are the same object\n",
    "print (a is b)\n",
    "b[\"California\"]=\"Poppy\"\n",
    "print (a)                   # Where the heck did that flower come from?\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))               # They are still the same object\n",
    "print (a is b)\n",
    "\n",
    "print (\"#\" + 65*'-')\n",
    "#    If you want to make a COPY of another simple dictionary, here is one method:\n",
    "a = {\"Alabama\":\"Pine\", \"Texas\":\"Pecan\", \"Alaska\":\"Spruce\"}\n",
    "b = dict(a)            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!\n",
    "print (a is b)\n",
    "\n",
    "print (\"#\" + 65*'-')\n",
    "#    If you want to make a COPY of another simple dictionary, here is another method:\n",
    "a = {\"Alabama\":\"Pine\", \"Texas\":\"Pecan\", \"Alaska\":\"Spruce\"}\n",
    "b = a.copy()            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!\n",
    "print (a is b)\n",
    "\n",
    "print (\"#\" + 65*'-')\n",
    "#    If you want to make a COPY of a complex dictionary, here is the deep method:\n",
    "import copy\n",
    "a = {\"Alabama\":\"Pine\", \"Texas\":\"Pecan\", \"Alaska\":\"Spruce\"}\n",
    "b = copy.deepcopy(a)            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!\n",
    "print (a is b)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']\n",
      "<class 'dict'>\n",
      "#-----------------------------------------------------------------\n",
      "{'BB61': 'Iowa', 'BB35': 'Texas', 'BB37': 'Oklahoma', 'BB36': 'Nevada', 'BB47': 'Washington'}\n",
      "{'DD992': 'Fletcher', 'DD263': 'Spruance', 'DD985': 'Cushing', 'DDG10': 'Sampson', 'DDG11': 'Sellers', 'DDG200': 'Nonesuch'}\n",
      "#-----------------------------------------------------------------\n",
      "5\n",
      "6\n",
      "#-----------------------------------------------------------------\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'51'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-15-c394fd560f23>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;34m\"#\"\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     12\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m \u001b[1;32mdel\u001b[0m \u001b[0mbattleship_dict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m\"51\"\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[1;32mif\u001b[0m \u001b[1;34m'z'\u001b[0m \u001b[1;32min\u001b[0m \u001b[0mbattleship_dict\u001b[0m\u001b[1;33m:\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mdict\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'z'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m#Avoid key errors\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: '51'"
     ]
    }
   ],
   "source": [
    "print ( dir(battleship_dict))\n",
    "print ( type(battleship_dict))\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "print ( battleship_dict)\n",
    "print ( destroyer_dict)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "print (len(battleship_dict))\n",
    "print (len(destroyer_dict))\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "del battleship_dict[\"51\"]\n",
    "\n",
    "if 'z' in battleship_dict: print (dict['z'])  #Avoid key errors\n",
    "print (battleship_dict.get('z'))  ## None (instead of KeyError)\n",
    "\n",
    "print (list(enumerate(battleship_dict,1)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Membership"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print ('BB61' in battleship_dict)    # Key is in dictionary (or not)\n",
    "print ('BB62' in battleship_dict)    \n",
    "\n",
    "print ('Iowa' in battleship_dict)    # Value is NOT in dictionary (keys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Methods\n",
    "The most important methods are .keys, .values, and .items"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Texas\n",
      "#-----------------------------------------------------------------\n",
      "dict_keys(['BB61', 'BB35', 'BB37', 'BB36', 'BB47'])\n",
      "<class 'dict_keys'>\n",
      "<class 'list'>\n",
      "['BB61', 'BB35', 'BB37', 'BB36', 'BB47']\n",
      "#-----------------------------------------------------------------\n",
      "dict_values(['Iowa', 'Texas', 'Oklahoma', 'Nevada', 'Washington'])\n",
      "<class 'dict_values'>\n",
      "<class 'list'>\n",
      "['Iowa', 'Texas', 'Oklahoma', 'Nevada', 'Washington']\n",
      "#-----------------------------------------------------------------\n",
      "dict_items([('BB61', 'Iowa'), ('BB35', 'Texas'), ('BB37', 'Oklahoma'), ('BB36', 'Nevada'), ('BB47', 'Washington')])\n",
      "<class 'dict_items'>\n",
      "<class 'list'>\n",
      "[('BB61', 'Iowa'), ('BB35', 'Texas'), ('BB37', 'Oklahoma'), ('BB36', 'Nevada'), ('BB47', 'Washington')]\n",
      "#-----------------------------------------------------------------\n",
      "BB61\n",
      "BB35\n",
      "BB37\n",
      "BB36\n",
      "BB47\n",
      "#-----------------------------------------------------------------\n",
      "Iowa\n",
      "Texas\n",
      "Oklahoma\n",
      "Nevada\n",
      "Washington\n",
      "#-----------------------------------------------------------------\n",
      "BB61 Iowa\n",
      "BB35 Texas\n",
      "BB37 Oklahoma\n",
      "BB36 Nevada\n",
      "BB47 Washington\n",
      "#-----------------------------------------------------------------\n",
      "BB61 Iowa\n",
      "BB35 Texas\n",
      "BB37 Oklahoma\n",
      "BB36 Nevada\n",
      "BB47 Washington\n",
      "#-----------------------------------------------------------------\n",
      "dict_items([('DD992', 'Fletcher'), ('DD263', 'Spruance'), ('DD985', 'Cushing'), ('DDG10', 'Sampson'), ('DDG11', 'Sellers'), ('DDG200', 'Nonesuch')])\n",
      "#-----------------------------------------------------------------\n",
      "Nonesuch\n",
      "dict_items([('DD992', 'Fletcher'), ('DD263', 'Spruance'), ('DD985', 'Cushing'), ('DDG10', 'Sampson'), ('DDG11', 'Sellers'), ('DDG200', 'Nonesuch')])\n",
      "#-----------------------------------------------------------------\n",
      "Nonesuch\n",
      "dict_items([('DD992', 'Fletcher'), ('DD263', 'Spruance'), ('DD985', 'Cushing'), ('DDG10', 'Sampson'), ('DDG11', 'Sellers'), ('DDG200', 'Nonesuch')])\n",
      "Nonesuch\n",
      "dict_items([('DD992', 'Fletcher'), ('DD263', 'Spruance'), ('DD985', 'Cushing'), ('DDG10', 'Sampson'), ('DDG11', 'Sellers'), ('DDG200', 'Nonesuch')])\n",
      "#-----------------------------------------------------------------\n",
      "dict_items([('BB36', 'Nevada'), ('BB61', 'Iowa'), ('BB35', 'Texas'), ('BB37', 'Oklahoma'), ('BB47', 'Washington')])\n",
      "dict_items([])\n"
     ]
    }
   ],
   "source": [
    "print (battleship_dict['BB35'])\n",
    "print (\"#\" + 65*'-')\n",
    "#    for key in battleship_dict.keys(): print (key)\n",
    "\n",
    "## Get the .keys() list:\n",
    "print (battleship_dict.keys()) \n",
    "z = battleship_dict.keys()\n",
    "x = list(battleship_dict.keys())\n",
    "print (type(z))\n",
    "print (type(x))\n",
    "print (x)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "## Likewise, there's a .values() list of values\n",
    "print (battleship_dict.values())\n",
    "z = battleship_dict.values()\n",
    "x = list(battleship_dict.values())\n",
    "print (type(z))\n",
    "print (type(x))\n",
    "print (x)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "## Likewise, there's a .items() list of tuples of key/values\n",
    "print (battleship_dict.items())\n",
    "z = battleship_dict.items()\n",
    "x = list(battleship_dict.items())\n",
    "print (type(z))\n",
    "print (type(x))\n",
    "print (x)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "for hull in battleship_dict.keys():\n",
    "    print (hull)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "for name in battleship_dict.values():\n",
    "    print (name)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "for hull, name in battleship_dict.items():\n",
    "    print (hull, name)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "for hull in battleship_dict:\n",
    "    print (hull, battleship_dict[hull])\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Use .update to make changes to add one dictionary to another\n",
    "destroyer_dict.update(missile_destroyer_dict)\n",
    "print ( destroyer_dict.items()) \n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Use .get method to query dictionary, avoid key errors, and enable use of a default value.\n",
    "ship = destroyer_dict.get(\"DDG200\", \"Nonesuch\")  #THere is no DDG200 in our dictionary, but no error generated.\n",
    "print (ship)\n",
    "print ( destroyer_dict.items())   # Dictionary contents have not changed.\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Use .setdefault method to query dictionary, avoid key errors, and enable use of a default value.\n",
    "ship = destroyer_dict.setdefault(\"DDG200\", \"Nonesuch\")  #THere is no DDG200 in our dictionary, but no error generated.\n",
    "print (ship)\n",
    "print ( destroyer_dict.items())   # Dictionary contents HAVE changed.\n",
    "ship = destroyer_dict.setdefault(\"DDG200\", \"Whassup\")  #THere is now DDG200 in our dictionary, so default ignored.\n",
    "print (ship)\n",
    "print ( destroyer_dict.items())   # Dictionary contents HAVE NOT changed.\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Use .copy method to copy dictionary (prior to test .clear method)\n",
    "copy_battleship_dict = battleship_dict.copy()\n",
    "print ( copy_battleship_dict.items())\n",
    "copy_battleship_dict.clear()           # Another way to build an empty dictionary (from existing)\n",
    "print ( copy_battleship_dict.items())  # Dictionary is now empty\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Techniques"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "## Common case -- loop over the keys,\n",
    "## accessing each key/value\n",
    "for hull, name in battleship_dict.items():\n",
    "    print (hull, name)\n",
    "print (line_string)\n",
    "\n",
    "## Common case -- loop over the keys in sorted order,\n",
    "## accessing each key/value\n",
    "for key in sorted(battleship_dict.keys()):\n",
    "    print (key, battleship_dict[key])\n",
    "    \n",
    "## Common case -- Flexible lists\n",
    "##     Using a dictionary indexed by integers allows \"Offset\" indexes\n",
    "\n",
    "## Common case -- Sparse Matrix\n",
    "##     Using a dictionary indexed by integers or tuples allows a sparse matrix, with only useful positions populated.\n",
    "\n",
    "## Common case -- Avoiding Key Errors\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictionary Comprehensions\n",
    "Build or transform complex dictionaries with a single line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Dictionary comprehension to build a dictionary from separate lists\n",
    "hull_list = [\"BB50\", \"BB51\", \"BB52\", \"BB53\"]\n",
    "name_list = [\"Indiana\", \"Montana\",\"Carolina\",\"Iowa\"]\n",
    "phantom_ship_dict = {hull: name for hull, name in zip(hull_list, name_list)}\n",
    "print (phantom_ship_dict)\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Dictionary comprehension to transform a dictionary (Transpose in this example)\n",
    "destroyers_by_name_dict = {destroyer_dict[hull]: hull for hull in destroyer_dict}\n",
    "print(destroyers_by_name_dict)   # Note that results are not in any specific order!\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# Dictionary comprehension to build a dictionary from numeric algorithm\n",
    "cubes_dict = {i: i**3 for i in range(40) if i % 3 == 0}\n",
    "print (cubes_dict)      # Note that results are not in any specific order!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing Complex Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print ( battleship_dict.items())    \n",
    "print (battleship_dict_in_dict)\n",
    "print (repr(battleship_dict_in_dict))\n",
    "print (\"#\" + 65*'-')\n",
    "\n",
    "# import reprlib\n",
    "print (reprlib.repr(battleship_dict_in_dict))\n",
    "print (\"#\" + 65*'-')\n",
    "# import pprint    \n",
    "pprint.pprint (battleship_dict_in_dict, width=30)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sets in Python 3\n",
    "<a id=Sets></a>\n",
    "This demonstrates basic Python set management capabilities.\n",
    "\n",
    "Since set contents must be unique, sets cannont contain lists or dictionaries, but can contain tuples or sets.\n",
    "\n",
    "Sets are useful for filtering, but must be careful in some operations as set order is not definitive."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Generation\n",
    "Sets and Dictionaries both use the curly bracket symbols {}.  Sets behave somewhat like dictionaries with keys but without values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "<class 'frozenset'>\n",
      "['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']\n"
     ]
    }
   ],
   "source": [
    "#  \n",
    "tree_set = {}     #DANGER:  Create empty dict instead of empty set\n",
    "print (type(tree_set))\n",
    "\n",
    "tree_set = set() #Create empty set\n",
    "tree_set = {\"oak\", \"pine\", \"cypress\", \"cedar\", \"pecan\", \"walnut\"}\n",
    "shrub_set = set([\"juniper\", \"elderberry\"])\n",
    "# Forward Index = 0          1         2          3               4              5 \n",
    "# Reverse Index = -6          -5        -4         -3              -2             -1 \n",
    "\n",
    "# Frozen Sets cannot be changed\n",
    "binary_values = frozenset([0, 1])\n",
    "print (type(binary_values))\n",
    "print (dir(binary_values))\n",
    "#    a = binary_values.hash  #Why is this not working anymore?\n",
    "#    print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Variable Names as Objects and References\n",
    "Sets have the same \"variable assignment\" behavior as has been described above for the other Python objects.  \n",
    " \n",
    "For deeper insight:\n",
    "\n",
    "http://scottlobdell.me/2013/08/understanding-python-variables-as-pointers/\n",
    "\n",
    "http://henry.precheur.org/python/copy_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "79963528\n",
      "79963528\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut', 'shrub'}\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut', 'shrub'}\n",
      "79963528\n",
      "79963528\n",
      "#=================================================================\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "{'pecan', 'pine', 'cypress', 'cedar', 'walnut', 'oak'}\n",
      "78516520\n",
      "79964648\n",
      "#=================================================================\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "{'pecan', 'pine', 'cypress', 'cedar', 'walnut', 'oak'}\n",
      "79963528\n",
      "78516520\n",
      "#=================================================================\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "{'pecan', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "79964424\n",
      "79964648\n"
     ]
    }
   ],
   "source": [
    "a = {\"oak\", \"pine\", \"cypress\", \"cedar\", \"pecan\", \"walnut\"}\n",
    "b = a\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))               # They are the same object\n",
    "b.add(\"shrub\")\n",
    "print (a)                   # Where the heck did that shrub come from?\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))               # They are still the same object\n",
    "\n",
    "print (bar_string)\n",
    "#    If you want to make a COPY of another simple dictionary, here is one method:\n",
    "a = {\"oak\", \"pine\", \"cypress\", \"cedar\", \"pecan\", \"walnut\"}\n",
    "b = set(a)            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!\n",
    "\n",
    "print (bar_string)\n",
    "#    If you want to make a COPY of another simple dictionary, here is another method:\n",
    "a = {\"oak\", \"pine\", \"cypress\", \"cedar\", \"pecan\", \"walnut\"}\n",
    "b = a.copy()            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!\n",
    "\n",
    "print (bar_string)\n",
    "#    If you want to make a COPY of a complex dictionary, here is the deep method:\n",
    "import copy\n",
    "a = {\"oak\", \"pine\", \"cypress\", \"cedar\", \"pecan\", \"walnut\"}\n",
    "b = copy.deepcopy(a)            #This does the copy you are looking for.\n",
    "print (a)\n",
    "print (b)\n",
    "print (id(a))\n",
    "print (id(b))    #They are the NOT same object!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__iand__', '__init__', '__ior__', '__isub__', '__iter__', '__ixor__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']\n",
      "<class 'set'>\n",
      "[(1, 'pecan'), (2, 'oak'), (3, 'pine'), (4, 'cypress'), (5, 'cedar'), (6, 'walnut')]\n",
      "{(1, 'pecan'), (4, 'cypress'), (2, 'oak'), (5, 'cedar'), (6, 'walnut'), (3, 'pine')}\n"
     ]
    }
   ],
   "source": [
    "print ( dir(tree_set))\n",
    "print ( type(tree_set))\n",
    "\n",
    "# The enumerate function makes it possible to index a set, or create a set index tuples\n",
    "print (list(enumerate(tree_set,1)))\n",
    "\n",
    "print (set(enumerate(tree_set,1)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'pecan', 'pine', 'cypress', 'cedar', 'elderberry', 'juniper', 'walnut', 'oak'}\n",
      "{'pecan', 'juniper', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "{'juniper'}\n",
      "{'pecan', 'juniper', 'oak', 'pine', 'cypress', 'cedar', 'walnut'}\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "\n",
      " {3}\n",
      "\n",
      " {1, 2, 3, 4, 5}\n",
      "\n",
      " {1, 2}\n",
      "\n",
      " False\n",
      "\n",
      " True\n",
      "\n",
      " False\n",
      "\n",
      " True\n",
      "\n",
      " False\n",
      "\n",
      " True\n",
      "\n",
      " True\n"
     ]
    }
   ],
   "source": [
    "tree_set.add(\"juniper\")    \n",
    "tree_set.add(\"sycamore\")    \n",
    "tree_set.remove(\"sycamore\")    \n",
    "tree_set.discard(\"periwinkle\")    # Discard method doesn't complain    \n",
    "\n",
    "print (tree_set.union(shrub_set))  # Tree set is not modified by union\n",
    "print ( tree_set)\n",
    "\n",
    "print (tree_set.intersection(shrub_set))  # Tree set is not modified \n",
    "print ( tree_set)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print ('\\n ' + str( {1, 2, 3} & {3, 4, 5})) # & is AND for Intersection\n",
    "print ('\\n ' + str( {1, 2, 3} | {3, 4, 5})) # | is OR for Union\n",
    "print ('\\n ' + str( {1, 2, 3} - {3, 4, 5})) # - is for Difference (Not the same as Intersection)\n",
    "print ('\\n ' + str( {1, 2, 3} > {3, 4, 5})) # > is for Superset\n",
    "print ('\\n ' + str( {3, 4, 5, 6} > {3, 4, 5})) # > is for Superset\n",
    "print ('\\n ' + str( {1, 2, 3} < {3, 4, 5})) # < is for Subset\n",
    "print ('\\n ' + str( {3, 4} < {3, 4, 5})) # < is for Subset\n",
    "\n",
    "print ('\\n ' + str( {1, 2, 3} == {3, 4, 5})) \n",
    "print ('\\n ' + str( {1, 2, 3} == {1, 2, 3}))\n",
    "print ('\\n ' + str( {1, 2, 3} == {3, 2, 1}))  # ORder does not matter in set equality\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Set Comprehensions\n",
    "Build or transform complex sets with a single line of code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{2, 4, 6, 8, 12, 14}\n"
     ]
    }
   ],
   "source": [
    "even_prime_incr_set = {n+1 for n in [1,2,3,5,7,11,13] if (n+1)%2==0}\n",
    "print (even_prime_incr_set)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Printing Complex Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'p', 'x', 'i', 's', 'l', 'u', 'f', 'd', 'c', 't', 'e', 'o', 'g', 'r', 'a'}\n"
     ]
    }
   ],
   "source": [
    "mary_poppins = set('supercalifragilisticexpialidocious')\n",
    "print (mary_poppins)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Type Conversions\n",
    "<a id=TypeConversions></a>\n",
    "(Note:  The code below is dependent on running all the code above to establish preliminary objects.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Converstion to String"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "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": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "#=================================================================\n",
      "#-----------------------------------------------------------------\n",
      "\n",
      "#=================================================================\n",
      "\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*'-')\n",
    "print (\"\\n#\" + 65*'=')\n",
    "print (\"\\n#\" + 65*'-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Files\n",
    "<a id=Files></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Reading Text Files - SIMPLEST Single Pass Incremental Action Approach\n",
    " Read a line of text and process that line before moving to next line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start:\n",
      "5\n",
      "stop:\n",
      "10\n",
      "step:\n",
      "2\n",
      "high:\n",
      "yes\n",
      "low:\n",
      "no\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<function TextIOWrapper.close>"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filename = 'sample_config.txt'\n",
    "input_file = open(filename, 'r')\n",
    "for line in input_file:\n",
    "    # Here is where the work per line is performed\n",
    "    # In this case, the text line is split into words to be processed\n",
    "    words = line.split()     \n",
    "    for word in words:\n",
    "        word = word.lower()\n",
    "        print (word)       \n",
    "input_file.close"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mark Lutz \"Best Practice\" Single Pass Incremental Action Approach\n",
    "Mark Lutz' book describes this as the best practice approach, where there is no explicit file open and the file reading is incorporated into an Iterable.  Mark's example does not explicity close the file (?)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start:\n",
      "5\n",
      "stop:\n",
      "10\n",
      "step:\n",
      "2\n",
      "high:\n",
      "yes\n",
      "low:\n",
      "no\n"
     ]
    }
   ],
   "source": [
    "filename = 'sample_config.txt'\n",
    "for line in open(filename):\n",
    "    # Here is where the work per line is performed\n",
    "    # In this case, the text line is split into words to be processed\n",
    "    words = line.split()     \n",
    "    for word in words:\n",
    "        word = word.lower()\n",
    "        print (word)       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Reading Text Files - First ALTERNATIVE Single Pass Incremental Action Approach\n",
    " Read a line of text and process that line before moving to next line.\n",
    " \n",
    " Use of TRY to deal with file access problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start:\n",
      "5\n",
      "stop:\n",
      "10\n",
      "step:\n",
      "2\n",
      "high:\n",
      "yes\n",
      "low:\n",
      "no\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<function TextIOWrapper.close>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "filename = 'sample_config.txt'\n",
    "try:\n",
    "    input_file = open(filename, 'r')\n",
    "except:\n",
    "    s_abort()\n",
    "for line in input_file:\n",
    "    # Here is where the work per line is performed\n",
    "    # In this case, the text line is split into words to be processed\n",
    "    words = line.split()     \n",
    "    for word in words:\n",
    "        word = word.lower()\n",
    "        print (word)       \n",
    "input_file.close"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Reading Text Files - Second ALTERNATIVE Single Pass Incremental Action Approach\n",
    " Read a line of text and process that line before moving to next line.\n",
    " \n",
    " Use of WITH considered best practice for implied closure of file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start:\n",
      "5\n",
      "stop:\n",
      "10\n",
      "step:\n",
      "2\n",
      "high:\n",
      "yes\n",
      "low:\n",
      "no\n"
     ]
    }
   ],
   "source": [
    "filename = 'sample_config.txt'\n",
    "with open(filename, 'r') as input_file:\n",
    "    for line in input_file:\n",
    "        # Here is where the work per line is performed\n",
    "        # In this case, the text line is split into words to be processed\n",
    "        words = line.split()     \n",
    "        for word in words:\n",
    "            word = word.lower()\n",
    "            print (word)       "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Reading Text Files - SIMPLE Dual Pass Full Action Approach\n",
    "Read the entire file of text into a list of strings in first pass\n",
    "\n",
    "Process the list of strings in second pass\n",
    "\n",
    "Use of WITH considered best practice for implied closure of file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['start:   5', 'stop:    10', 'step:    2', 'high:    yes', 'low:     no']\n"
     ]
    }
   ],
   "source": [
    "filename = 'sample_config.txt'\n",
    "# First pass reads entire file\n",
    "# Use of WITH considered best practice for implied closure of file\n",
    "with open(filename, 'r') as infile:\n",
    "    data_string = infile.read()  # Read the contents of the file into single string.\n",
    "\n",
    "# Return a list of the lines, breaking at line boundaries.\n",
    "my_list = data_string.splitlines()\n",
    "\n",
    "# Second pass processes entire list\n",
    "print (my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Writing Text Files - First ALTERNATIVE Single Pass Incremental Action Approach\n",
    " Write a singe block of multi-line text\n",
    " \n",
    " Use of TRY to deal with file access problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "filename = 'example.txt'\n",
    "try:   \n",
    "    output_file = open(filename, 'w')\n",
    "except:\n",
    "    s_abort()        \n",
    "output_file.write(\"To write or not to write!\\nthat is the question!\\n\")\n",
    "output_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " ### Writing Log Files \n",
    "Open a file and append log entries.\n",
    " \n",
    "Use of TRY to deal with file access problems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "logname = 'log_example.txt'    \n",
    "try:   \n",
    "    log_file = open(logname, 'a')\n",
    "except:\n",
    "    s_abort()        \n",
    "log_file.write(\"------------------\\n Here is yet another entry\\n\")\n",
    "log_file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Binary Mode for Reading and Writing Binary Files\n",
    "There is no text in these files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bytes'>\n",
      "1000\n",
      ".....\n",
      "Terminado!\n"
     ]
    }
   ],
   "source": [
    "buffersize = 1000\n",
    "input_file = open('python_logo_small.gif','rb')\n",
    "output_file = open('test_graphic.gif', 'wb')\n",
    "buffer = input_file.read(buffersize)\n",
    "print (type(buffer))\n",
    "print (len(buffer))\n",
    "while len(buffer):\n",
    "    output_file.write(buffer)\n",
    "    print ('.', end='')\n",
    "    buffer = input_file.read(buffersize)\n",
    "print ()\n",
    "input_file.close\n",
    "output_file.close              # Bytes don't actually make it onto disk until CLOSE!\n",
    "print ('Terminado!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Exception Handling for Files\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": {
    "collapsed": false
   },
   "source": [
    "## Appendices\n",
    "<a id=\"Appendix\"></a>\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",
    "<a id=\"Idiot\"></a>\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
}