Python Classes.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Jupyter Shift-Tab Help trick:\n",
    "# press Shift-Tab while cursor is inside function(parenthesis)\n",
    "# ie press Shift-Tab while cursor is inside (\"Sup\")\n",
    "print(\"Sup\")\n",
    "# for our own functions/classes need to run them first in Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programming Styles\n",
    "\n",
    "* Imperative\n",
    " ** All computer machines work in imperative style\n",
    " ** Global variables are a problem\n",
    " \n",
    "* Declarative\n",
    "\n",
    "    ** We declare knowledge \n",
    "    ** We make queries on that knowledge\n",
    "    \n",
    "* Functional\n",
    " \n",
    "* Object Oriented\n",
    "\n",
    "### Data Hiding (Abstraction) - Private and Public\n",
    "### Inheritance (Classes can inherit other Classes)\n",
    "### Polymorphism (Different Classes use same methods doing different actions)\n",
    "The ability of different objects to respond, each in its own way, to identical messages is called polymorphism"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "EAFP is a Python acronym that stands for easier to ask for forgiveness than permission. This coding style is highly pushed in the Python community because it completely relies on the duck typing concept, thus fitting well with the language philosophy.\n",
    "\n",
    "The concept behind EAFP is fairly easy: instead of checking if an object has a given attribute or method before actually accessing or using it, just trust the object to provide what you need and manage the error case"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* casually methods == functions, technically methods are functions defined within class(more to follow) and have class context"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    \"\"\"A simple example class\"\"\"\n",
    "    i = 12345\n",
    "\n",
    "    def f(self): #this is important! similar to this in other languages object itself\n",
    "        return f'Hello'\n",
    "dir(MyClass)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f():\n",
    "    return \"Something\"\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myc=MyClass()\n",
    "#?myc\n",
    "print(myc.i)\n",
    "print(myc.f())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myc.f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myc.f2= f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myc.f2()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Side note number conversions\n",
    "2811145733512 == int(\"0x28E8557C588\",16)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Complex:\n",
    "    def __init__(self, realpart, imagpart, name):\n",
    "        self.r = realpart\n",
    "        self.i = imagpart\n",
    "        self.name = name\n",
    "    def calcDistance(self, mult):\n",
    "        return (self.r**2+self.i**2)**0.5*mult\n",
    "x = Complex(3.0, -4.5, \"Complekss\")\n",
    "print(x.r, x.i)\n",
    "print(x.calcDistance(5))\n",
    "print(x.name)\n",
    "# dir(x)\n",
    "dir(Complex)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data Hiding (Abstraction) - Private and Public\n",
    "\n",
    "### From http://www.faqs.org/docs/diveintopython/fileinfo_private.html\n",
    "\n",
    "\n",
    "* If the name of a Python function, class method, or attribute starts with (but doesn’t end with) two underscores, it’s private; everything else is public.\n",
    "\n",
    "* In Python, all special methods (like __setitem__) and built-in attributes (like __doc__) follow a standard naming convention: they both start with and end with two underscores. Don’t name your own methods and attributes this way; it will only confuse you (and others) later.\n",
    "\n",
    "* Python has no concept of protected class methods (accessible only in their own class and descendant classes). Class methods are either private (accessible only in their own class) or public (accessible from anywhere).\n",
    "\n",
    "Strictly speaking, private methods are accessible outside their class, just not easily accessible. Nothing in Python is truly private; internally, the names of private methods and attributes are mangled and unmangled on the fly to make them seem inaccessible by their given names. You can access the __parse method of the MP3FileInfo class by the name _MP3FileInfo__parse. Acknowledge that this is interesting, **then promise to never, ever do it in real code**. \n",
    "\n",
    "Private methods are private for a reason, but like many other things in Python, their privateness is ultimately a matter of convention, not force."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Creating and Deleting Class variables outside class definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.counter = 1\n",
    "while x.counter < 10:\n",
    "    x.counter = x.counter * 2\n",
    "print(x.counter)\n",
    "del x.counter\n",
    "# print(x.counter)\n",
    "print(x.r)\n",
    "del x.r\n",
    "print(x.r)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myc.f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mycoolmethod=myc.f\n",
    "for i in range(2):\n",
    "    print(mycoolmethod())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Actually, you may have guessed the answer: the special thing about methods is that the instance object is passed as the first argument of the function. In our example, the call x.f() is exactly equivalent to MyClass.f(x). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generally speaking, instance variables are for data unique to each instance and class variables are for attributes and methods shared by all instances of the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "\n",
    "    kind = 'canine'         # class variable shared by all instances\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name    # instance variable unique to each instance\n",
    "        self.bigname = \"BIGDOG\"\n",
    "d = Dog('Fido')\n",
    "e = Dog('Spot')\n",
    "print(d.kind, d.name)\n",
    "print(e.kind, e.name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.kind='wolf'\n",
    "d.kind, e.kind # seems to work right?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e.kind=['superdog']\n",
    "d.kind, e.kind\n",
    "e.kind+=[\"hound\"]\n",
    "d.kind, e.kind\n",
    "# \"d.\".capitalize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As discussed in A Word About Names and Objects, shared data can have possibly surprising effects with involving mutable objects such as lists and dictionaries. For example, the tricks list in the following code should not be used as a class variable because just a single list would be shared by all Dog instances:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "\n",
    "    tricks = []             # mistaken use of a class variable\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)\n",
    "\n",
    "d = Dog('Fido')\n",
    "e = Dog('Buddy')\n",
    "d.add_trick('roll over')\n",
    "e.add_trick('play dead')\n",
    "f = Dog('Dzulis')\n",
    "print(f.tricks)\n",
    "print(d.tricks)                # unexpectedly shared by all dogs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Correct design of the class should use an instance variable instead:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dog:\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.tricks = []    # creates a new empty list for each dog\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)\n",
    "    def del_trick(self, trick):\n",
    "        self.tricks.remove(trick)\n",
    "    def update_trick(self, ndx, newtrick):\n",
    "        self.tricks[ndx] = newtrick\n",
    "    def update_tr(self, trk, newtrick):\n",
    "        trk = newtrick\n",
    "d = Dog('Fido')\n",
    "e = Dog('Buddy')\n",
    "d.add_trick('roll over')\n",
    "e.add_trick('play dead')\n",
    "d.tricks, e.tricks\n",
    "f = Dog('Bully')\n",
    "f.add_trick('bite')\n",
    "f.add_trick('chew')\n",
    "print(d.tricks,e.tricks,f.tricks)\n",
    "f.del_trick('bite')\n",
    "print(f.tricks)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.tricks\n",
    "d.add_trick('play dead')\n",
    "d.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.update_trick(1, 'rise up')\n",
    "d.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.update_tr(d.tricks[1], \"do nothing\")\n",
    "d.tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.tricks[1]= 'do nothing'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Pet(object):\n",
    "\n",
    "    def __init__(self, name, species):\n",
    "        self.name = name\n",
    "        self.species = species\n",
    "\n",
    "    def getName(self):\n",
    "        return self.name\n",
    "\n",
    "    def getSpecies(self):\n",
    "        return self.species\n",
    "    \n",
    "    def setSpecies(self, newspecies):\n",
    "        self.species = newspecies\n",
    "\n",
    "    def __str__(self):\n",
    "        return f\"{self.name} is a {self.species}\"\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first word, class, indicates that we are creating a class. The second word, Pet, indicates the name of the class. The word in parentheses, object, is the class that Pet is inheriting from. We’ll get more into inheritance below, so for now all you need to know is that object is a special variable in Python that you should include in the parentheses when you are creating a new class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tom=Pet(\"Tom\", \"Cat\")\n",
    "print(tom) # __str__ is overridden here!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tom.setSpecies('tiger')\n",
    "print(tom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As mentioned before, we don’t actually have to pass in the self parameter because Python automatically figures it out. To make it a little bit clearer as to what is going on, we can look at two different ways of calling getName. The first way is the standard way of doing it: polly.getName(). The second, while not conventional, is equivalent: Pet.getName(polly)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "jerry=Pet(\"Jerry\", \"mouse\")\n",
    "jerry.getSpecies()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Pet.getSpecies(jerry)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat(Pet):\n",
    "\n",
    "    def __init__(self, name, hates_dogs):\n",
    "        Pet.__init__(self, name, \"Cat\")\n",
    "        self.hates_dogs = hates_dogs\n",
    "\n",
    "    def hatesDogs(self):\n",
    "        return self.hates_dogs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tom=Cat(\"Tom\",True)\n",
    "print(tom) # uses __str__ from Pet!\n",
    "print(tom.hatesDogs())\n",
    "dir(tom)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Is Instance of particular class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance(tom, Cat)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance(tom, Pet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "isinstance(tom, Dog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function defined outside the class\n",
    "def f1(self, x, y):\n",
    "    return min(x, x+y)\n",
    "\n",
    "class C:\n",
    "    f = f1\n",
    "\n",
    "    def g(self):\n",
    "        return 'hello world'\n",
    "    h = g\n",
    "myc=C()\n",
    "print(f1(None,6, 7))\n",
    "print(myc.f(5,99))\n",
    "print(myc.g())\n",
    "print(myc.h())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now f, g and h are all attributes of class C that refer to function objects, and consequently they are all methods of instances of C — h being exactly equivalent to g. Note that this practice usually only serves to confuse the reader of a program."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Methods may call other methods by using method attributes of the self argument:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bag:\n",
    "    def __init__(self):\n",
    "        self.data = []\n",
    "\n",
    "    def add(self, x):\n",
    "        self.data.append(x)\n",
    "\n",
    "    def addtwice(self, x):\n",
    "        self.add(x)\n",
    "        self.add(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = Bag()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.add('first')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.addtwice(42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#An example of a class\n",
    "class Shape:\n",
    "\n",
    "    def __init__(self, x, y, description=\"No description\", author=\"Nobody\"):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        self.description = description\n",
    "        self.author = author\n",
    "\n",
    "    def area(self):\n",
    "        return self.x * self.y\n",
    "\n",
    "    def perimeter(self):\n",
    "        return 2 * self.x + 2 * self.y\n",
    "\n",
    "    def describe(self, text):\n",
    "        self.description = text\n",
    "\n",
    "    def authorName(self, text):\n",
    "        self.author = text\n",
    "\n",
    "    def scaleSize(self, scale):\n",
    "        self.x = self.x * scale\n",
    "        self.y = self.y * scale"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Rectangle(Shape):\n",
    "    def __init__(self, x, y, color=\"Red\"):\n",
    "        Shape.__init__(self, x, y, \"Rectangle\")\n",
    "        self.color=color\n",
    "    def __str__(self):\n",
    "        return (f\"Shape color: {self.color} type: {self.description} made by {self.author} x:{self.x} y:{self.y}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rect=Rectangle(5,6)\n",
    "print(rect)\n",
    "print(rect.area(), rect.perimeter())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rectangle=rect\n",
    "#finding the area of your rectangle:\n",
    "print(rectangle.area())\n",
    "\n",
    "#finding the perimeter of your rectangle:\n",
    "print(rectangle.perimeter())\n",
    "\n",
    "#describing the rectangle\n",
    "rectangle.describe(\"A wide rectangle, more than twice\\\n",
    " as wide as it is tall\")\n",
    "\n",
    "#making the rectangle 50% smaller\n",
    "rectangle.scaleSize(0.5)\n",
    "\n",
    "#re-printing the new area of the rectangle\n",
    "print(rectangle.area())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### We aren't limited to a single instance of a class - we could have as many instances as we like."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "long_rectangle = Rectangle(120,10)\n",
    "fat_rectangle = Rectangle(130,120)\n",
    "print(long_rectangle)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## More about self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Restaurant(object):\n",
    "    def __init__(self):\n",
    "        self.bankrupt = False\n",
    "\n",
    "    def open_branch(self):\n",
    "        if not self.bankrupt:\n",
    "            print(\"branch opened\")\n",
    "        else:\n",
    "            print(\"Bankrupt Businesses do not open branches!\")\n",
    "x = Restaurant()\n",
    "y = Restaurant()\n",
    "print(x.bankrupt,y.bankrupt)\n",
    "y.bankrupt=True\n",
    "x.open_branch()\n",
    "y.open_branch()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The first argument of every class method, including init, is always a reference to the current instance of the class. By convention, this argument is always named self. In the init method, self refers to the newly created object; in other class methods, it refers to the instance whose method was called."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## We could use a different name such as this instead of self, but convention is strong here, so use self!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sometimes it is useful to have a data type similar to the Pascal “record” or C “struct”, bundling together a few named data items. An empty class definition will do nicely:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    def __init__(self, name, dept, salary=100000):\n",
    "        self.name = name\n",
    "        self.dept = dept\n",
    "        self.salary = salary\n",
    "    def __str__(self):\n",
    "        return f'Employee: {self.name}, dept: {self.dept}, salary: {self.salary}'\n",
    "\n",
    "john = Employee('John', 'Engineering')\n",
    "print(john)\n",
    "# Fill the fields of the record\n",
    "john.name = 'John Doe'\n",
    "john.dept = 'computer lab'\n",
    "john.salary = 1000\n",
    "print(john)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "peter = {\"name\" : 'peter', 'dept' = 'computer lab'}\n",
    "peter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Customer(object):\n",
    "    \"\"\"A customer of ABC Bank with a checking account. Customers have the\n",
    "    following properties:\n",
    "\n",
    "    Attributes:\n",
    "        name: A string representing the customer's name.\n",
    "        balance: A float tracking the current balance of the customer's account.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, name, balance=0.0):\n",
    "        \"\"\"Return a Customer object whose name is *name* and starting\n",
    "        balance is *balance*.\"\"\"\n",
    "        self.name = name\n",
    "        self.balance = balance\n",
    "\n",
    "    def withdraw(self, amount):\n",
    "        \"\"\"Return the balance remaining after withdrawing *amount*\n",
    "        dollars.\"\"\"\n",
    "        if amount > self.balance:\n",
    "            raise RuntimeError('Amount greater than available balance.')\n",
    "        self.balance -= amount\n",
    "        return self.balance\n",
    "\n",
    "    def deposit(self, amount):\n",
    "        \"\"\"Return the balance remaining after depositing *amount*\n",
    "        dollars.\"\"\"\n",
    "        self.balance += amount\n",
    "        return self.balance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vs = Customer(\"Valdis\", balance=333)\n",
    "print(vs.balance)\n",
    "vs.withdraw(300)\n",
    "print(vs.balance)\n",
    "vs.withdraw(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Extra: Adding Iterators to your own classes\n",
    "\n",
    "https://docs.python.org/3/tutorial/classes.html#iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is easy to add iterator behavior to your classes. Define an __iter__() method which returns an object with a __next__() method. If the class defines __next__(), then __iter__() can just return self:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Reverse:\n",
    "    \"\"\"Iterator for looping over a sequence backwards.\"\"\"\n",
    "    def __init__(self, data):\n",
    "        self.data = data\n",
    "        self.index = len(data)\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.index == 0:\n",
    "            raise StopIteration\n",
    "        self.index = self.index - 1\n",
    "        return self.data[self.index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###  Discussion for another day on Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generators are a simple and powerful tool for creating iterators. They are written like regular functions but use the yield statement whenever they want to return data. Each time next() is called on it, the generator resumes where it left off (it remembers all the data values and which statement was last executed). An example shows that generators can be trivially easy to create:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def reverse(data):\n",
    "    for index in range(len(data)-1, -1, -1):\n",
    "        yield data[index]\n",
    "for char in reverse('golf'):\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Home rewrite Employee function using dictionary\n",
    "## Correct predefined functions (replace pass with instructions)\n",
    "## Use dictionary to update and retrieve records from employee\n",
    "## create two employees:\n",
    "## John with name \"John\" and salary 100000\n",
    "## Peter with name \"Peter\" and salary 80000\n",
    "\n",
    "\n",
    "class Employee:\n",
    "    \n",
    "    def __init__(self, name, dept, salary=100000):\n",
    "        self.edict={}\n",
    "        \n",
    "    def __str__(self):\n",
    "        return f'Employee: {self.name}, dept: {self.dept}, salary: {self.salary}'\n",
    "    def updateName():\n",
    "        pass\n",
    "    def updateSalary():\n",
    "        pass\n",
    "    def getName():\n",
    "        pass\n",
    "    def getSalary():\n",
    "        pass\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Microsoft Azure \n",
    "### Interactive coding in your browser\n",
    "https://notebooks.azure.com/"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}