lecture-06/1-intro-to-oop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# CME 211: Lecture 6\n",
    "Fall 2020\n",
    "\n",
    "## Introduction to Object Oriented Programming\n",
    "\n",
    "### Procedural programming\n",
    "\n",
    "In *procedural programming* (also known as *imperative programming*) you\n",
    "implement your computation in terms of variables (integers, doubles, etc.), data\n",
    "structures (arrays, lists, dictionaries, etc.), and procedures (functions,\n",
    "subroutines, etc.).  The programmer is responsible for designing the procedure\n",
    "(or sequence of instructions) that the computer will follow.\n",
    "\n",
    "Most of the widely used programming languages (Python, C++, Fortran, Java,\n",
    "MATLAB, etc.) are procedural but also support Object Oriented Programming\n",
    "(OOP).\n",
    "\n",
    "Some alternatives to *procedural programming* include:\n",
    "\n",
    "* *functional programming*: structuring a computation as the composition of pure\n",
    "  functions.  See: [Haskell](https://www.haskell.org/), [Clojure](https://clojure.org/), [Scheme](https://en.wikipedia.org/wiki/Scheme_(programming_language)), and [Functional\n",
    "  Programming in Python](https://docs.python.org/3/library/functional.html)\n",
    "\n",
    "* *declarative programming*: making a set of declarations and asking a computer, usually via a solver, to\n",
    "  produce a result where all declarations hold true:\n",
    "\n",
    "  * *equation based programming* In a mathematical programming language (GAMS, AMPL, JuMP, CVX, CVXPY, Modelica, gPROMS), the\n",
    "    programmer writes down a set of equations and/or inequalities (constraints) and\n",
    "    asks a solver to find a solution. Some may argue that equation-based programming is just a variant of object oriented programming.\n",
    "\n",
    "  * Also **Boolean satisfiability problem**:\n",
    "    see <https://en.wikipedia.org/wiki/Boolean_satisfiability_problem>\n",
    "\n",
    "### Object oriented programming in a nutshell\n",
    "\n",
    "Object oriented programming is based around the concept of \"objects\".  Objects have two kinds of\n",
    "*attributes* (accessed via `.` sytax): data attributes (or instance variables)\n",
    "and function attributes (or *methods*).  Object data is typically modified by\n",
    "object methods.\n",
    "\n",
    "\n",
    "### Why object oriented programming?\n",
    "\n",
    "* Concept of object oriented programming has been around since 1960s\n",
    "\n",
    "* Gained popularity in the 1980s and 1990s with the development and\n",
    "  standardization of C++, and faster computers that mitigated the overhead of the\n",
    "  abstractions\n",
    "\n",
    "* **Abstraction, modularity, and reusability** are some of the most commonly cited\n",
    "  reasons for using object oriented programming\n",
    "\n",
    "* Almost all new software development uses some degree of object oriented programming (for better or worse)\n",
    "\n",
    "* In Python, everything is an object.  Proper use of object oriented programming features allows\n",
    "  programmers to write code that integrates nicely into the Python language\n",
    "  and set of libraries.\n",
    "\n",
    "### Why not object oriented programming?\n",
    "\n",
    "* Proper object oriented programming design is **hard**.  There is a cottage industry of tools and books.\n",
    "\n",
    "* Programmers tend to abuse object oriented programming features leading to code bases that are *extremely*\n",
    "  difficult to work with.  (This might also mean **job security**)\n",
    "\n",
    "\n",
    "### Abstraction\n",
    "\n",
    "* Represent data and computations in a familiar form\n",
    "\n",
    "  * Car object, with an engine object, and tire objects\n",
    "\n",
    "* Make programmers more productive\n",
    "\n",
    "  * Salaries are expensive compared to computers\n",
    "\n",
    "* Too much abstraction can be a bad thing if it has a significant impact on\n",
    "  performance\n",
    "\n",
    "  * Desktop computers really are cheap\n",
    "\n",
    "  * Supercomputers are not cheap\n",
    "\n",
    "### Objects\n",
    "\n",
    "* In object oriented programming you express your computations in terms of *objects*, which are instances\n",
    "  of *classes*\n",
    "\n",
    "* Classes are blueprints for objects\n",
    "\n",
    "![fig/class-object.png](fig/class-object.png)\n",
    "\n",
    "* Classes specify data and the methods to use or interact with that data\n",
    "\n",
    "### Class / object example 1: list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 19, 3]"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = list()\n",
    "a.append(5)\n",
    "a.append(19)\n",
    "a.append(3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 5, 19]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sort()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `list()` returns an object which is an instance of the *list* class\n",
    "* `append()` and `sort()` are *methods*\n",
    "* 3, 5, 19 are the *data* maintained by the object\n",
    "\n",
    "\n",
    "### Class / object examples 2: file objects\n",
    "\n",
    "Here is some code to write to a file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"hello.txt\", \"w\")\n",
    "f.write(\"hello cme211!\\n\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The `open()` function returns an *object* which is an instance of the *file\n",
    "  class*\n",
    "\n",
    "* `write()` and `close()` are methods of the *file class*\n",
    "\n",
    "Let's look at the documentation for `open()` via `help(open)`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Help on built-in function open in module io:\n",
    "\n",
    "open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)\n",
    "    Open file and return a stream.  Raise IOError upon failure.\n",
    "\n",
    "[text omitted]\n",
    "\n",
    "open() returns a **file object** whose type depends on the mode, and\n",
    "through which the standard file operations such as reading and writing\n",
    "are performed. When open() is used to open a file in a text mode ('w',\n",
    "'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\n",
    "a file in a binary mode, the returned class varies: in read binary\n",
    "mode, it returns a BufferedReader; in write binary and append binary\n",
    "modes, it returns a BufferedWriter, and in read/write mode, it returns\n",
    "a BufferedRandom.\n",
    "\n",
    "[text omitted]\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The structure of file input-output objects has changed quite a bit between\n",
    "Python 2 and Python 3.  For basic uses, the behavior is the same and simple file\n",
    "IO code should be the same.\n",
    "\n",
    "### Modularity and reusability\n",
    "\n",
    "* **High level languages** like Python, Java, C++, etc. **include classes for working with files**, holding data (lists and dictionaries), etc.\n",
    "\n",
    "* So you do not have to design and create your own classes if someone else has\n",
    "  already done the work for you\n",
    "\n",
    "* But you _might_ want to create classes that are specialized to the needs of your\n",
    "  applications, so they can be used (and reused) by yourself and others\n",
    "\n",
    "### Object oriented programming in Python\n",
    "\n",
    "* New kinds of objects can be created in Python by defining your own classes\n",
    "\n",
    "* Classes are the blueprint for creating objects which are known as instances of\n",
    "the class\n",
    "\n",
    "* Classes have *attributes*\n",
    "\n",
    "  * Variables (data) are called class *variables*\n",
    "\n",
    "  * Functions for interacting with the class are called *methods*\n",
    "\n",
    "  * Attributes are accessed using *dot notation*\n",
    "\n",
    "### Creating instances\n",
    "\n",
    "* Instances of a class are created by calling the class object as a function\n",
    "\n",
    "* Any arguments of the function call are passed to the special `__init__()`\n",
    "  method\n",
    "\n",
    "### Python class definition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Classes are defined with the `class` keyword\n",
    "* Followed by the class name and a colon (`:`)\n",
    "* Followed by the indented class body, containing class *attributes*\n",
    "\n",
    "### Object initialization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```py\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* `__init__` is the special name for the initialization method\n",
    "* `self` is a reference to the specific instance (object) that is calling this\n",
    "  method.  In the case of the `__init__` method, `self` refers to the object\n",
    "  being created.  `self` is simply a Python variable and can be renamed\n",
    "* `id` is the input argument from the call to create a new instance\n",
    "* `self.id = id` stores the input `id` in the object\n",
    "\n",
    "### Class definition in action\n",
    "\n",
    "Let's work with a class called `Student` to create objects that represent and\n",
    "maintain information about students.\n",
    "\n",
    "Define the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, everything in Python is an object.  This includes classes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Student"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Student"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can think of a Python `class` as object that can produce objects of the class\n",
    "type.  Let's create a student object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Student at 0x7f16481cfb70>"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = Student(7)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That output is not terribly useful at this point.  Let's access the `id`\n",
    "attribute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(s.id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Let's talk about `self`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "inside __init__()\n",
      "self = <__main__.Student object at 0x7f16481750f0>\n",
      "s    = <__main__.Student object at 0x7f16481750f0>\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        print(\"inside __init__()\")\n",
    "        print(\"self = {}\".format(self))\n",
    "        self.id = id\n",
    "\n",
    "s = Student(7)\n",
    "print(\"s    = {}\".format(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we see that `self` inside of `__init__` is the same object that is returned\n",
    "by the call `Student(7)`.\n",
    "\n",
    "### Object setup\n",
    "\n",
    "* The optional initialization method is typically used to do setup of class\n",
    "  variables that will be used throughout the life of the instance\n",
    "\n",
    "* What kind of class variables might we want to setup for a student class?\n",
    "\n",
    "### Class variable setup\n",
    "\n",
    "Let's add an empty dictionary for the classes that the student is enrolled in:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "        self.courses = {}\n",
    "\n",
    "s = Student(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Architecting our object\n",
    "\n",
    "* Our object has data about `id` and `classes`\n",
    "\n",
    "* But how do we do anything with it?\n",
    "\n",
    "* We need to create additional methods for interacting or *interfacing* with the\n",
    "  object\n",
    "\n",
    "### Encapsulation\n",
    "\n",
    "* The *interface* of an object encapsulates the internal data and code\n",
    "\n",
    "* *encapsulation* means hiding the details of data structures and algorithms\n",
    "(internal code)\n",
    "\n",
    "![fig/encapsulation.png](fig/encapsulation.png)\n",
    "\n",
    "### Interfaces\n",
    "\n",
    "* Interfaces **protect** the user of the class from **internal implementation details.**\n",
    "\n",
    "* Found a **better way to implement the internal representation** of the data? **No problem.**  In the interface is the same, internal changes to data representation\n",
    "  won't affect anything that uses the object.\n",
    "\n",
    "* **New algorithm** for the internal processing of that data? **No problem.**\n",
    "\n",
    "* **Screwed up your interface** and now need to make changes to the interface? **Problem**\n",
    "\n",
    "### Defining a regular method\n",
    "\n",
    "Inside of the `Student` class, we put the `get_id` method:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "        self.courses = {}\n",
    "    def get_id(self):\n",
    "        return self.id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* just like defining a Python function\n",
    "\n",
    "* `self` is a reference to the specific instance that is calling this method\n",
    "\n",
    "### Access to id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Student object at 0x7f16481cf128>\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "s = Student(7)\n",
    "print(s)\n",
    "print(s.get_id())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check up\n",
    "\n",
    "How are we doing with interface design?\n",
    "\n",
    "Is there a way somebody could accidentally change the id given the interface\n",
    "we've implemented?\n",
    "\n",
    "Let's test it:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Student object at 0x7f1648179550>\n",
      "id = 7\n",
      "id = 42\n",
      "s.get_id() = 7\n"
     ]
    }
   ],
   "source": [
    "s = Student(7)\n",
    "print(s)\n",
    "id = s.get_id()\n",
    "print(\"id = {}\".format(id))\n",
    "id = 42\n",
    "print(\"id = {}\".format(id))\n",
    "print(\"s.get_id() = {}\".format(s.get_id()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reference returned by `get_id()` cannot be used to change the assignment of\n",
    "the reference within the object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s.get_id() = I have changed the id to a string, probably not good\n"
     ]
    }
   ],
   "source": [
    "s.id = \"I have changed the id to a string, probably not good\"\n",
    "print(\"s.get_id() = {}\".format(s.get_id()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `id` attribute is accessible and can be assigned to just like any Python\n",
    "variable.  This may not be desirable behavior. We can visualize all of the above in [Python Tutor](http://www.pythontutor.com/visualize.html#code=class%20Student%3A%0A%20%20%20%20def%20__init__%28self,%20id%29%3A%0A%20%20%20%20%20%20%20%20self.id%20%3D%20id%0A%20%20%20%20%20%20%20%20self.courses%20%3D%20%7B%7D%0A%20%20%20%20def%20get_id%28self%29%3A%0A%20%20%20%20%20%20%20%20return%20self.id%0A%20%20%20%20%20%20%20%20%0As%20%3D%20Student%287%29%0Aprint%28s%29%0Aid%20%3D%20s.get_id%28%29%0Aprint%28%22id%20%3D%20%7B%7D%22.format%28id%29%29%0Aid%20%3D%2042%0Aprint%28%22id%20%3D%20%7B%7D%22.format%28id%29%29%0Aprint%28%22s.get_id%28%29%20%3D%20%7B%7D%22.format%28s.get_id%28%29%29%29%0A%0As.id%20%3D%20%22I%20have%20changed%20the%20id%20to%20a%20string,%20probably%20not%20good%22%0Aprint%28%22s.get_id%28%29%20%3D%20%7B%7D%22.format%28s.get_id%28%29%29%29%0A&cumulative=false&curInstr=19&heapPrimitives=nevernest&mode=display&origin=opt-frontend.js&py=3&rawInputLstJSON=%5B%5D&textReferences=false).\n",
    "\n",
    "### Adding classes / grades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPA = 3.5\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "        self.courses = {}\n",
    "    def get_id(self):\n",
    "        return self.id\n",
    "    def add_class(self, name, gradepoint):\n",
    "        self.courses[name] = gradepoint\n",
    "        sumgradepoints = float(sum(self.courses.values()))\n",
    "        self.gpa = sumgradepoints/len(self.courses)\n",
    "    def get_gpa(self):\n",
    "        return self.gpa\n",
    "\n",
    "s = Student(7)\n",
    "s.add_class(\"gym\", 4)\n",
    "s.add_class(\"math\", 3)\n",
    "print(\"GPA = {}\".format(s.get_gpa()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Getting courses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPA = 3.5\n",
      "courses = {'gym': 4, 'math': 3}\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "        self.courses = {}\n",
    "    def get_id(self):\n",
    "        return self.id\n",
    "    def add_class(self, name, gradepoint):\n",
    "        self.courses[name] = gradepoint\n",
    "        sumgradepoints = float(sum(self.courses.values()))\n",
    "        self.gpa = sumgradepoints/len(self.courses)\n",
    "    def get_gpa(self):\n",
    "        return self.gpa\n",
    "    def get_courses(self):\n",
    "        return self.courses\n",
    "\n",
    "s = Student(7)\n",
    "s.add_class(\"gym\", 4)\n",
    "s.add_class(\"math\", 3)\n",
    "print(\"GPA = {}\".format(s.get_gpa()))\n",
    "print(\"courses = {}\".format(s.get_courses()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**If a method returns a reference to a mutable object, then changing that object \"outside\" of the class will change the data \"inside\" of the class.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPA = 3.5\n",
      "courses = {'gym': 4, 'math': 3, 'english': 4}\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "        self.courses = {}\n",
    "    def get_id(self):\n",
    "        return self.id\n",
    "    def add_class(self, name, gradepoint):\n",
    "        self.courses[name] = gradepoint\n",
    "        sumgradepoints = float(sum(self.courses.values()))\n",
    "        self.gpa = sumgradepoints/len(self.courses)\n",
    "    def get_gpa(self):\n",
    "        return self.gpa\n",
    "    def get_courses(self):\n",
    "        return self.courses\n",
    "\n",
    "s = Student(7)\n",
    "s.add_class(\"gym\", 4)\n",
    "s.add_class(\"math\", 3)\n",
    "\n",
    "courses = s.get_courses()\n",
    "courses[\"english\"] = 4    # <~ Not the best idea\n",
    "\n",
    "print(\"GPA = {}\".format(s.get_gpa()))\n",
    "print(\"courses = {}\".format(s.get_courses()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Interfaces and references\n",
    "\n",
    "* It is easy to accidentally let a method provide a reference to a mutable data\n",
    "  structure within your object.\n",
    "\n",
    "* Once you have handed out that reference someone can manipulate your internal\n",
    "  data and perhaps get the object into an unexpected state.\n",
    "\n",
    "* You really need to think about what you pass out of your object if you want to\n",
    "  have strong encapsulation.\n",
    "\n",
    "### Public attributes\n",
    "\n",
    "Default behavior is that all attributes are public, i.e. accessible using dot\n",
    "notation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s.id = 7\n",
      "s.get_id() = 9\n"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.id = id\n",
    "        self.courses = {}\n",
    "    def get_id(self):\n",
    "        return self.id\n",
    "\n",
    "s = Student(7)\n",
    "print(\"s.id = {}\".format(s.id))\n",
    "s.id = 9\n",
    "print(\"s.get_id() = {}\".format(s.get_id()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Private attributes\n",
    "\n",
    "Attributes can be made *private* by using a double underscore prefix for the\n",
    "name:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s.get_id() = 7\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "'Student' object has no attribute '__id'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-cab443e1ae4a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mStudent\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"s.get_id() = {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_id\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 10\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"s.id = {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__id\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'Student' object has no attribute '__id'"
     ]
    }
   ],
   "source": [
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self.__id = id\n",
    "        self.courses = {}\n",
    "    def get_id(self):\n",
    "        return self.__id\n",
    "\n",
    "s = Student(7)\n",
    "print(\"s.get_id() = {}\".format(s.get_id()))\n",
    "print(\"s.id = {}\".format(s.__id))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \"Privacy\" through obscurity\n",
    "\n",
    "Python object attributes are never really private.  The `__` before the attribute\n",
    "tells Python to obscure tha name in some way.  This is called name or symbol\n",
    "mangling."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s._Student__id"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The \"private\" attribute is still accessible by prefixing it with\n",
    "`_<classname>__`.\n",
    "\n",
    "### Better to return a copy over a reference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "GPA = 3.5\n",
      "courses = {'gym': 4, 'math': 3}\n"
     ]
    }
   ],
   "source": [
    "import copy\n",
    "\n",
    "class Student:\n",
    "    def __init__(self, id):\n",
    "        self._id = id\n",
    "        self._gpa = 0.0\n",
    "        self._courses = {}\n",
    "    def get_id(self):\n",
    "        return self._id\n",
    "    def add_class(self, name, gradepoint):\n",
    "        self._courses[name] = gradepoint\n",
    "        sumgradepoints = float(sum(self._courses.values()))\n",
    "        self._gpa = sumgradepoints/len(self._courses)\n",
    "    def get_gpa(self):\n",
    "        return self._gpa\n",
    "    def get_courses(self):\n",
    "        return copy.deepcopy(self._courses)\n",
    "\n",
    "s = Student(7)\n",
    "s.add_class(\"gym\", 4)\n",
    "s.add_class(\"math\", 3)\n",
    "courses = s.get_courses()\n",
    "courses[\"english\"] = 4                         # Modify the copy of our dict.\n",
    "print(\"GPA = {}\".format(s.get_gpa()))          # Notice that GPA in our class object preserved.\n",
    "print(\"courses = {}\".format(s.get_courses()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### What not to do\n",
    "\n",
    "Python is dynamic, which is great.  But you should not do this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "class SimpleClass:\n",
    "    pass\n",
    "\n",
    "a = SimpleClass()\n",
    "a.new_attribute = \"hi cme211\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This adds an attribute to the object referred to by `a`, but not other objects\n",
    "of the same class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'SimpleClass' object has no attribute 'new_attribute'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-5af8c0e5d8b0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mSimpleClass\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mb\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnew_attribute\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'SimpleClass' object has no attribute 'new_attribute'"
     ]
    }
   ],
   "source": [
    "b = SimpleClass()\n",
    "b.new_attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators revisited\n",
    "\n",
    "A Python **iterator** is an object which implements methods `__iter__` and\n",
    "`__next__`. An object that contains an iterator is called **iterable**.\n",
    "Most of Python containers such as lists, tuples or sets are iterable.\n",
    "Here we show an example iterator class that returns powers of 2.\n",
    "(Source [programiz.com](https://www.programiz.com/python-programming/methods/built-in/list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 4, 8, 16]\n"
     ]
    }
   ],
   "source": [
    "class PowTwo:\n",
    "    def __init__(self, max):\n",
    "        self.max = max\n",
    "    \n",
    "    def __iter__(self):\n",
    "        self.num = 0\n",
    "        return self\n",
    "        \n",
    "    def __next__(self):\n",
    "        if(self.num >= self.max):\n",
    "            raise StopIteration\n",
    "        result = 2 ** self.num\n",
    "        self.num += 1\n",
    "        return result\n",
    "\n",
    "powTwo = PowTwo(5)\n",
    "powTwoIter = iter(powTwo)\n",
    "\n",
    "print(list(powTwoIter))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python's `iter()` function returns the iterator from an iterable object.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### Intro to object oriented programming summary\n",
    "\n",
    "* Object Oriented Programming is about implementing abstractions such that data,\n",
    "  and the associated operations on it, are represented in a way that is more\n",
    "  familiar to humans\n",
    "\n",
    "* Mechanics of object oriented programming are about the same as procedural programming, but developing\n",
    "  good abstractions can take a lot of thought\n",
    "\n",
    "### Recommended Reading\n",
    "\n",
    "*Learning Python, Fifth Edition* by Mark Lutz\n",
    "\n",
    "* Chapter 26: Object Oriented Programming: The Big Picture\n",
    "\n",
    "* Chapter 27: Class Coding Basics"
   ]
  }
 ],
 "metadata": {
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}