Learning Python 6 - Classes and Objects.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Learning Python - Notebook 6 - Classes and Objects\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 __Classes and Object Oriented Programming.__\n",
    "\n",
    "Please see the accompanying notebooks for complementary and more complex topics.\n",
    "\n",
    "I have also called upon some influence from some courses available on Lynda and YouTube.\n",
    "Bill Weiman offers a comprehensive simple start, that includes some best practices.\n",
    "Simon Allardice offers an overview understanding of object oriented programming and design.\n",
    "Corey Schafer provides a quick and dirct explanation of key 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 large enough that I've chosen a \"root, trunk, branch, and bark\" structure.  The \"root\" is marked as Cell Zero.  It contains a summary of all the IMPORT statements used throughout this notebook.  Cells can be executed from top to bottom.  The first cell in each section is independent, meaning that you can edit code in different sections without affecting others.  Some cells are subsidiary to and dependent upon the first \"base cell\" in that section being run beforehand.  Please consult the comments in each cell to determine whether it is a \"base\" or \"subsidiary\" cell.  A few cells are \"bark\" cells.  These are small \"one off\" cells whose content is unique to themselves.  They are not dependent on any other cells, have no subidiaries, and can be run at any time.\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",
    "* [Development Plan](#DevoPlan)\n",
    "* Class Coding Basics\n",
    "   - [Simplest Class](#Simplest)\n",
    "   - [Creating Classes](#CreatingClasses)\n",
    "   - [Using Initiator](#Constructor0)\n",
    "   - [Using Basic Accessors](#Accessors0)\n",
    "   - [Alternative Accessors 1: Keywords](#1Accessors0)\n",
    "   - [Alternative Accessors 2: Keywords with Defaults](#2Accessors0)\n",
    "   - [Alternative Accessors 3: \"Setter / Getter\"](#3Accessors0)\n",
    "   - [Alternative Accessors 4: Using Keyword Dictionary to Pass and Store Attributes](#4Accessors0)\n",
    "   - [Object Variables and Class Variables](#ObjVar0)\n",
    "   - [Inheritance](#Inhertance0)\n",
    "   - [Iterators](#Iterators0)\n",
    "   - [Looking Under The Hood](#Hood0)\n",
    "   - Creating a Method Independent of Class\n",
    "   - [What Is This Ship?](#WTS)\n",
    "* [More Realistic Examples](#Realist0)\n",
    "* [Class Coding Details]\n",
    "* [Overloading]\n",
    "* [Designing with Classes]\n",
    "* [Advanced Class Topics]\n",
    "   - [Extending Built-In Types]\n",
    "   - [New-Style Classes]\n",
    "   - [Static Methods]\n",
    "   - [Class Methods]\n",
    "   - [Super Functions]\n",
    "* [Appendix](#Appendix)\n",
    "   - Data on Ships\n",
    "   - [Jupyter Features and Controls](#Jupyter)\n",
    "   - [Tell Me I'm an Idiot!](#Idiot)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Development Plan\n",
    "<a id=\"DevoPlan\"></a>\n",
    "Based on other tutorials, here are the key aspects of OO to explore:\n",
    "- Encapsulation\n",
    "- Data Abstraction\n",
    "- Polymorphism\n",
    "- Inheritance\n",
    "- Descriptors\n",
    "- Class Method and Static Method\n",
    "- Class Properties\n",
    "- Python Special Methods\n",
    "\n",
    "Based on Lutz' chapter, here is an outline of stuff I need to explore.\n",
    "- Attribute Inheritance Search\n",
    "- Method Calls\n",
    "- Classes and Instances\n",
    "- Coding Class Trees\n",
    "- Operator Overloading\n",
    "- Polymorphism\n",
    "\n",
    "## Terminology\n",
    "Terminology / verminology!\n",
    "The bane of discussing and documenting Object Oriented concepts is the terminology.  Precision requires patience, both in writing with precision and in reading stuff written precisely.  Impatience leads to imprecision, and vice versa.  However, precision can get pedantic.\n",
    "If one is very fluid with the terminology, then the narrative text becomes demonstrably wrong.\n",
    "If one is very precise with the terminology, then the narative text becomes imprenetrable to the neophyte.\n",
    "I will attempt to steer a middle course, with some early fluidity for readability, and with growing precision for accuracy.\n",
    "\n",
    "Everything in Python is an object.  Objects have attributes.  A named object's attributes are usually the thing that comes after the \"dot\" that appears after the object's name.\n",
    "\n",
    "Attributes can be either properties or methods.  The use of the word \"property\" could eventually lead to confusion.  In most cases, \"property\" means the simple properties of an object.  However, there is also a Python decorator \"@property\" and there is a built-in function \"property().\"\n",
    "\n",
    "Simple properties are frequently referred to as variables, especially when referring to the concept of \"private variables.\"  I (and many other writers) may use the words \"variable\" and \"simple property\" interchangeably.\n",
    "\n",
    "## Major Learnings\n",
    "Explorations have highlighted a few of the most interesting things about OO with Python.\n",
    "- The user can add class properties outside of the class definition, and can create instances that \"inherit\" these properties.\n",
    "- Class variables and object variables are accessible without using class and object methods.\n",
    "- \"Under the hood,\" OO management is performed using common Python structures (dictionaires, etc.)  These structures are directly accessible without using class and object methods.\n",
    "- Coding Class Trees\n",
    "- Operator Overloading\n",
    "- Polymorphism\n",
    "\n",
    "## Getting Started\n",
    "Before we get going, let's import everything we need, check a few details, etc."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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",
    "\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": [
    "## Class Coding Basics\n",
    "### Simplest Class\n",
    "<a id=\"Simplest\"></a>\n",
    "The simplest class has no attributes, thus has neither properties nor methods.  The user can set class properties and can create instances from this simplest class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Texas\n",
      "1836\n",
      "Texas\n",
      "1836\n",
      "Bethesda\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "dict_keys(['city'])\n",
      "['city']\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "dict_keys(['__dict__', '__weakref__', 'year', 'state', '__module__', '__doc__'])\n",
      "['__dict__', '__weakref__', 'year', 'state', '__module__', '__doc__']\n"
     ]
    }
   ],
   "source": [
    "# The simplest Python class\n",
    "#  Defining a class with no methods and no properties.  It doesnt do anything.\n",
    "class nope:  pass\n",
    "\n",
    "# Defining class-level properties or attributes\n",
    "nope.state = 'Texas'\n",
    "nope.year = 1836\n",
    "\n",
    "print (nope.state)\n",
    "print (nope.year)\n",
    "# print (nope.city)\n",
    "\n",
    "# Creating instances, which inherit class-level properties\n",
    "sally = nope()\n",
    "sally.city = 'Bethesda'\n",
    "print (sally.state)\n",
    "print (sally.year)\n",
    "print (sally.city)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Object management is performed using standard Python structures, such as specific dictionaries.  (More later...)\n",
    "# Access object structure\n",
    "print (sally.__dict__.keys())\n",
    "print (list(sally.__dict__.keys()))\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Access class structure\n",
    "print (nope.__dict__.keys())\n",
    "print (list(nope.__dict__.keys()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating Classes\n",
    "<a id=\"CreatingClasses\"></a>\n",
    "Let's start with the very basics of creating Classes and simple objects from Classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ding\n",
      "Boom\n",
      "Bwahhhh\n",
      "Ding\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # These are Instance Methods\n",
    "    def ring(self):\n",
    "        print(self.bellSound)\n",
    "    def fire(self):\n",
    "        print(self.gunSound)\n",
    "\n",
    "USSTexas = Ship()\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple Method Calls\n",
    "Let's move on to some simple method calls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ding\n",
      "Boom\n",
      "Ding\n",
      "Boom\n"
     ]
    }
   ],
   "source": [
    "# Method Calls\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # These are Instance Methods\n",
    "    def ring(self):\n",
    "        print(self.bellSound)\n",
    "    def fire(self):\n",
    "        print(self.gunSound)\n",
    "\n",
    "# Method Call from Object    \n",
    "#   This approach calls the method on the object, and lets intepreter do the hierarchy tree traversal\n",
    "USSTexas = Ship()\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "\n",
    "# Method Call from Class on Object\n",
    "#    This approach goes straight to selecting the part of the hierarchy tree\n",
    "Ship.ring(USSTexas)\n",
    "Ship.fire(USSTexas)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Using Initiator\n",
    "<a id=\"Constructor0\"></a>\n",
    "Everybody calls _init_ the constructor, but that's wrong.  The object has already been constructed by the _new_ method.  By the the time that _init_ is called, the object has already been constructed.  So, this method should be called the __initiator__."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hull BB35 speaks \"Ding\" and shouts \"Boom\".\n",
      "Bwahhhh\n",
      "Ding\n",
      "Hull BB34 speaks \"Ding\" and shouts \"Boom\".\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "print_ship():  requires a Ship",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-13-1629772f00ec>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     48\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     49\u001b[0m \u001b[0mHMSBounty\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'Splash'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 50\u001b[0;31m \u001b[0mprint_ship\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mHMSBounty\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-13-1629772f00ec>\u001b[0m in \u001b[0;36mprint_ship\u001b[0;34m(o)\u001b[0m\n\u001b[1;32m     33\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mprint_ship\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mo\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     34\u001b[0m     \u001b[1;32mif\u001b[0m \u001b[1;32mnot\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mo\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mShip\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 35\u001b[0;31m         \u001b[1;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'print_ship():  requires a Ship'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     36\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Hull {} speaks \"{}\" and shouts \"{}\".'\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mhull_number\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mring\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mo\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfire\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     37\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: print_ship():  requires a Ship"
     ]
    }
   ],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Class methods\n",
    "    # This is the Initiator method.\n",
    "    def __init__(self, hull_number, length, width, draft, displacement):\n",
    "        self._hull_number = hull_number\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "        self._draft = draft\n",
    "        self._tonnage = displacement\n",
    "\n",
    "    # These are Instance Methods\n",
    "    # In particular, these are the \"GETTERS.\"  These are methods that extract an internal object variable.\n",
    "    #   Some programmers call these \"ACCESSORS.\"\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "    def ring(self):\n",
    "        return self.bellSound\n",
    "    \n",
    "    def fire(self):\n",
    "        return self.gunSound\n",
    "        \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "#  This function uses the ACCESSOR or GETTER methods.\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} speaks \"{}\" and shouts \"{}\".'.format(o.hull_number(), o.ring(), o.fire()) )\n",
    "\n",
    "# Exercising the Initiator / Constructor method \n",
    "USSNewYork = Ship('BB34', 400, 200, 100, 1200)          \n",
    "USSTexas = Ship('BB35', 400, 200, 100, 1200)\n",
    "\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "print_ship(USSTexas)\n",
    "\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?\n",
    "\n",
    "print_ship(USSNewYork)\n",
    "\n",
    "# Force type error for running external function that expects an object as input parameter.\n",
    "HMSBounty = 'Splash'\n",
    "print_ship(HMSBounty)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using Basic Accessors\n",
    "<a id=\"Accessors0\"></a>\n",
    "Basic Accessor methods provide a way to \"access\" or read object properties.  This example uses the initiator to set all the properties in a particular order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "400\n",
      "BB35\n",
      "Bwahhhh\n",
      "Ding\n",
      "BB35\n",
      "Hull BB34 sings Ding and speaks Boom.\n",
      "Hull BB60 sings Ding and speaks Boom.\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    def __init__(self, hull_num, length, width, draft, displacement):\n",
    "        self._hull_number = hull_num\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "        self._draft = draft\n",
    "        self._tonnage = displacement\n",
    "\n",
    "        # These are Instance Methods called Accessors\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "    def ring(self):\n",
    "        return self.bellSound\n",
    "    \n",
    "    def fire(self):\n",
    "        return self.gunSound\n",
    "        \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} sings {} and speaks {}.'.format(o.hull_number(), o.ring(), o.fire()) )        \n",
    "        \n",
    "USSNewYork = Ship('BB34', 400, 200, 100, 1200)          \n",
    "USSTexas = Ship('BB35', 400, 200, 100, 1200)\n",
    "\n",
    "# Exercising the Accesors\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._length)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._hull_number)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?\n",
    "\n",
    "bbh = USSTexas.hull_number()     # Methods called with following parentheses\n",
    "print (bbh)\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship('BB60', 800, 300, 150, 2400))   # Can call the Class directly to create new object.  Note CLASS name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Alternative Accessors 1: Keywords\n",
    "<a id=\"1Accessors0\"></a>\n",
    "This example uses the initiator to set all the properties, using keywords."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "400\n",
      "BB35\n",
      "Bwahhhh\n",
      "Ding\n",
      "BB35\n",
      "Hull BB34 sings Ding and speaks Boom.\n",
      "Hull BB60 sings Ding and speaks Boom.\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class with KWARGS\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the use of KWARGS in the Initiator.  Both the function definition line and in the code itself.\n",
    "    def __init__(self, **kwargs):\n",
    "        self._hull_number = kwargs['hull_num']\n",
    "        self._length = kwargs['length']\n",
    "        self._width = kwargs['width']\n",
    "        self._draft = kwargs['draft']\n",
    "        self._tonnage = kwargs['displacement']\n",
    "\n",
    "        # These are Instance Methods called Accessors\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "    def ring(self):\n",
    "        return self.bellSound\n",
    "    \n",
    "    def fire(self):\n",
    "        return self.gunSound\n",
    "        \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} sings {} and speaks {}.'.format(o.hull_number(), o.ring(), o.fire()) )        \n",
    "    \n",
    "# Note how the objects are defined with keywards since the Class constructor usess keywords and KWARGS        \n",
    "USSNewYork = Ship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Ship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._length)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._hull_number)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?\n",
    "bbh = USSTexas.hull_number()     # \n",
    "print (bbh)\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship(hull_num='BB60', length=800, width=300, draft=150, displacement=2400))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Alternative Accessors 2:  Keywords with Defaults\n",
    "<a id=\"2Accessors0\"></a>\n",
    "This example uses the initiator to set all the properties using keywords, as before.  However, this method incorporates defaults if the keyword property is not provided on input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BB35\n",
      "Hull BB34 sings Ding and speaks Boom.\n",
      "Hull BB62 sings Ding and speaks Boom.\n",
      "Hull BB60 sings Ding and speaks Boom.\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class with KWARGS and Default Value\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the use of KWARGS in the Initiator.  Both the function definition line and in the code itself.\n",
    "    def __init__(self, **kwargs):\n",
    "        self._hull_number = kwargs['hull_num'] if 'hull_num' in kwargs else 'BB60'\n",
    "        self._length = kwargs['length'] if 'length' in kwargs else 887\n",
    "        self._width = kwargs['width'] if 'width' in kwargs else 108\n",
    "        self._draft = kwargs['draft'] if 'draft' in kwargs else 29\n",
    "        self._tonnage = kwargs['displacement'] if 'displacement' in kwargs else 45000\n",
    "\n",
    "        # These are Instance Methods called Accessors\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "    def ring(self):\n",
    "        return self.bellSound\n",
    "    \n",
    "    def fire(self):\n",
    "        return self.gunSound\n",
    "        \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} sings {} and speaks {}.'.format(o.hull_number(), o.ring(), o.fire()) )        \n",
    "    \n",
    "# Note how the objects are defined with keywards since the Class constructor usess keywords and KWARGS        \n",
    "USSNewYork = Ship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Ship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "bbh = USSTexas.hull_number()     # \n",
    "print (bbh)\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship(hull_num='BB62', length=800, width=300, draft=150, displacement=2400))\n",
    "print_ship(Ship())       # Calling Class with no paramaters leads to use of defaults."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Alternative Accessors 3:  \"Setter / Getter\"\n",
    "<a id=\"3Accessors0\"></a>\n",
    "Some programmers like this best practice.  NOTE the different Accessors used with different variables than the above ones.\n",
    "Also note the use of the __STR__ method to enable an object to be simply called by PRINT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BB35\n",
      "Hull BB34 pushes 400 and pulls 1200.\n",
      "Hull BB60 pushes 800 and pulls 2400.\n",
      "Hull BB60 pushes 887 and pulls 45000.\n",
      "Hull BB35\n",
      "Hull BB34 pushes 395 and pulls 1200.\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class with KWARGS and GETTER / SETTER \n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the use of KWARGS in the Initiator.  Both the function definition line and in the code itself.\n",
    "    def __init__(self, **kwargs):\n",
    "        self._hull_number = kwargs['hull_num'] if 'hull_num' in kwargs else 'BB60'\n",
    "        self._length = kwargs['length'] if 'length' in kwargs else 887\n",
    "        self._width = kwargs['width'] if 'width' in kwargs else 108\n",
    "        self._draft = kwargs['draft'] if 'draft' in kwargs else 29\n",
    "        self._tonnage = kwargs['displacement'] if 'displacement' in kwargs else 45000\n",
    "\n",
    "        \n",
    "        # These \"Getter / Setter\" methods can be used to access or to set a property.\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        return self._hull_number\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        return self._length\n",
    "    \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        return self._tonnage\n",
    "    \n",
    "    # The string method enables an object to return a string\n",
    "        # This uses the Getter / Setter to access a property \n",
    "    def __str__(self):\n",
    "\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "    \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )        \n",
    "    \n",
    "# Note how the objects are defined with keywards since the Class constructor usess keywords and KWARGS        \n",
    "USSNewYork = Ship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Ship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "USSTexas.length()\n",
    "USSTexas.tonnage()\n",
    "bbh = USSTexas.hull_number()     # \n",
    "print (bbh)\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship(hull_num='BB60', length=800, width=300, draft=150, displacement=2400))\n",
    "print_ship(Ship())       # Calling Class with no paramaters leads to use of defaults.\n",
    "print (USSTexas)         # Just printing an object calls the __STR__ method\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "print_ship(USSNewYork)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Alternative Accessors 4:  Using Keyword Dictionary to Pass and Store Attributes\n",
    "<a id=\"4Accessors0\"></a>\n",
    "Some programmers like this best practice.  NOTE the different Accessors used with different variables than the above ones.\n",
    "Also note the use of the STR method to enable an object to be simply called by PRINT."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "400\n",
      "BB35\n",
      "Bwahhhh\n",
      "Ding\n",
      "Hull BB34 pushes 400 and pulls 1200.\n",
      "Hull BB60 pushes 800 and pulls 2400.\n",
      "Hull None pushes None and pulls None.\n",
      "Hull BB35\n",
      "Hull BB34 pushes 395 and pulls 1200.\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class with KWARGS feeding Attribute Dictionary.  Using separage GET and SET methods \n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the use of KWARGS in the Initiator.  Both the function definition line and in the code itself.\n",
    "    def __init__(self, **kwargs):\n",
    "        self.variables=kwargs\n",
    "                \n",
    "    # Need different \"Getter / Setter\" methods with the attribute dictionary.\n",
    "    def set_variable(self, key, value):\n",
    "        self.variables[key] = value\n",
    "        \n",
    "    def get_variable(self, key):\n",
    "        return self.variables.get(key, None)\n",
    "        \n",
    "\n",
    "    # The string method enables an object to return a string\n",
    "        # This uses the Getter / Setter to access a property \n",
    "    def __str__(self):\n",
    "\n",
    "        return 'Hull {}'.format(self.variables.get('hull_number'))\n",
    "\n",
    "    \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.get_variable('hull_number'), \n",
    "          o.get_variable('length'), o.get_variable('tonnage')) )        \n",
    "    \n",
    "# Note how the objects are defined with keywards since the Class constructor usess keywords and KWARGS        \n",
    "USSNewYork = Ship(hull_number='BB34', length=400, width=200, draft=100, tonnage=1200)          \n",
    "USSTexas = Ship(hull_number='BB35', length=400, width=200, draft=100, tonnage=1200)\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas.variables['length'])     # Direct access to object dictionary variable via object attribute.  Not recommended.\n",
    "print (USSTexas.get_variable('hull_number'))     # Direct access.  Doesn't work.\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?\n",
    "\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship(hull_number='BB60', length=800, width=300, draft=150, tonnage=2400))\n",
    "print_ship(Ship())       # Calling Class with no paramaters leads to use of defaults.\n",
    "print (USSTexas)         # Just printing an object calls the __STR__ method\n",
    "USSNewYork.set_variable('length', 395)   # Use of SET to set a property.\n",
    "print_ship(USSNewYork)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Object Variables and Class Variables\n",
    "<a id=\"ObjVar0\"></a>\n",
    "Class variables are visible to all objects in the class, and can be access via class names or instance names.\n",
    "\n",
    "Instance variables are specific to an instance.  They should not be access directly, but rather via methods.  Instance variables can frequently be accessed directly, but this is consider inadvisable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "Ding\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "400\n",
      "BB35\n",
      "BB35\n",
      "Hull BB34 pushes 400 and pulls 1200.\n",
      "Hull BB60 pushes 800 and pulls 2400.\n",
      "Hull BB60 pushes 887 and pulls 45000.\n",
      "Hull BB35\n",
      "Hull BB34 pushes 395 and pulls 1200.\n"
     ]
    }
   ],
   "source": [
    "#  \n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  \n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        self._hull_number = kwargs['hull_num'] if 'hull_num' in kwargs else 'BB60'\n",
    "        self._length = kwargs['length'] if 'length' in kwargs else 887\n",
    "        self._width = kwargs['width'] if 'width' in kwargs else 108\n",
    "        self._draft = kwargs['draft'] if 'draft' in kwargs else 29\n",
    "        self._tonnage = kwargs['displacement'] if 'displacement' in kwargs else 45000\n",
    "\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        return self._hull_number\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        return self._length\n",
    "    \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        return self._tonnage\n",
    "    \n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "    \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )        \n",
    "    \n",
    "USSNewYork = Ship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Ship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "\n",
    "# Accessing class variables\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Accessing object / instance variables\n",
    "print (USSTexas._length)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._hull_number)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "USSTexas.length()\n",
    "USSTexas.tonnage()\n",
    "bbh = USSTexas.hull_number()     # \n",
    "print (bbh)\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship(hull_num='BB60', length=800, width=300, draft=150, displacement=2400))\n",
    "print_ship(Ship())       # Calling Class with no paramaters leads to use of defaults.  Note \"re-initiation\"\n",
    "print (USSTexas)         # Just printing an object calls the __STR__ method\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "print_ship(USSNewYork)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "Ding\n",
      "TaTaTaTATABlahh!\n",
      "Bwahhhh\n",
      "Bwahhhh\n",
      "Ding\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Ship alerts!:   TaTaTaTATABlahh! Ding\n",
      "Ship alerts!:   Bwahhhh Ding\n",
      "Ship alerts!:   TaTaTaTATABlahh! Ding\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "<built-in method __dir__ of Ship object at 0x0000000004CCEAC8>\n",
      "mappingproxy({'__dict__': <attribute '__dict__' of 'Ship' objects>,\n",
      "              '__doc__': 'Common base class for ships',\n",
      "              '__init__': <function Ship.__init__ at 0x0000000004CC2EA0>,\n",
      "              '__module__': '__main__',\n",
      "              '__str__': <function Ship.__str__ at 0x0000000004CC2378>,\n",
      "              '__weakref__': <attribute '__weakref__' of 'Ship' objects>,\n",
      "              'bellSound': 'Ding',\n",
      "              'gunSound': 'Boom',\n",
      "              'hornSound': 'Bwahhhh',\n",
      "              'hull_number': <function Ship.hull_number at 0x0000000004CC2B70>,\n",
      "              'length': <function Ship.length at 0x0000000004CC2AE8>,\n",
      "              'sounds': <function Ship.sounds at 0x0000000004CC20D0>,\n",
      "              'tonnage': <function Ship.tonnage at 0x0000000004CC2158>})\n",
      "{'_draft': 100,\n",
      " '_hull_number': 'BB35',\n",
      " '_length': 400,\n",
      " '_tonnage': 1200,\n",
      " '_width': 200,\n",
      " 'hornSound': 'TaTaTaTATABlahh!'}\n",
      "{'_draft': 100,\n",
      " '_hull_number': 'BB34',\n",
      " '_length': 400,\n",
      " '_tonnage': 1200,\n",
      " '_width': 200}\n"
     ]
    }
   ],
   "source": [
    "#  Focus on Class Attributes / Variables\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    def __init__(self, **kwargs):\n",
    "        self._hull_number = kwargs['hull_num'] if 'hull_num' in kwargs else 'BB60'\n",
    "        self._length = kwargs['length'] if 'length' in kwargs else 887\n",
    "        self._width = kwargs['width'] if 'width' in kwargs else 108\n",
    "        self._draft = kwargs['draft'] if 'draft' in kwargs else 29\n",
    "        self._tonnage = kwargs['displacement'] if 'displacement' in kwargs else 45000\n",
    "\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        return self._hull_number\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        return self._length\n",
    "    \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        return self._tonnage\n",
    "    \n",
    "    # Note that self.hornSound can bind to Class attribute or object attribute\n",
    "    def sounds(self):\n",
    "        print ('Ship alerts!:  ', self.hornSound,  self.bellSound)  \n",
    "    \n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "    \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )        \n",
    "    \n",
    "USSNewYork = Ship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Ship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "\n",
    "# Accessing class variables\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute. \n",
    "\n",
    "USSTexas.hornSound = 'TaTaTaTATABlahh!'\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSNewYork.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.hornSound)         # Direct access to class variable via class attribute. \n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute. \n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "USSTexas.sounds()              # Using the new method introduced here as an object method\n",
    "USSNewYork.sounds()\n",
    "Ship.sounds(USSTexas)          # Using the new method introduced here as a class method on an object\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# An early look under the hood at the object management dictionary and its contents with these object & class variables.\n",
    "pprint (USSTexas.__dir__)\n",
    "pprint (Ship.__dict__)          # Note class attribute hornSound\n",
    "pprint (USSTexas.__dict__)      # Note unique object attribute hornSound\n",
    "pprint (USSNewYork.__dict__)    # Note absence of object attribute hornSound\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Methods\n",
    "<a id=\"Methods0\"></a>\n",
    "Using Class Methods, Object Methods, Static Methods, and Abstract Methods.\n",
    "\n",
    "Class Methods are tied to class and not tied to objects.  Useful as alternate constructors.\n",
    "\n",
    "Static Methods are part of the class, but don't really know anything about the class.  Static Methods are not tied to objects.  Static methods work inside the Class scope, so don't require using external functions with external scope.  Static Methods are methods/functions that only operate on the parameters provided to them.  Some poorly conceived class methods should be static methods.  Static methods simplify some issues of subclasses and inheritance, which we may look at later.\n",
    "\n",
    "Abstract Methods are used in base classes.  They can name methods that must be defined / overloaded in all derived classes.  Abstract Methods require importing the Abstract Base Class module, which can present hidden dangers to the uninformed when working with inheritence.  Work with Abstract Classes waits till after basic exploration of inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "Ding\n",
      "TaTaTaTATABlahh!\n",
      "Bwahhhh\n",
      "Bwahhhh\n",
      "Ding\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "TaTaTaTATABlahh!\n",
      "RootTootToot\n",
      "RootTootToot\n",
      "Ding\n",
      "RootTootToot\n",
      "<built-in method __dir__ of Ship object at 0x0000000004CD34A8>\n",
      "mappingproxy({'__dict__': <attribute '__dict__' of 'Ship' objects>,\n",
      "              '__doc__': 'Common base class for ships',\n",
      "              '__init__': <function Ship.__init__ at 0x0000000004C6F158>,\n",
      "              '__module__': '__main__',\n",
      "              '__str__': <function Ship.__str__ at 0x0000000004C6F268>,\n",
      "              '__weakref__': <attribute '__weakref__' of 'Ship' objects>,\n",
      "              'bellSound': 'Ding',\n",
      "              'gunSound': 'Boom',\n",
      "              'hornSound': 'RootTootToot',\n",
      "              'hull_number': <function Ship.hull_number at 0x0000000004C6F2F0>,\n",
      "              'length': <function Ship.length at 0x0000000004C6F048>,\n",
      "              'set_horn': <classmethod object at 0x0000000004CD3358>,\n",
      "              'shipCount': 0,\n",
      "              'shipInventory': [],\n",
      "              'sounds': <function Ship.sounds at 0x0000000004C6F378>,\n",
      "              'time_bells': <staticmethod object at 0x0000000004CD34E0>,\n",
      "              'tonnage': <function Ship.tonnage at 0x0000000004C6F1E0>})\n",
      "{'_draft': 100,\n",
      " '_hull_number': 'BB35',\n",
      " '_length': 400,\n",
      " '_tonnage': 1200,\n",
      " '_width': 200,\n",
      " 'hornSound': 'TaTaTaTATABlahh!'}\n",
      "{'_draft': 100,\n",
      " '_hull_number': 'BB34',\n",
      " '_length': 400,\n",
      " '_tonnage': 1200,\n",
      " '_width': 200}\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "#  Focus on Methods\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "#  These are Object Methods    \n",
    "    # Note the use of KWARGS in the Initiator.  Both the function definition line and in the code itself.\n",
    "    def __init__(self, **kwargs):\n",
    "        self._hull_number = kwargs['hull_num'] if 'hull_num' in kwargs else 'BB60'\n",
    "        self._length = kwargs['length'] if 'length' in kwargs else 887\n",
    "        self._width = kwargs['width'] if 'width' in kwargs else 108\n",
    "        self._draft = kwargs['draft'] if 'draft' in kwargs else 29\n",
    "        self._tonnage = kwargs['displacement'] if 'displacement' in kwargs else 45000\n",
    "\n",
    "        \n",
    "        # These \"Getter / Setter\" methods can be used to access or to set a property.\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        return self._hull_number\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        return self._length\n",
    "    \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        return self._tonnage\n",
    "    \n",
    "    # Note that self.hornSound can bind to Class attribute or object attribute\n",
    "    def sounds(self):\n",
    "        print ('Ship alerts!:  ', self.hornSound,  self.bellSound)  \n",
    "    \n",
    "    # The string method enables an object to return a string\n",
    "        # This uses the Getter / Setter to access a property \n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "#  These are Class Methods        \n",
    "    @classmethod\n",
    "    def set_horn(cls, sound):\n",
    "        cls.hornSound = sound\n",
    "        \n",
    "#  These are Static Method\n",
    "    @staticmethod\n",
    "    \n",
    "    # This method calculates the current time in bells.  (Or pretends to...)\n",
    "    def time_bells():\n",
    "        # On this ship, the time is always 4 bells\n",
    "        t = int(5-1)\n",
    "        return t        \n",
    "    \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )        \n",
    "    \n",
    "# Note how the objects are defined with keywards since the Class constructor usess keywords and KWARGS        \n",
    "USSNewYork = Ship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Ship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "\n",
    "# Accessing class variables\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute. \n",
    "\n",
    "USSTexas.hornSound = 'TaTaTaTATABlahh!'\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSNewYork.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.hornSound)         # Direct access to class variable via class attribute. \n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute. \n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "Ship.set_horn('RootTootToot')  # Use CLASS METHOD to change class attribute\n",
    "USSTexas.hornSound = 'TaTaTaTATABlahh!'\n",
    "USSNevada = Ship(hull_num='BB36', length=410, width=210, draft=110, displacement=1300)\n",
    "print (USSTexas.hornSound)     # Check object attribute set uniquely\n",
    "print (USSNewYork.hornSound)     # Check object attribute set to class attribute\n",
    "print (Ship.hornSound)         # Check class attribute \n",
    "print (Ship.bellSound)         # Check class attribute \n",
    "print (USSNevada.hornSound)     # \n",
    "\n",
    "pprint (USSTexas.__dir__)\n",
    "pprint (Ship.__dict__)          # Note class attribute hornSound\n",
    "pprint (USSTexas.__dict__)      # Note unique object attribute hornSound\n",
    "pprint (USSNewYork.__dict__)    # Note absence of object attribute hornSound\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (USSNewYork.time_bells())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Inheritance\n",
    "<a id=\"Inheritance0\"></a>\n",
    "Accessing Class variables via instance names.  Accessing instance variables directly, and inapporpriately.\n",
    "Note use of SUPER, which is discouraged by Lutz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hull BB34 pushes 400 and pulls 1200.\n",
      "Hull BB35\n",
      "Hull BB34 pushes 395 and pulls 1200.\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Warship' object has no attribute 'target'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-278c84a0ff23>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     65\u001b[0m \u001b[0mprint_ship\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mUSSNewYork\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     66\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m---> 67\u001b[0;31m \u001b[0mUSSNewYork\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mtarget\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Iwo Jima'\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# Call child class method\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     68\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m     69\u001b[0m \u001b[0mprint\u001b[0m \u001b[1;33m(\u001b[0m\u001b[0mUSSNewYork\u001b[0m \u001b[1;32mis\u001b[0m \u001b[0mWarship\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAttributeError\u001b[0m: 'Warship' object has no attribute 'target'"
     ]
    }
   ],
   "source": [
    "#  First simple method inheritance\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the removal of default values.  Use of defaults in a base class can be a bad idea.\n",
    "    def __init__(self, **kwargs):\n",
    "        if 'hull_num' in kwargs: self._hull_number = kwargs['hull_num'] \n",
    "            \n",
    "        if 'length' in kwargs: self._length = kwargs['length'] \n",
    "        if 'width' in kwargs: self._width = kwargs['width'] \n",
    "        if 'draft' in kwargs: self._draft = kwargs['draft'] \n",
    "        if 'displacement' in kwargs: self._tonnage = kwargs['displacement'] \n",
    "        \n",
    "    # The \"Getter / Setter\" methods are more complex for base class\n",
    "    #   Need to check to see if a value is set\n",
    "    #   This is my own GETTER / SETTER code, deprecated from the \"Best Case\" example\n",
    "    #   Code deprecated because I'm not setting an object type at this level of class hierarchy.\n",
    "    #   The example had code to check for a \"type\" parameter, and then delete it from the KWARGS passed to the parent constrctr.\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        try: return self._hull_number\n",
    "        except AttributeError:  return None\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        try: return self._length\n",
    "        except AttributeError:  return None \n",
    "        \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        try: return self._tonnage\n",
    "        except AttributeError:  return None   \n",
    "\n",
    "    # The string method enables an object to return a string\n",
    "        # This uses the Getter / Setter to access a property \n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )         \n",
    "    \n",
    "class Warship(Ship):\n",
    "    pass    # In this example, the subordinate classes don't do anything\n",
    "\n",
    "class Tanker(Ship):\n",
    "    pass    # In this example, the subordinate classes don't do anything\n",
    "    \n",
    "    \n",
    "      \n",
    "USSNewYork = Warship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Warship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "HMASSirius = Tanker(hull_num='AOR-34', length=420, width=200, draft=100, displacement=1200)\n",
    "\n",
    "print_ship(USSNewYork)\n",
    "print (USSTexas)         # Just printing an object calls the __STR__ method\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "print_ship(USSNewYork)\n",
    "\n",
    "USSNewYork.target('Iwo Jima')  # Call child class method\n",
    "\n",
    "print (USSNewYork is Warship)\n",
    "print (USSNewYork is Warship())\n",
    "print (USSTexas is Warship)\n",
    "print (USSNewYork is Ship)\n",
    "\n",
    "print (isinstance(USSNewYork, Warship))\n",
    "print (isinstance(USSTexas, Warship))\n",
    "print (isinstance(USSNewYork, Ship))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hull BB34 pushes 400 and pulls 1200.\n",
      "Hull BB35\n",
      "Hull BB34 pushes 395 and pulls 1200.\n",
      "Now targetting Iwo Jima\n",
      "False\n",
      "False\n",
      "False\n",
      "False\n",
      "True\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "#  Building inheritance, including use of SUPER in construction\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the removal of default values.  Use of defaults in a base class cn be a bad idea.\n",
    "    def __init__(self, **kwargs):\n",
    "        if 'hull_num' in kwargs: self._hull_number = kwargs['hull_num'] \n",
    "            \n",
    "        if 'length' in kwargs: self._length = kwargs['length'] \n",
    "        if 'width' in kwargs: self._width = kwargs['width'] \n",
    "        if 'draft' in kwargs: self._draft = kwargs['draft'] \n",
    "        if 'displacement' in kwargs: self._tonnage = kwargs['displacement'] \n",
    "        \n",
    "    # The \"Getter / Setter\" methods are more complex for base class\n",
    "    #   Need to check to see if a value is set\n",
    "    #   This is my own GETTER / SETTER code, deprecated from the \"Best Case\" example\n",
    "    #   Code deprecated because I'm not setting an object type at this level of class hierarchy.\n",
    "    #   The example had code to check for a \"type\" parameter, and then delete it from the KWARGS passed to the parent constrctr.\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        try: return self._hull_number\n",
    "        except AttributeError:  return None\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        try: return self._length\n",
    "        except AttributeError:  return None \n",
    "        \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        try: return self._tonnage\n",
    "        except AttributeError:  return None   \n",
    "\n",
    "    # The string method enables an object to return a string\n",
    "        # This uses the Getter / Setter to access a property \n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )         \n",
    "    \n",
    "class Warship(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "    # Child class gets an additional method above those of base class    \n",
    "    def target(self, t):    \n",
    "        print ('Now targetting', t)\n",
    "        \n",
    "class Tanker(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    \n",
    "      \n",
    "USSNewYork = Warship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Warship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "HMASSirius = Tanker(hull_num='AOR-34', length=420, width=200, draft=100, displacement=1200)\n",
    "\n",
    "print_ship(USSNewYork)\n",
    "print (USSTexas)         # Just printing an object calls the __STR__ method\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "print_ship(USSNewYork)\n",
    "\n",
    "USSNewYork.target('Iwo Jima')  # Call child class method\n",
    "\n",
    "print (USSNewYork is Warship)\n",
    "print (USSNewYork is Warship())\n",
    "print (USSTexas is Warship)\n",
    "print (USSNewYork is Ship)\n",
    "\n",
    "print (isinstance(USSNewYork, Warship))\n",
    "print (isinstance(USSTexas, Warship))\n",
    "print (isinstance(USSNewYork, Ship))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Displaying Class Information\n",
    "The STR method is used to display class information for users.  The goal of STR method is to be readable.\n",
    "\n",
    "The REPR method is used to display class information for programmers.  The goal of REPR is to be unambigious.  In advanced cases, it would be desirous that the output of REPR could feed EVAL, and could be used to recreate the object.\n",
    "\n",
    "The HELP function is used to display class details, primarily for diagnostic purposes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hull BB34 pushes 400 and pulls 1200.\n",
      "Hull BB35\n",
      "Hull BB34 pushes 395 and pulls 1200.\n",
      "Hull BB34\n",
      "Hull BB34\n",
      "Now targetting Iwo Jima\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Help on Warship in module __main__ object:\n",
      "\n",
      "class Warship(Ship)\n",
      " |  Common base class for ships\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Warship\n",
      " |      Ship\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  target(self, t)\n",
      " |      # Child class gets an additional method above those of base class\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Ship:\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  hull_number(self, h=None)\n",
      " |      # The \"Getter / Setter\" methods are more complex for base class\n",
      " |  \n",
      " |  length(self, l=None)\n",
      " |  \n",
      " |  tonnage(self, t=None)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Ship:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Ship:\n",
      " |  \n",
      " |  bellSound = 'Ding'\n",
      " |  \n",
      " |  gunSound = 'Boom'\n",
      " |  \n",
      " |  hornSound = 'Bwahhhh'\n",
      "\n",
      "None\n",
      "Help on class Warship in module __main__:\n",
      "\n",
      "class Warship(Ship)\n",
      " |  Common base class for ships\n",
      " |  \n",
      " |  Method resolution order:\n",
      " |      Warship\n",
      " |      Ship\n",
      " |      builtins.object\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __init__(self, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  target(self, t)\n",
      " |      # Child class gets an additional method above those of base class\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Methods inherited from Ship:\n",
      " |  \n",
      " |  __repr__(self)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __str__(self)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  hull_number(self, h=None)\n",
      " |      # The \"Getter / Setter\" methods are more complex for base class\n",
      " |  \n",
      " |  length(self, l=None)\n",
      " |  \n",
      " |  tonnage(self, t=None)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors inherited from Ship:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes inherited from Ship:\n",
      " |  \n",
      " |  bellSound = 'Ding'\n",
      " |  \n",
      " |  gunSound = 'Boom'\n",
      " |  \n",
      " |  hornSound = 'Bwahhhh'\n",
      "\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "#  Building inheritance, as before\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Note the removal of default values.  Use of defaults in a base class cn be a bad idea.\n",
    "    def __init__(self, **kwargs):\n",
    "        if 'hull_num' in kwargs: self._hull_number = kwargs['hull_num'] \n",
    "            \n",
    "        if 'length' in kwargs: self._length = kwargs['length'] \n",
    "        if 'width' in kwargs: self._width = kwargs['width'] \n",
    "        if 'draft' in kwargs: self._draft = kwargs['draft'] \n",
    "        if 'displacement' in kwargs: self._tonnage = kwargs['displacement'] \n",
    "        \n",
    "    # The \"Getter / Setter\" methods are more complex for base class\n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        try: return self._hull_number\n",
    "        except AttributeError:  return None\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        try: return self._length\n",
    "        except AttributeError:  return None \n",
    "        \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        try: return self._tonnage\n",
    "        except AttributeError:  return None   \n",
    "\n",
    "    # The string method enables an object to return a string\n",
    "        # This uses the Getter / Setter to access a property \n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "    def __repr__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "    \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )         \n",
    "    \n",
    "class Warship(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "    # Child class gets an additional method above those of base class    \n",
    "    def target(self, t):    \n",
    "        print ('Now targetting', t)\n",
    "        \n",
    "class Tanker(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "         \n",
    "USSNewYork = Warship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Warship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "HMASSirius = Tanker(hull_num='AOR-34', length=420, width=200, draft=100, displacement=1200)\n",
    "\n",
    "print_ship(USSNewYork)\n",
    "print (USSTexas)         # Just printing an object calls the __STR__ method\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "print_ship(USSNewYork)\n",
    "\n",
    "print (str(USSNewYork))\n",
    "print (repr(USSNewYork))\n",
    "\n",
    "USSNewYork.target('Iwo Jima')  # Call child class method\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (help(USSNewYork))       # Call HELP on object\n",
    "print (help(Warship))          # Call HELP on class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dnalleveL\n"
     ]
    }
   ],
   "source": [
    "# Inheritance with overwriting.  Is this overloading?\n",
    "class ReverseString(str):     # This class inherits from the built in class STR (since everything in PYthon is an object)\n",
    "    def __str__(self):\n",
    "        return self[::-1]\n",
    "    \n",
    "string_object = ReverseString('Levelland')\n",
    "print (string_object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Iterators\n",
    "<a id=\"Iterators0\"></a>\n",
    "Using iteration methods with classes.  This example is more of a generator, because it generates a sequence of numbers, where a true iterator would work with a container."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 \n",
      "1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  "
     ]
    }
   ],
   "source": [
    "# A stripped down version of an iterator.  A real one would include validity checking code for the inputs.\n",
    "class range_inclusive:\n",
    "    def __init__(self, *args):\n",
    "        self._start = 0       # Set starting point for range\n",
    "        self._schlep = 1      # Set step size for range count\n",
    "        # Validity checking code for *args would go here.\n",
    "        (self._start, self._stop, self._schlep) = args\n",
    "        \n",
    "        self._next = self._start    # Set starting point for count\n",
    "        \n",
    "    # The __iter__ method makes this an iterator.  Don't obsess about the syntax.   This syntax makes this an iterator.    \n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    # The __next__ method is key to iterator.  A loop code structure will look to use this method.\n",
    "    def __next__(self):\n",
    "        if self._next > self._stop:\n",
    "            raise StopIteration\n",
    "        else:\n",
    "            _arr = self._next\n",
    "            self._next += self._schlep\n",
    "            return _arr\n",
    "for i in range(15):\n",
    "    print (i, end=' ')\n",
    "print()\n",
    "for j in range_inclusive(1, 15, 1):\n",
    "    print (j, end='  ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Looking Under The Hood\n",
    "<a id=\"Hood0\"></a>\n",
    "Looking at some of the conventional and accessible structures that make Classes and Objects possible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now targetting Iwo Jima\n",
      "\n",
      "#=================================================================\n",
      "\n",
      "# Superclass Dictionary-------------------------\n",
      "mappingproxy({'__dict__': <attribute '__dict__' of 'Ship' objects>,\n",
      "              '__doc__': 'Common base class for ships',\n",
      "              '__init__': <function Ship.__init__ at 0x0000000004CF8488>,\n",
      "              '__module__': '__main__',\n",
      "              '__str__': <function Ship.__str__ at 0x0000000004CF82F0>,\n",
      "              '__weakref__': <attribute '__weakref__' of 'Ship' objects>,\n",
      "              'bellSound': 'Ding',\n",
      "              'gunSound': 'Boom',\n",
      "              'hornSound': 'Bwahhhh',\n",
      "              'hull_number': <function Ship.hull_number at 0x0000000004CF8F28>,\n",
      "              'length': <function Ship.length at 0x0000000004CF8EA0>,\n",
      "              'tonnage': <function Ship.tonnage at 0x0000000004CF8E18>})\n",
      "'Ship'\n",
      "(<class 'object'>,)\n",
      "'Common base class for ships'\n",
      "'__main__'\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "\n",
      "# Subclass Dictionary-------------------------\n",
      "mappingproxy({'__doc__': None,\n",
      "              '__init__': <function Warship.__init__ at 0x0000000004CF8378>,\n",
      "              '__module__': '__main__',\n",
      "              'target': <function Warship.target at 0x0000000004CF8158>})\n",
      "'Warship'\n",
      "(<class '__main__.Ship'>,)\n",
      "None\n",
      "'__main__'\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "\n",
      "# Subclass Dictionary-------------------------\n",
      "mappingproxy({'__doc__': 'Derived class for tanker ships',\n",
      "              '__init__': <function Tanker.__init__ at 0x0000000004CF8D90>,\n",
      "              '__module__': '__main__'})\n",
      "'Tanker'\n",
      "(<class '__main__.Ship'>,)\n",
      "'Derived class for tanker ships'\n",
      "'__main__'\n",
      "\n",
      "#=================================================================\n",
      "\n",
      "# Objects Dictionary-------------------------\n",
      "{'_draft': 100,\n",
      " '_hull_number': 'BB35',\n",
      " '_length': 400,\n",
      " '_tonnage': 1200,\n",
      " '_width': 200}\n",
      "None\n",
      "'__main__'\n",
      "<class '__main__.Warship'>\n",
      "\n",
      "#=================================================================\n",
      "400\n",
      "400\n",
      "\n",
      "#=================================================================\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "#  Build super-class, as before\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Build super-class methods.\n",
    "    def __init__(self, **kwargs):\n",
    "        if 'hull_num' in kwargs: self._hull_number = kwargs['hull_num'] \n",
    "            \n",
    "        if 'length' in kwargs: self._length = kwargs['length'] \n",
    "        if 'width' in kwargs: self._width = kwargs['width'] \n",
    "        if 'draft' in kwargs: self._draft = kwargs['draft'] \n",
    "        if 'displacement' in kwargs: self._tonnage = kwargs['displacement'] \n",
    "        \n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        try: return self._hull_number\n",
    "        except AttributeError:  return None\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        try: return self._length\n",
    "        except AttributeError:  return None \n",
    "        \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        try: return self._tonnage\n",
    "        except AttributeError:  return None   \n",
    "\n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "# Build unrelated independent function external to the classes\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )         \n",
    "    \n",
    "# Define subclasses, with methods    \n",
    "class Warship(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "    # Child class gets an additional method above those of base class    \n",
    "    def target(self, t):    \n",
    "        print ('Now targetting', t)\n",
    "        \n",
    "class Tanker(Ship):\n",
    "    'Derived class for tanker ships'\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    \n",
    "# Create instances of objects based on both subclasses      \n",
    "USSNewYork = Warship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Warship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "HMASSirius = Tanker(hull_num='AOR-34', length=420, width=200, draft=100, displacement=1200)\n",
    "\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "\n",
    "USSNewYork.target('Iwo Jima')  # Call child class method\n",
    "\n",
    "print (\"\\n#\" + 65*'=')\n",
    "\n",
    "# Accessing Class attributes directly.\n",
    "#   These are the Predefined Class Attributes (though some may be set to NONE)\n",
    "#    Superclass\n",
    "print (\"\\n# Superclass Dictionary\" + 25*'-')\n",
    "pprint (Ship.__dict__)   # __dict is class namespace (aka dictionary of attributes\n",
    "pprint (Ship.__name__)   # __name is class name\n",
    "pprint (Ship.__bases__)  # __bases is tuple containing the base classes\n",
    "pprint (Ship.__doc__)    # __doc is the class' documentation string\n",
    "pprint (Ship.__module__) # __module is the name of the\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (\"\\n# Subclass Dictionary\" + 25*'-')\n",
    "#    Subclass\n",
    "pprint (Warship.__dict__)\n",
    "pprint (Warship.__name__)\n",
    "pprint (Warship.__bases__)\n",
    "pprint (Warship.__doc__)\n",
    "pprint (Warship.__module__)\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (\"\\n# Subclass Dictionary\" + 25*'-')\n",
    "pprint (Tanker.__dict__)\n",
    "pprint (Tanker.__name__)\n",
    "pprint (Tanker.__bases__)\n",
    "pprint (Tanker.__doc__)\n",
    "pprint (Tanker.__module__)\n",
    "print (\"\\n#\" + 65*'=')\n",
    "\n",
    "print (\"\\n# Objects Dictionary\" + 25*'-')\n",
    "pprint(USSTexas.__dict__)\n",
    "# pprint(USSTexas.__name__)  # Objects don't have __name attribute\n",
    "# pprint(USSTexas.__bases__) # Objects don't have _bases\n",
    "pprint(USSTexas.__doc__)\n",
    "pprint(USSTexas.__module__)\n",
    "pprint(USSTexas.__class__)\n",
    "print (\"\\n#\" + 65*'=')\n",
    "\n",
    "# Accessing Object attributes directly or via attribute dictionary.\n",
    "#   These are the Predefined Class Attributes (though some may be set to NONE)\n",
    "print(USSTexas.__dict__['_length'])\n",
    "print(USSTexas._length)\n",
    "print (\"\\n#\" + 65*'=')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now targetting Iwo Jima\n",
      "\n",
      "#=================================================================\n",
      "\n",
      "# Superclass Distionary-------------------------\n",
      "mappingproxy({'__dict__': <attribute '__dict__' of 'Ship' objects>,\n",
      "              '__doc__': 'Common base class for ships',\n",
      "              '__init__': <function Ship.__init__ at 0x0000000004D0F950>,\n",
      "              '__module__': '__main__',\n",
      "              '__str__': <function Ship.__str__ at 0x0000000004D0FEA0>,\n",
      "              '__weakref__': <attribute '__weakref__' of 'Ship' objects>,\n",
      "              'bellSound': 'Ding',\n",
      "              'gunSound': 'Boom',\n",
      "              'hornSound': 'Bwahhhh',\n",
      "              'hull_number': <function Ship.hull_number at 0x0000000004D0F9D8>,\n",
      "              'length': <function Ship.length at 0x0000000004D0FA60>,\n",
      "              'shipCount': 0,\n",
      "              'shipInventory': [],\n",
      "              'tonnage': <function Ship.tonnage at 0x0000000004D0FF28>})\n",
      "shipCount <class 'int'> 0\n",
      "__str__ <class 'function'> <function Ship.__str__ at 0x0000000004D0FEA0>\n",
      "__init__ <class 'function'> <function Ship.__init__ at 0x0000000004D0F950>\n",
      "bellSound <class 'str'> Ding\n",
      "gunSound <class 'str'> Boom\n",
      "__dict__ <class 'getset_descriptor'> <attribute '__dict__' of 'Ship' objects>\n",
      "tonnage <class 'function'> <function Ship.tonnage at 0x0000000004D0FF28>\n",
      "__doc__ <class 'str'> Common base class for ships\n",
      "length <class 'function'> <function Ship.length at 0x0000000004D0FA60>\n",
      "hornSound <class 'str'> Bwahhhh\n",
      "__weakref__ <class 'getset_descriptor'> <attribute '__weakref__' of 'Ship' objects>\n",
      "hull_number <class 'function'> <function Ship.hull_number at 0x0000000004D0F9D8>\n",
      "__module__ <class 'str'> __main__\n",
      "shipInventory <class 'list'> []\n"
     ]
    }
   ],
   "source": [
    "# Following the wiring under the hood\n",
    "from pprint import pprint\n",
    "#  Build super-class, as before\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Build super-class methods.\n",
    "    def __init__(self, **kwargs):\n",
    "        if 'hull_num' in kwargs: self._hull_number = kwargs['hull_num'] \n",
    "            \n",
    "        if 'length' in kwargs: self._length = kwargs['length'] \n",
    "        if 'width' in kwargs: self._width = kwargs['width'] \n",
    "        if 'draft' in kwargs: self._draft = kwargs['draft'] \n",
    "        if 'displacement' in kwargs: self._tonnage = kwargs['displacement'] \n",
    "        \n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        try: return self._hull_number\n",
    "        except AttributeError:  return None\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        try: return self._length\n",
    "        except AttributeError:  return None \n",
    "        \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        try: return self._tonnage\n",
    "        except AttributeError:  return None   \n",
    "\n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "# Build unrelated independent function external to the classes\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )         \n",
    "    \n",
    "# Define subclasses, with methods    \n",
    "class Warship(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "    # Child class gets an additional method above those of base class    \n",
    "    def target(self, t):    \n",
    "        print ('Now targetting', t)\n",
    "        \n",
    "class Tanker(Ship):\n",
    "    'Derived class for tanker ships'\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    \n",
    "# Create instances of objects based on both subclasses      \n",
    "USSNewYork = Warship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Warship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "HMASSirius = Tanker(hull_num='AOR-34', length=420, width=200, draft=100, displacement=1200)\n",
    "\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "\n",
    "USSNewYork.target('Iwo Jima')  # Call child class method\n",
    "\n",
    "print (\"\\n#\" + 65*'=')\n",
    "\n",
    "# Accessing Class attributes directly.\n",
    "#   These are the Predefined Class Attributes (though some may be set to NONE)\n",
    "#    Superclass\n",
    "print (\"\\n# Superclass Dictionary\" + 25*'-')\n",
    "pprint (Ship.__dict__)\n",
    "for o in Ship.__dict__.keys():\n",
    "    print (o, type(Ship.__dict__[o]), Ship.__dict__[o])    \n",
    "    # Note that DICT and WEAKREF are different"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Now targetting Iwo Jima\n",
      "\n",
      "#=================================================================\n",
      "mappingproxy({'__dict__': <attribute '__dict__' of 'Ship' objects>,\n",
      "              '__doc__': 'Common base class for ships',\n",
      "              '__init__': <function Ship.__init__ at 0x0000000004C62D08>,\n",
      "              '__module__': '__main__',\n",
      "              '__str__': <function Ship.__str__ at 0x0000000004CB2730>,\n",
      "              '__weakref__': <attribute '__weakref__' of 'Ship' objects>,\n",
      "              'bellSound': 'Ding',\n",
      "              'gunSound': 'Boom',\n",
      "              'hornSound': 'Bwahhhh',\n",
      "              'hull_number': <function Ship.hull_number at 0x0000000004CB2510>,\n",
      "              'length': <function Ship.length at 0x0000000004CB2620>,\n",
      "              'shipCount': 0,\n",
      "              'shipInventory': [],\n",
      "              'tonnage': <function Ship.tonnage at 0x0000000004CB2598>})\n",
      "['__class__',\n",
      " '__delattr__',\n",
      " '__dict__',\n",
      " '__dir__',\n",
      " '__doc__',\n",
      " '__eq__',\n",
      " '__format__',\n",
      " '__ge__',\n",
      " '__getattribute__',\n",
      " '__gt__',\n",
      " '__hash__',\n",
      " '__init__',\n",
      " '__le__',\n",
      " '__lt__',\n",
      " '__module__',\n",
      " '__ne__',\n",
      " '__new__',\n",
      " '__reduce__',\n",
      " '__reduce_ex__',\n",
      " '__repr__',\n",
      " '__setattr__',\n",
      " '__sizeof__',\n",
      " '__str__',\n",
      " '__subclasshook__',\n",
      " '__weakref__',\n",
      " 'bellSound',\n",
      " 'gunSound',\n",
      " 'hornSound',\n",
      " 'hull_number',\n",
      " 'length',\n",
      " 'shipCount',\n",
      " 'shipInventory',\n",
      " 'tonnage']\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "{'_draft': 100,\n",
      " '_hull_number': 'BB35',\n",
      " '_length': 400,\n",
      " '_tonnage': 1200,\n",
      " '_width': 200}\n",
      "['__class__',\n",
      " '__delattr__',\n",
      " '__dict__',\n",
      " '__dir__',\n",
      " '__doc__',\n",
      " '__eq__',\n",
      " '__format__',\n",
      " '__ge__',\n",
      " '__getattribute__',\n",
      " '__gt__',\n",
      " '__hash__',\n",
      " '__init__',\n",
      " '__le__',\n",
      " '__lt__',\n",
      " '__module__',\n",
      " '__ne__',\n",
      " '__new__',\n",
      " '__reduce__',\n",
      " '__reduce_ex__',\n",
      " '__repr__',\n",
      " '__setattr__',\n",
      " '__sizeof__',\n",
      " '__str__',\n",
      " '__subclasshook__',\n",
      " '__weakref__',\n",
      " '_draft',\n",
      " '_hull_number',\n",
      " '_length',\n",
      " '_tonnage',\n",
      " '_width',\n",
      " 'bellSound',\n",
      " 'gunSound',\n",
      " 'hornSound',\n",
      " 'hull_number',\n",
      " 'length',\n",
      " 'shipCount',\n",
      " 'shipInventory',\n",
      " 'target',\n",
      " 'tonnage']\n",
      "\n",
      "#-----------------------------------------------------------------\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",
      "<built-in method __dir__ of list object at 0x0000000004D5E388>\n",
      "['__iter__', 'pop', '__lt__', '__imul__', '__ne__', '__gt__', 'index', '__format__', '__new__', '__getitem__', '__le__', '__reversed__', '__class__', '__reduce__', '__str__', '__add__', '__mul__', '__doc__', '__rmul__', '__iadd__', 'reverse', 'sort', '__hash__', '__init__', '__ge__', '__dir__', '__getattribute__', '__sizeof__', 'append', 'count', '__eq__', '__repr__', '__contains__', '__reduce_ex__', '__subclasshook__', 'extend', '__delattr__', 'insert', 'copy', '__setitem__', '__delitem__', 'clear', '__setattr__', 'remove', '__len__']\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 'int'>\n",
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "from pprint import pprint\n",
    "#  Build super-class, as before\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "      # Class level attributes.  Start with count of objects\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # Build super-class methods.\n",
    "    def __init__(self, **kwargs):\n",
    "        if 'hull_num' in kwargs: self._hull_number = kwargs['hull_num'] \n",
    "            \n",
    "        if 'length' in kwargs: self._length = kwargs['length'] \n",
    "        if 'width' in kwargs: self._width = kwargs['width'] \n",
    "        if 'draft' in kwargs: self._draft = kwargs['draft'] \n",
    "        if 'displacement' in kwargs: self._tonnage = kwargs['displacement'] \n",
    "        \n",
    "    def hull_number(self, h = None):\n",
    "        if h: self._hull_number = h\n",
    "        try: return self._hull_number\n",
    "        except AttributeError:  return None\n",
    "    \n",
    "    def length(self, l = None):\n",
    "        if l:  self._length = l\n",
    "        try: return self._length\n",
    "        except AttributeError:  return None \n",
    "        \n",
    "    def tonnage(self, t = None):\n",
    "        if t:  self._tonnage = t\n",
    "        try: return self._tonnage\n",
    "        except AttributeError:  return None   \n",
    "\n",
    "    def __str__(self):\n",
    "        return 'Hull {}'.format(self.hull_number())\n",
    "\n",
    "# Build unrelated independent function external to the classes\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} pushes {} and pulls {}.'.format(o.hull_number(), o.length(), o.tonnage()) )         \n",
    "    \n",
    "# Define subclasses, with methods    \n",
    "class Warship(Ship):\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "\n",
    "    # Child class gets an additional method above those of base class    \n",
    "    def target(self, t):    \n",
    "        print ('Now targetting', t)\n",
    "        \n",
    "class Tanker(Ship):\n",
    "    'Derived class for tanker ships'\n",
    "    def __init__(self, **kwargs):\n",
    "        super().__init__(**kwargs)\n",
    "    \n",
    "    \n",
    "# Create instances of objects based on both subclasses      \n",
    "USSNewYork = Warship(hull_num='BB34', length=400, width=200, draft=100, displacement=1200)          \n",
    "USSTexas = Warship(hull_num='BB35', length=400, width=200, draft=100, displacement=1200)\n",
    "HMASSirius = Tanker(hull_num='AOR-34', length=420, width=200, draft=100, displacement=1200)\n",
    "\n",
    "USSNewYork.length(395)   # Use of GETTER / SETTER to set a property.\n",
    "\n",
    "USSNewYork.target('Iwo Jima')  # Call child class method\n",
    "\n",
    "print (\"\\n#\" + 65*'=')\n",
    "\n",
    "\n",
    "\n",
    "# Note the difference bewteen dir(Class) and Class.__dict__\n",
    "#   Pythonistas say that __dict__ is just the dictionary of attributes\n",
    "#     while dir() walks the inheritence hierarchy and collects information from each class\n",
    "#     From the results below, notice that __dict_ contains the values in the dictionary, which dir() shows only the keys.\n",
    "pprint (Ship.__dict__)\n",
    "pprint (dir(Ship))\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "pprint(USSTexas.__dict__)\n",
    "pprint (dir(USSTexas))\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Note that some object types (such as a list) do not have __dict__ attributes, but still can be plumbed with DIR\n",
    "print (dir([]))\n",
    "print ([].__dir__)\n",
    "print ([].__dir__())\n",
    "print (dir([]))\n",
    "#print (dir['a', 'b'])\n",
    "print (type(42))\n",
    "print (type('42'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a Method Independent of Class\n",
    "It is possible to define a function independent of a class, and then use it as a class method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Message from vessel  scrap1 :  Crunch!   Curse!!!\n",
      "{'_draft': 25,\n",
      " '_hull_number': 'scrap2',\n",
      " '_length': 120,\n",
      " '_tonnage': 3000,\n",
      " '_width': 55}\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Message from vessel  scrap2 :  Crunch!   Curse!!!\n",
      "{'_draft': 25,\n",
      " '_hull_number': 'scrap2',\n",
      " '_length': 120,\n",
      " '_tonnage': 3000,\n",
      " '_width': 55}\n"
     ]
    }
   ],
   "source": [
    "# Creating a method independent of the class.  The class kind of \"adopts\" the function as a new method.\n",
    "from pprint import pprint\n",
    "\n",
    "# First step, define a function that takes an object as input.  And preferably uses a known method from that object.\n",
    "def ground_hull(obj1):\n",
    "    this_hull_number = obj1.hull_number()    # Access an object method\n",
    "    print (\"Message from vessel \", this_hull_number, \":  Crunch!   Curse!!!\")\n",
    "    return\n",
    "    \n",
    "# Define Barge Class\n",
    "class Barge:\n",
    "    \n",
    "    # Class methods\n",
    "    # This is the Initiator method.\n",
    "    def __init__(self, hull_number, length, width, draft, displacement):\n",
    "        self._hull_number = hull_number\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "        self._draft = draft\n",
    "        self._tonnage = displacement\n",
    "\n",
    "    # These are Instance Methods\n",
    "    # In particular, these are the \"GETTERS.\"  These are methods that extract an internal object variable.\n",
    "    #   Some programmers call these \"ACCESSORS.\"\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "rust_pan1 = Barge('scrap1', 100, 50, 20, 2000)\n",
    "rust_pan2 = Barge('scrap2', 120, 55, 25, 3000)\n",
    "\n",
    "ground_hull(rust_pan1)\n",
    "\n",
    "pprint (rust_pan2.__dict__)   # Print object dictionary before creaing new method\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "# Add method to class externally later in the day\n",
    "Barge.ground = ground_hull\n",
    "\n",
    "# Call new method on existing object in that class.\n",
    "rust_pan2.ground()\n",
    "\n",
    "pprint (rust_pan2.__dict__)   # Print object dictionary after creaing new method\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### What Is This Ship?\n",
    "<a id=\"WTS\"></a>\n",
    "Some additional ship-based OO code for upcoming exercises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Battleship'>\n",
      "{'status': 'Approved'}\n",
      "<class 'dict'>\n",
      "{'status': 'Designed', 'hull_number': 'BB-35'}\n",
      "{'status': 'Built', 'hull_number': 'BB-35'}\n",
      "{'name': 'Texas', 'status': 'Commissioned', 'hull_number': 'BB-35'}\n",
      "{'name': 'Ex-Texas', 'status': 'Decommissioned', 'hull_number': 'BB-35'}\n",
      "{'name': 'Ex-Texas', 'status': 'Scrapped', 'hull_number': 'BB-35'}\n",
      "<class '__main__.Battleship'>\n",
      "{'status': 'Approved'}\n",
      "<class 'dict'>\n",
      "{'status': 'Designed', 'hull_number': 'BB-34'}\n",
      "{'status': 'Built', 'hull_number': 'BB-34'}\n",
      "{'name': 'New York', 'status': 'Commissioned', 'hull_number': 'BB-34'}\n",
      "{'name': 'Ex-New York', 'status': 'Decommissioned', 'hull_number': 'BB-34'}\n",
      "{'name': 'Ex-New York', 'status': 'Sunk', 'hull_number': 'BB-34'}\n",
      "True\n",
      "{'name': 'Ex-New York', 'status': 'Sunk', 'hull_number': 'BB-34'}\n"
     ]
    }
   ],
   "source": [
    "# Basic Battleship Class with inheritance, data dictionary of all attributes, and minimal methods\n",
    "import datetime\n",
    "\n",
    "class Warship:\n",
    "    \"\"\"Simplest base object for a ship\"\"\"\n",
    "    def __init__(self):\n",
    "        self.data_dict = dict()\n",
    "        self.data_dict[\"status\"]=\"Approved\"\n",
    "    def design(self, hull_number):\n",
    "        self.data_dict[\"status\"]=\"Designed\"\n",
    "        self.data_dict[\"hull_number\"] = str(hull_number)\n",
    "    def build(self):\n",
    "        self.data_dict[\"status\"]=\"Built\"\n",
    "    def scrap(self):\n",
    "        self.data_dict[\"status\"]=\"Scrapped\"\n",
    "    def sink(self):\n",
    "        self.data_dict[\"status\"]=\"Sunk\"\n",
    "\n",
    "\n",
    "class Battleship(Warship):\n",
    "    \"\"\"Child object for battlewagons \"\"\"\n",
    "    def commission(self, ship_name_string):\n",
    "        self.data_dict[\"status\"]=\"Commissioned\"\n",
    "        self.data_dict[\"name\"]=ship_name_string        \n",
    "    def decommission(self):\n",
    "        self.data_dict[\"status\"]=\"Decommissioned\"\n",
    "        old_name_string = self.data_dict[\"name\"]\n",
    "        self.data_dict[\"name\"]=\"Ex-\" + old_name_string        \n",
    "\n",
    "#-----------------------------------------------------------------------\n",
    "#   String Generation and Manipulation\n",
    "#\n",
    "#-----------------------------------------------------------------------\n",
    "#    bb_35 = Warship()\n",
    "#    print (bb_35.data_dict)\n",
    "#    bb_35.design(\"BB-35\")\n",
    "#    print (bb_35.data_dict)\n",
    "#    bb_35.build()\n",
    "#    print (bb_35.data_dict)\n",
    "#    bb_35.scrap()\n",
    "#    print (bb_35.data_dict)\n",
    "\n",
    "bb_35 = Battleship()\n",
    "print (type(bb_35))\n",
    "print (bb_35.data_dict)\n",
    "print (type(bb_35.data_dict))\n",
    "bb_35.design(\"BB-35\")\n",
    "print (bb_35.data_dict)\n",
    "bb_35.build()\n",
    "print (bb_35.data_dict)\n",
    "bb_35.commission(\"Texas\")\n",
    "print (bb_35.data_dict)\n",
    "bb_35.decommission()\n",
    "print (bb_35.data_dict)\n",
    "bb_35.scrap()\n",
    "print (bb_35.data_dict)\n",
    "\n",
    "bb_34 = Battleship()\n",
    "print (type(bb_34))\n",
    "print (bb_34.data_dict)\n",
    "print (type(bb_34.data_dict))\n",
    "bb_34.design(\"BB-34\")\n",
    "print (bb_34.data_dict)\n",
    "bb_34.build()\n",
    "print (bb_34.data_dict)\n",
    "bb_34.commission(\"New York\")\n",
    "print (bb_34.data_dict)\n",
    "bb_34.decommission()\n",
    "print (bb_34.data_dict)\n",
    "bb_34.sink()\n",
    "print (bb_34.data_dict)\n",
    "\n",
    "print (hasattr(bb_34, 'data_dict'))  # HASATTR sometimes considered dangerous due to user error or V2 issues\n",
    "print (getattr(bb_34, 'data_dict'))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class '__main__.Battleship'>\n",
      "<class 'str'>\n",
      "Approved\n",
      "Approved\n",
      "Approved\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "True\n",
      "False\n",
      "True\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "BB-35\n",
      "Designed\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Built\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Texas\n",
      "Commissioned\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Decommissioned\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Scrapped\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "Approved\n",
      "Designed\n",
      "Built\n",
      "Commissioned\n",
      "Decommissioned\n",
      "Sunk\n",
      "\n",
      "#-----------------------------------------------------------------\n",
      "False\n",
      "Ex-New York\n"
     ]
    }
   ],
   "source": [
    "# Basic Battleship Class with inheritance, individual named attributes, and status-checking methods\n",
    "import datetime\n",
    "\n",
    "class Warship:\n",
    "    \"\"\"Simplest base object for a ship\"\"\"\n",
    "    def __init__(self):\n",
    "        self.status=\"Approved\"\n",
    "    def design(self, hull_number):\n",
    "        self.status=\"Designed\"\n",
    "        self.hull_number = str(hull_number)\n",
    "    def build(self):\n",
    "        self.status=\"Built\"\n",
    "    def scrap(self):\n",
    "        self.status=\"Scrapped\"\n",
    "    def sink(self):\n",
    "        self.status=\"Sunk\"\n",
    "    def q_status(self):\n",
    "        return self.status\n",
    "    def q_hull_number(self):\n",
    "        return self.hull_number\n",
    "    def q_name(self):\n",
    "        return self.name\n",
    "\n",
    "\n",
    "class Battleship(Warship):\n",
    "    \"\"\"Child object for battlewagons \"\"\"\n",
    "    def commission(self, ship_name_string):\n",
    "        self.status=\"Commissioned\"\n",
    "        self.name=ship_name_string        \n",
    "    def decommission(self):\n",
    "        self.status=\"Decommissioned\"\n",
    "        old_name_string = self.name\n",
    "        self.name=\"Ex-\" + old_name_string        \n",
    "\n",
    "#-----------------------------------------------------------------------\n",
    "#   String Generation and Manipulation\n",
    "#\n",
    "#-----------------------------------------------------------------------\n",
    "#    bb_35 = Warship()\n",
    "#    print (bb_35.data_dict)\n",
    "#    bb_35.design(\"BB-35\")\n",
    "#    print (bb_35.data_dict)\n",
    "#    bb_35.build()\n",
    "#    print (bb_35.data_dict)\n",
    "#    bb_35.scrap()\n",
    "#    print (bb_35.data_dict)\n",
    "\n",
    "bb_35 = Battleship()\n",
    "print (type(bb_35))\n",
    "qs = bb_35.q_status()\n",
    "print (type(qs))\n",
    "print (qs)\n",
    "print (bb_35.q_status())                   # Attribute accessible via method\n",
    "print (bb_35.status)                       # Attribute directly accessible\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (hasattr(bb_35, 'status'))\n",
    "print (hasattr(bb_35, 'hull_number'))       # un-instanuated attributes aren't yet recognized as attributes\n",
    "print (hasattr(bb_35, 'q_status'))          # A method appears to also be an attribute\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "bb_35.design(\"BB-35\")                      # Inherited method\n",
    "print (bb_35.q_hull_number())\n",
    "print (bb_35.q_status())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "bb_35.build()\n",
    "print (bb_35.q_status())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "bb_35.commission(\"Texas\")\n",
    "print (bb_35.q_name())\n",
    "print (bb_35.q_status())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "bb_35.decommission()\n",
    "print (bb_35.q_status())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "bb_35.scrap()\n",
    "print (bb_35.q_status())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "bb_34 = Battleship()                   # Second instance\n",
    "print (bb_34.q_status())\n",
    "bb_34.design(\"BB-34\")\n",
    "print (bb_34.q_status())\n",
    "bb_34.build()\n",
    "print (bb_34.q_status())\n",
    "bb_34.commission(\"New York\")\n",
    "print (bb_34.q_status())\n",
    "bb_34.decommission()\n",
    "print (bb_34.q_status())\n",
    "bb_34.sink()\n",
    "print (bb_34.q_status())\n",
    "print (\"\\n#\" + 65*'-')\n",
    "\n",
    "print (hasattr(bb_34, 'data_dict'))  # HASATTR sometimes considered dangerous due to user error or V2 issues\n",
    "print (getattr(bb_34, 'name'))\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## More Realistic Examples\n",
    "<a id=\"Realist0\"></a>\n",
    "### Adding Test Code\n",
    "A package file could contain test logic so that the file can be run for simple unit testing during incremental prototyping.  When run as part of a larger program, this simple test block would be ignored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "__main__\n",
      "scrap1\n"
     ]
    }
   ],
   "source": [
    "# Define Barge Class, as before\n",
    "class Barge:\n",
    "    def __init__(self, hull_number, length, width, draft, displacement):\n",
    "        self._hull_number = hull_number\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "        self._draft = draft\n",
    "        self._tonnage = displacement\n",
    "\n",
    "# This code runs only if the code is being run NOT as part of a larger program.        \n",
    "if __name__ == '__main__':\n",
    "    # Simple test code\n",
    "    rust_pan1 = Barge('scrap1', 100, 50, 20, 2000)\n",
    "    rust_pan2 = Barge('scrap2', 120, 55, 25, 3000)\n",
    "    print (__name__)\n",
    "    print (rust_pan1._hull_number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Based on Lutz\n",
    "Now that we have the basics, we can get mired in Lutz (using my own crazy code.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    shipCount = 0        #Class level attributes.  Start with count of objects\n",
    "    shipInventory = list()\n",
    "    \n",
    "    def __init__(self, hull_number, length, width, draft, displacement):\n",
    "        self.hull_number = hull_number\n",
    "        self.length = length\n",
    "        self.width = width\n",
    "        self.draft = draft\n",
    "        self.displace = displacement\n",
    "        Ship.shipCount += 1\n",
    "        Ship.shipInventory.append(hull_number)\n",
    "        print (Ship.shipCount)\n",
    "        print (Ship.shipInventory)\n",
    "        print ('---')\n",
    "        \n",
    "    def __del__(self):\n",
    "        Ship.shipCount -= 1\n",
    "        Ship.shipInventory.remove(self.hull_number)\n",
    "        \n",
    "    def displayCount(self):\n",
    "        print (\"Total hulls designed \", Ship.shipCount)\n",
    "        \n",
    "    def listHulls(self):\n",
    "        print (Ship.shipInventory)\n",
    "        \n",
    "    def describe(self):\n",
    "        print (self.hull_number, self.displace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "['BB35']\n",
      "---\n",
      "0\n",
      "Total hulls designed  0\n",
      "[]\n",
      "1\n",
      "['BB34']\n",
      "---\n",
      "Total hulls designed  1\n",
      "['BB34']\n",
      "['BB34']\n",
      "BB34 1200\n",
      "BB35 1200\n",
      "[]\n",
      "Total hulls designed  0\n"
     ]
    }
   ],
   "source": [
    "print (Ship.shipCount)\n",
    "BBTexas = Ship('BB35', 400, 200, 100, 1200)\n",
    "print (Ship.shipCount)\n",
    "BBTexas.displayCount()\n",
    "BBTexas.listHulls()\n",
    "\n",
    "BBNewYork = Ship('BB34', 400, 200, 100, 1200)\n",
    "BBNewYork.displayCount()\n",
    "BBNewYork.listHulls()\n",
    "BBTexas.listHulls()\n",
    "\n",
    "BBNewYork.describe()\n",
    "BBTexas.describe()\n",
    "del BBNewYork\n",
    "BBTexas.listHulls()\n",
    "BBTexas.displayCount()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try again using Class Methods"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    shipCount = 0        #Class level attributes.  Start with count of objects\n",
    "    shipInventory = list()\n",
    "    \n",
    "    def __init__(self, hull_number, length, width, draft, displacement):\n",
    "        print ('---Start of Constructor')\n",
    "        self.hull_number = hull_number\n",
    "        print (self.hull_number)\n",
    "        self.length = length\n",
    "        print (self.length)\n",
    "        self.width = width\n",
    "        print (self.width)\n",
    "        self.draft = draft\n",
    "        print (self.draft)\n",
    "        self.displace = displacement\n",
    "        print (self.displace)\n",
    "        Ship.shipCount += 1\n",
    "        print (Ship.shipCount)\n",
    "        Ship.shipInventory.append(hull_number)\n",
    "        print (Ship.shipInventory)\n",
    "        print ('---')\n",
    "        \n",
    "    def describe(self):\n",
    "        print ('---Start of Description Instance Method')\n",
    "        print (self.hull_number, self.displace)\n",
    "        print ('---')\n",
    "        \n",
    "    def listHulls(self):\n",
    "        print ('---Start of List Hulls Semi-Class Method')\n",
    "        print (type(Ship.shipInventory))\n",
    "        print (Ship.shipCount)\n",
    "#        print (Ship.shipInventory[0])\n",
    "        print ('---')\n",
    "        \n",
    "    def displayCount(self):\n",
    "        print ('---Start of Display Count Semi-class Method')\n",
    "        print (\"Total hulls designed \", Ship.shipCount)        \n",
    "        print ('---')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "---Start of Constructor\n",
      "BB35\n",
      "400\n",
      "200\n",
      "100\n",
      "1200\n",
      "1\n",
      "['BB35']\n",
      "---\n",
      "1\n",
      "---Start of Description Instance Method\n",
      "BB35 1200\n",
      "---\n",
      "---Start of List Hulls Semi-Class Method\n",
      "<class 'list'>\n",
      "1\n",
      "---\n",
      "---Start of Display Count Semi-class Method\n",
      "Total hulls designed  1\n",
      "---\n"
     ]
    }
   ],
   "source": [
    "print (Ship.shipCount)\n",
    "BBTexas = Ship('BB35', 400, 200, 100, 1200)\n",
    "print (Ship.shipCount)\n",
    "BBTexas.describe()\n",
    "Ship.listHulls\n",
    "Ship.displayCount                  # Can't call class methods this way when they are defined as instance methods.\n",
    "BBTexas.listHulls()\n",
    "BBTexas.displayCount()             # Can call class methods by instance name, but must use parentheses"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### Based on Lynda\n",
    "Let's try something that will work.  Let's start simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ding\n",
      "Boom\n",
      "Bwahhhh\n",
      "Ding\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "    shipCount = 0        #Class level attributes.  Start with count of objects\n",
    "    shipInventory = list()\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    def ring(self):\n",
    "        print(self.bellSound)\n",
    "    def fire(self):\n",
    "        print(self.gunSound)\n",
    "\n",
    "USSTexas = Ship()\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "#### Constructing the Object\n",
    "Let's try something that will work.  Let's start simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "Ding\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "    shipCount = 0        #Class level attributes.  Start with count of objects\n",
    "    shipInventory = list()\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    # This is the Constructor method.\n",
    "    def __init__(self, hull_number, length, width, draft, displacement):\n",
    "        self._hull_number = hull_number\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "        self._draft = draft\n",
    "        self._tonnage = displacement\n",
    "\n",
    "    # These are Instance Methods\n",
    "    # In particular, these are the \"GETTERS.\"  These are methods that extract an internal object variable.\n",
    "    #   Some programmers call these \"ACCESSORS.\"\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "    def ring(self):\n",
    "        return self.bellSound\n",
    "    \n",
    "    def fire(self):\n",
    "        return self.gunSound\n",
    "        \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} speaks \"{}\" and shouts \"{}\".'.format(o.hull_number(), o.ring(), o.fire()) )\n",
    "\n",
    "USSNewYork = Ship('BB34', 400, 200, 100, 1200)          \n",
    "USSTexas = Ship('BB35', 400, 200, 100, 1200)\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Bwahhhh\n",
      "400\n",
      "BB35\n",
      "Bwahhhh\n",
      "Ding\n",
      "BB35\n",
      "Hull BB34 sings Ding and speaks Boom.\n",
      "Hull BB60 sings Ding and speaks Boom.\n"
     ]
    }
   ],
   "source": [
    "# Define Ship Class\n",
    "class Ship:\n",
    "    'Common base class for ships'\n",
    "    # Class variables / attributes / properties\n",
    "    shipCount = 0        #Class level attributes.  Start with count of objects\n",
    "    shipInventory = list()\n",
    "    hornSound = 'Bwahhhh'\n",
    "    bellSound = 'Ding'\n",
    "    gunSound = 'Boom'\n",
    "    \n",
    "    def __init__(self, hull_num, length, width, draft, displacement):\n",
    "        self._hull_number = hull_num\n",
    "        self._length = length\n",
    "        self._width = width\n",
    "        self._draft = draft\n",
    "        self._tonnage = displacement\n",
    "\n",
    "        # These are Instance Methods\n",
    "    def hull_number(self):\n",
    "        return self._hull_number\n",
    "    \n",
    "    def ring(self):\n",
    "        return self.bellSound\n",
    "    \n",
    "    def fire(self):\n",
    "        return self.gunSound\n",
    "        \n",
    "# These are functions external to the class, so they are NOT methods\n",
    "def print_ship(o):\n",
    "    if not isinstance(o, Ship):\n",
    "        raise TypeError('print_ship():  requires a Ship')\n",
    "    print('Hull {} sings {} and speaks {}.'.format(o.hull_number(), o.ring(), o.fire()) )        \n",
    "        \n",
    "USSNewYork = Ship('BB34', 400, 200, 100, 1200)          \n",
    "USSTexas = Ship('BB35', 400, 200, 100, 1200)\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._length)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (USSTexas._hull_number)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "USSTexas.ring()\n",
    "USSTexas.fire()\n",
    "print (USSTexas.hornSound)     # Direct access to class variable via object attribute.  Not recommended.\n",
    "print (Ship.bellSound)         # Direct access to class variable via class attribute.  Also not recommended?\n",
    "bbh = USSTexas.hull_number()     # \n",
    "print (bbh)\n",
    "print_ship(USSNewYork)\n",
    "print_ship(Ship('BB60', 800, 300, 150, 2400))   # Can call the Class directly to create new object.  Note CLASS name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Useful Functions\n",
    "<a id=UsefulFunctions></a>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Functions I Wrote\n",
    "Most of these I brought over from my Perl corpus.  We will see if we really need them much here."
   ]
  },
  {
   "cell_type": "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": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "application/json": {
       "cell": {
        "!": "OSMagics",
        "HTML": "Other",
        "SVG": "Other",
        "bash": "Other",
        "capture": "ExecutionMagics",
        "cmd": "Other",
        "debug": "ExecutionMagics",
        "file": "Other",
        "html": "DisplayMagics",
        "javascript": "DisplayMagics",
        "js": "DisplayMagics",
        "latex": "DisplayMagics",
        "perl": "Other",
        "prun": "ExecutionMagics",
        "pypy": "Other",
        "python": "Other",
        "python2": "Other",
        "python3": "Other",
        "ruby": "Other",
        "script": "ScriptMagics",
        "sh": "Other",
        "svg": "DisplayMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "writefile": "OSMagics"
       },
       "line": {
        "alias": "OSMagics",
        "alias_magic": "BasicMagics",
        "autocall": "AutoMagics",
        "automagic": "AutoMagics",
        "autosave": "KernelMagics",
        "bookmark": "OSMagics",
        "cd": "OSMagics",
        "clear": "KernelMagics",
        "cls": "KernelMagics",
        "colors": "BasicMagics",
        "config": "ConfigMagics",
        "connect_info": "KernelMagics",
        "copy": "Other",
        "ddir": "Other",
        "debug": "ExecutionMagics",
        "dhist": "OSMagics",
        "dirs": "OSMagics",
        "doctest_mode": "BasicMagics",
        "echo": "Other",
        "ed": "Other",
        "edit": "KernelMagics",
        "env": "OSMagics",
        "gui": "BasicMagics",
        "hist": "Other",
        "history": "HistoryMagics",
        "killbgscripts": "ScriptMagics",
        "ldir": "Other",
        "less": "KernelMagics",
        "load": "CodeMagics",
        "load_ext": "ExtensionMagics",
        "loadpy": "CodeMagics",
        "logoff": "LoggingMagics",
        "logon": "LoggingMagics",
        "logstart": "LoggingMagics",
        "logstate": "LoggingMagics",
        "logstop": "LoggingMagics",
        "ls": "Other",
        "lsmagic": "BasicMagics",
        "macro": "ExecutionMagics",
        "magic": "BasicMagics",
        "matplotlib": "PylabMagics",
        "mkdir": "Other",
        "more": "KernelMagics",
        "notebook": "BasicMagics",
        "page": "BasicMagics",
        "pastebin": "CodeMagics",
        "pdb": "ExecutionMagics",
        "pdef": "NamespaceMagics",
        "pdoc": "NamespaceMagics",
        "pfile": "NamespaceMagics",
        "pinfo": "NamespaceMagics",
        "pinfo2": "NamespaceMagics",
        "popd": "OSMagics",
        "pprint": "BasicMagics",
        "precision": "BasicMagics",
        "profile": "BasicMagics",
        "prun": "ExecutionMagics",
        "psearch": "NamespaceMagics",
        "psource": "NamespaceMagics",
        "pushd": "OSMagics",
        "pwd": "OSMagics",
        "pycat": "OSMagics",
        "pylab": "PylabMagics",
        "qtconsole": "KernelMagics",
        "quickref": "BasicMagics",
        "recall": "HistoryMagics",
        "rehashx": "OSMagics",
        "reload_ext": "ExtensionMagics",
        "ren": "Other",
        "rep": "Other",
        "rerun": "HistoryMagics",
        "reset": "NamespaceMagics",
        "reset_selective": "NamespaceMagics",
        "rmdir": "Other",
        "run": "ExecutionMagics",
        "save": "CodeMagics",
        "sc": "OSMagics",
        "set_env": "OSMagics",
        "store": "StoreMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "tb": "ExecutionMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "unalias": "OSMagics",
        "unload_ext": "ExtensionMagics",
        "who": "NamespaceMagics",
        "who_ls": "NamespaceMagics",
        "whos": "NamespaceMagics",
        "xdel": "NamespaceMagics",
        "xmode": "BasicMagics"
       }
      },
      "text/plain": [
       "Available line magics:\n",
       "%alias  %alias_magic  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %macro  %magic  %matplotlib  %mkdir  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %popd  %pprint  %precision  %profile  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n",
       "\n",
       "Available cell magics:\n",
       "%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n",
       "\n",
       "Automagic is ON, % prefix IS NOT needed for line magics."
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "?Ship"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%magic"
   ]
  }
 ],
 "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
}