DefiningClasses.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:de081c2891a73ee7d899466c1e797336d35d118b5e26c7037dcd0de4bdd9a443"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "Classes in Python"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Alexandre M. S. on May 3rd, 2014"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python classes provide all the standard features of Object Oriented Programming: the class inheritance mechanism allows multiple base classes, a derived class can override any methods of its base class or classes, and a method can call the method of a base class with the same name. Objects can contain arbitrary amounts and kinds of data. As is true for modules, classes partake of the dynamic nature of Python: they are created at runtime, and can be modified further after creation."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##Python Scopes and Namespaces\n",
      "\n",
      "A *namespace* is a mapping from names to objects. Most namespaces are currently implemented as Python dictionaries, but that's normally not noticeable in any way (except for performance), and it may change in the future.\n",
      "\n",
      "There is absolutely no relation between names in different namespaces; for instance, two different modules may both define a function `maximize` without confusion - users of the modules must prefix it with the module name."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def scope_test():\n",
      "\n",
      "    def do_local():\n",
      "        spam = \"local spam\"\n",
      "\n",
      "    #this only works on python3\n",
      "    #def do_nonlocal():\n",
      "    #    nonlocal spam\n",
      "    #    spam = \"nonlocal spam\"\n",
      "\n",
      "    def do_global():\n",
      "        global spam\n",
      "        spam = \"global spam\"\n",
      "\n",
      "    spam = \"test spam\"\n",
      "    do_local()\n",
      "    print(\"After local assignment:\", spam)\n",
      "    #do_nonlocal()\n",
      "    #print(\"After nonlocal assignment:\", spam)\n",
      "    do_global()\n",
      "    print(\"After global assignment:\", spam)\n",
      "    \n",
      "    \n",
      "scope_test()\n",
      "print(\"In global scope:\", spam)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "After local assignment: test spam\n",
        "After global assignment: test spam\n",
        "In global scope: global spam\n"
       ]
      }
     ],
     "prompt_number": 1
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "The output of the previous code in Python3 is:\n",
      "\n",
      "`After local assignment: test spam`\n",
      "\n",
      "`After nonlocal assignment: nonlocal spam`\n",
      "\n",
      "`After global assignment: nonlocal spam`\n",
      "\n",
      "`In global scope: global spam`\n",
      "\n",
      "Note how the local assignment (which is default) didn\u2019t change scope_test\u2018s binding of spam. The nonlocal assignment changed scope_test\u2018s binding of spam, and the global assignment changed the module-level binding."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "**Note:** The `nonlocal` statement causes the listed identifiers to refer to previously bound variables in the nearest enclosing scope. This is important because the default behavior for binding is to search the local namespace first. The statement allows encapsulated code to rebind variables outside of the local scope besides the global (module) scope."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##A first look at classes\n",
      "\n",
      "The simplest form of class definition looks like this:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class ClassName:\n",
      "    <statement-1>\n",
      "    .\n",
      "    .\n",
      "    .\n",
      "    <statement-N>"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "SyntaxError",
       "evalue": "invalid syntax (<ipython-input-2-6e3c822e8552>, line 2)",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-2-6e3c822e8552>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    <statement-1>\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
       ]
      }
     ],
     "prompt_number": 2
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Class definitions, like function definitions (`def` statements) must be executed before they have any effect. (You could conceivably place a class definition in a branch of an `if` statement, or inside a function.)"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Class Objects\n",
      "\n",
      "Class objects support two kinds of operations: attribute references and instantiation."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class MyClass:\n",
      "    \"\"\"A simple example class\n",
      "    sdfasdf\n",
      "    \"\"\"\n",
      "    i = 12345\n",
      "    \n",
      "    @classmethod\n",
      "    def f(self):\n",
      "        i = 20\n",
      "        return 'hello world' + str(i)\n",
      "    \n",
      "x = MyClass()\n",
      "x.f()\n",
      "print x.i\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "12345\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "*Attribute references* use the standard syntax used for all attribute references in Python: `Myclass.i`.\n",
      "\n",
      "*Class instantiation* uses function notation: `x = MyClass()`"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###The `__init__()` method\n",
      "\n",
      "The instantiation operation (\u201ccalling\u201d a class object) creates an empty object. Many classes like to create objects with instances customized to a specific initial state. Therefore a class may define a special method named `__init__()`, like this:\n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def __init__(self):\n",
      "    self.data = []\n",
      "    self._filename = ''\n",
      "    \n",
      "class MyClass:\n",
      "    pass\n",
      "\n",
      "x = MyClass()\n",
      "x.update = __init__()\n",
      "x.update(x)\n",
      "dir(x)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 37,
       "text": [
        "['__doc__', '__module__', '_filename', 'data', 'update']"
       ]
      }
     ],
     "prompt_number": 37
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "When a class defines an `__init__()` method, class instantiation automatically invokes `__init__()` for the newly-created class instance. So in this example, a new, initialized instance can be obtained by:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Complex:\n",
      "    def __init__(self, realpart, imagpart):\n",
      "        self.r = realpart\n",
      "        self.i = imagpart\n",
      "\n",
      "\n",
      "x = Complex(3.0, -4.5)\n",
      "print x.r\n",
      "print x.i\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "3.0\n",
        "-4.5\n"
       ]
      },
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 41,
       "text": [
        "3.0"
       ]
      }
     ],
     "prompt_number": 41
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Random Remarks\n",
      "\n",
      "+ Data attributes override method attributes with the same name; to avoid accidental name conflicts, which may cause hard-to-find bugs in large programs, it is wise to use some kind of convention that minimizes the chance of conflicts.\n",
      "\n",
      "+ Any function object that is a class attribute defines a method for instances of that class. It is not necessary that the function definition is textually enclosed in the class definition: assigning a function object to a local variable in the class is also ok. For example:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# 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",
      "    def g(self):\n",
      "        return 'hello world'\n",
      "    h = g"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "+ Methods may call other methods by using method attributes of the self argument:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class Bag:\n",
      "    def __init__(this):\n",
      "        this.data = []\n",
      "        \n",
      "    def add(this, x):\n",
      "        this.data.append(x)\n",
      "        \n",
      "    def addtwice(this, x):\n",
      "        this.add(x)\n",
      "        this.add(x)\n",
      "        \n",
      "b = Bag()\n",
      "b.addtwice('this')\n",
      "print b.data"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "['this', 'this']\n"
       ]
      }
     ],
     "prompt_number": 46
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Inheritance\n",
      "The syntax for a derived class definition looks like this:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class DerivedClassName(BaseClassName):\n",
      "    <statement-1>\n",
      "    .\n",
      "    .\n",
      "    .\n",
      "    <statement-N>"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Derived classes may override methods of their base classes. Because methods have no special privileges when calling other methods of the same object, a method of a base class that calls another method defined in the same base class may end up calling a method of a derived class that overrides it. (For C++ programmers: all methods in Python are effectively `virtual`.)\n",
      "\n",
      "There is a simple way to call the base class method directly: just call `BaseClassName.methodname(self, arguments)`.\n",
      "\n",
      "To extend a method of a parent class, use the super() method:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class B:\n",
      "    pass\n",
      "\n",
      "class C(B):\n",
      "    def method(self, arg):\n",
      "        super().method(arg)    # This does the same thing as:\n",
      "                               # super(C, self).method(arg)\n",
      "x = C()\n",
      "#isinstance(x, B)\n",
      "issubclass(C, B)\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "<__main__.C instance at 0x7f379f2047e8>\n"
       ]
      }
     ],
     "prompt_number": 63
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Python has two built-in functions that work with inheritance:\n",
      "\n",
      "+ Use `isinstance()` to check an instance\u2019s type: `isinstance(obj, int)` will be `True` only if `obj.__class__` is `int` or some class derived from `int`.\n",
      "\n",
      "+ Use `issubclass()` to check class inheritance: `issubclass(bool, int)` is `True` since `bool` is a subclass of `int`. However, `issubclass(float, int)` is `False` since `float` is not a subclass of `int`."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Multiple Inheritance\n",
      "Python supports a form of multiple inheritance as well."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class DerivedClassName(Base1, Base2, Base3):\n",
      "    <statement-1>\n",
      "    .\n",
      "    .\n",
      "    .\n",
      "    <statement-N>"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Private Variables\n",
      "\"Private\" instance variables that cannot be accessed except from inside an object don't exist in Python.\n",
      "\n",
      "For more details: https://docs.python.org/3/tutorial/classes.html#private-variables"
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Exceptions Are Classes Too\n",
      "User-defined exceptions are identified by classes as well. Using this mechanism it is possible to create extensible hierarchies of exceptions."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "raise Class\n",
      "\n",
      "raise Instance"
     ],
     "language": "python",
     "metadata": {},
     "outputs": []
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class ErrorKaka(Exception):\n",
      "    pass\n",
      "class ErrorKakaVerde(ErrorKaka):\n",
      "    pass\n",
      "class ErrorKakaVerdePestilente(ErrorKakaVerde):\n",
      "    pass\n",
      "\n",
      "for cls in [ErrorKaka, ErrorKakaVerde, ErrorKakaVerdePestilente]:\n",
      "    try:\n",
      "        raise cls()\n",
      "    except ErrorKakaVerdePestilente:\n",
      "        print(\"es pestilente!\")\n",
      "    except ErrorKakaVerde:\n",
      "        print(\"es verde!\")\n",
      "    except ErrorKaka:\n",
      "        print(\"es una caca!\")"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "es una caca!\n",
        "es verde!\n",
        "es pestilente!\n"
       ]
      }
     ],
     "prompt_number": 65
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Iterators\n",
      "By now you have probably noticed that most container objects can be looped over using a `for` statement:"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for element in [1, 2, 3]:\n",
      "    print(element)\n",
      "\n",
      "for element in (1, 2, 3):\n",
      "    print(element)\n",
      "\n",
      "for key in {'one':1, 'two':2}:\n",
      "    print(key)\n",
      "\n",
      "for char in \"123\":\n",
      "    print(char)\n",
      "try:\n",
      "    for line in open(\"myfile.txt\"):\n",
      "        print(line)\n",
      "except IOError as e:\n",
      "    print (e)\n",
      "except:\n",
      "    print 'kaka'\n",
      "finally:\n",
      "    print 'finally'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1\n",
        "2\n",
        "3\n",
        "1\n",
        "2\n",
        "3\n",
        "two\n",
        "one\n",
        "1\n",
        "2\n",
        "3\n",
        "[Errno 2] No such file or directory: 'myfile.txt'\n",
        "finally\n"
       ]
      }
     ],
     "prompt_number": 70
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "Behind the scenes, the `for` statement calls `iter()` on the container object. The function returns an iterator object that defines the method `__next__()` which accesses elements in the container one at a time. \n",
      "\n",
      "When there are no more elements, `__next__()` raises a StopIteration exception which tells the `for` loop to terminate"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      ">>> s = 'abc'\n",
      ">>> it = iter(s)\n",
      ">>> it\n",
      "<iterator object at 0x00A1DB50>\n",
      ">>> next(it)\n",
      "'a'\n",
      ">>> next(it)\n",
      "'b'\n",
      ">>> next(it)\n",
      "'c'\n",
      ">>> next(it)\n",
      "Traceback (most recent call last):\n",
      "  File \"<stdin>\", line 1, in ?\n",
      "    next(it)\n",
      "StopIteration"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "ename": "SyntaxError",
       "evalue": "invalid syntax (<ipython-input-16-87d8f7b80d09>, line 4)",
       "output_type": "pyerr",
       "traceback": [
        "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-16-87d8f7b80d09>\"\u001b[1;36m, line \u001b[1;32m4\u001b[0m\n\u001b[1;33m    <iterator object at 0x00A1DB50>\u001b[0m\n\u001b[1;37m    ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
       ]
      }
     ],
     "prompt_number": 16
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "To add iterator behavior to your classes you have to 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",
     "collapsed": false,
     "input": [
      "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 -= 1\n",
      "        return self.data[self.index]\n",
      "    \n",
      "    def next(self):\n",
      "        return self.__next__()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 75
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "rev = Reverse('spam')\n",
      "iter(rev)\n",
      "\n",
      "for char in rev:\n",
      "    print(char)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "m\n",
        "a\n",
        "p\n",
        "s\n"
       ]
      }
     ],
     "prompt_number": 76
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Generators\n",
      "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.\n",
      "\n",
      "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)."
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def reverse(data):\n",
      "    for index in range(len(data)-1, -1, -1):\n",
      "        yield data[index]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 77
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "for char in reverse('golf'):\n",
      "    print(char)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "f\n",
        "l\n",
        "o\n",
        "g\n"
       ]
      }
     ],
     "prompt_number": 78
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "g = 'golf'\n",
      "[g[i] for i in range(len(g)-1, -1, -1)]"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 85,
       "text": [
        "['f', 'l', 'o', 'g']"
       ]
      }
     ],
     "prompt_number": 85
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "####Benefits of generators\n",
      "\n",
      "+ `__iter__()` and `__next__()` methods are created automatically,\n",
      "\n",
      "+ local variables and execution state are automatically saved between calls and\n",
      "\n",
      "+ when generators terminate, they automatically raise `StopIteration`."
     ]
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "##References\n",
      "\n",
      "[1] https://docs.python.org/3/tutorial/classes.html"
     ]
    }
   ],
   "metadata": {}
  }
 ]
}