part07.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Efektywne programowanie w języku Python \n",
    "\n",
    "## wykład 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Object-Oriented Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- An **object** has identity\n",
    "- A **name** is a reference to an object\n",
    "- A **namespace** is an associative mapping from names to objects\n",
    "- An **attribute** is any name following a dot ('.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Class Definition Syntax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# the class keyword introduces a new class definition\n",
    "class ClassName:\n",
    "    <statement>\n",
    "    <statement>\n",
    "    ...\n",
    "# must be executed to have effect (like def)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Class Definitions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Statements are usually assignments or function definitions\n",
    "- Entering a class definition creates a new \"namespace\"-ish\n",
    "    - Really, a special **`__dict__`** attribute where others live\n",
    "- Exiting a class definition creates a class object\n",
    "    - Defining a class **==** creating a class object (like int, str)\n",
    "    - Defining a class **!=** instantiating a class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Class Objects vs. Instance Objects"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> **Defining a class** creates a class object\n",
    "> - Supports attribute reference and instantiation\n",
    "\n",
    "\n",
    "\n",
    "> **Instantiating a class** object creates an instance object\n",
    "> - Only supports attribute reference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Class Attribute References"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    \"\"\"A simple example class\"\"\"\n",
    "    num = 12345\n",
    "    \n",
    "    def greet(self):\n",
    "        return \"Hello world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Attribute References\n",
    "MyClass.num # => 12345 (int object)\n",
    "MyClass.greet # => <function f> (function object)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> **Warning!** Class attributes can be written to by the client"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class Instantiation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "# `x = MyClass(args)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "**\"Instantiating\"** a class constructs an instance object of that class object.\n",
    "\n",
    "In this case, x is an instance object of the MyClass class object"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Custom Constructor using `__init__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Complex:\n",
    "    def __init__(self, realpart=0, imagpart=0):\n",
    "        self.real = realpart\n",
    "        self.imag = imagpart"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> Class instantiation calls the special method `__init__` if it exists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# Make an instance object `c`!\n",
    "c = Complex(3.0, -4.5)\n",
    "c.real, c.imag # => (3.0, -4.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "`__init__` vs.  `__new__`\n",
    "\n",
    "https://dev.to/delta456/python-init-is-not-a-constructor-12on"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Instance Objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "c = Complex(3.0, -4.5)\n",
    "\n",
    "# Get attributes\n",
    "c.real, c.imag # => (3.0, -4.5)\n",
    "\n",
    "# Set attributes\n",
    "c.real = -9.2\n",
    "c.imag = 4.1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Instance Attribute Reference Resolution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class MyOtherClass():\n",
    "    num = 12345\n",
    "    def __init__(self):\n",
    "        self.num = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "12345\n"
     ]
    },
    {
     "ename": "AttributeError",
     "evalue": "type object 'MyOtherClass' has no attribute 'num'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-6-1016c1966f45>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;31m# 0 or 12345?\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mMyOtherClass\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 6\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mMyOtherClass\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mnum\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: type object 'MyOtherClass' has no attribute 'num'"
     ]
    }
   ],
   "source": [
    "x = MyOtherClass()\n",
    "print(x.num) # 0 or 12345?\n",
    "del x.num\n",
    "print(x.num) # 0 or 12345?\n",
    "del MyOtherClass.num\n",
    "print(MyOtherClass.num)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> Attribute references first search the instance's `__dict__` attribute, then the class object's"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Setting Data Attributes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "# You can set attributes on instance (and class) objects\n",
    "# on the fly (we used this in the constructor!)\n",
    "c.counter = 1\n",
    "while c.counter < 10:\n",
    "    c.counter = x.counter * 2\n",
    "    print(c.counter)\n",
    "\n",
    "del c.counter # Leaves no trace\n",
    "\n",
    "# prints 1, 2, 4, 8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> Setting attributes actually inserts into the instance object's `__dict__` attribute"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Methods vs. Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    \"\"\"A simple example class\"\"\"\n",
    "    num = 12345\n",
    "    def greet(self):\n",
    "        return \"Hello world!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x = MyClass()\n",
    "x.greet() # 'Hello world!'\n",
    "# Weird... doesn't `greet` accept an argument?\n",
    "\n",
    "print(type(x.greet)) # method\n",
    "print(type(MyClass.greet)) # function\n",
    "\n",
    "print(x.num is MyClass.num) # True\n",
    "print(x.greet is MyClass.greet) # False"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "A **method** is a function bound to an object \n",
    "> method ≈ (object, function)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Methods calls invoke special semantics\n",
    "\n",
    "> object.method(arguments) = function(object, arguments)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Pizza:\n",
    "    def __init__(self, radius, toppings, slices=8):\n",
    "        self.radius = radius\n",
    "        self.toppings = toppings\n",
    "        self.slices_left = slices\n",
    "    def eat_slice(self):\n",
    "        if self.slices_left > 0:\n",
    "            self.slices_left -= 1\n",
    "        else:\n",
    "            print(\"Oh no! Out of pizza\")\n",
    "    def __repr__(self):\n",
    "        return '{}\" pizza'.format(self.radius)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<function Pizza.eat_slice at 0x00000222FB341158>\n"
     ]
    }
   ],
   "source": [
    "p = Pizza(14, (\"Pepperoni\", \"Olives\"), slices=12)\n",
    "print(Pizza.eat_slice)\n",
    "# => <function Pizza.eat_slice>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<bound method Pizza.eat_slice of 14\" pizza>\n"
     ]
    }
   ],
   "source": [
    "print(p.eat_slice)\n",
    "# => <bound method Pizza.eat_slice of 14\" Pizza>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "method = p.eat_slice\n",
    "method.__self__ # => 14\" Pizza\n",
    "method.__func__ # => <function Pizza.eat_slice>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "p.eat_slice() # Implicitly calls Pizza.eat_slice(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Class and Instance Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dog:\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",
    "        \n",
    "a = Dog('Astro')\n",
    "pb = Dog('Mr. Peanut Butter')\n",
    "\n",
    "a.kind      # 'Canine' (shared by all dogs)\n",
    "pb.kind    # 'Canine' (shared by all dogs)\n",
    "a.name   # 'Astro' (unique to a)\n",
    "pb.name # 'Mr. Peanut Butter' (unique to pb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Warning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    tricks = []\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> What could go wrong?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d = Dog('Fido')\n",
    "e = Dog('Buddy')\n",
    "d.add_trick('roll over')\n",
    "e.add_trick('play dead')\n",
    "d.tricks # => ['roll over', 'play dead'] (shared value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Solution I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    # Let's try a default argument!\n",
    "    def __init__(self, name='', tricks=[]):\n",
    "        self.name = name\n",
    "        self.tricks = tricks\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['roll over', 'play dead']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Dog('Fido')\n",
    "e = Dog('Buddy')\n",
    "d.add_trick('roll over')\n",
    "e.add_trick('play dead')\n",
    "d.tricks # => ['roll over', 'play dead'] (shared value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Solution II"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Dog:\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "        self.tricks = [] # New list for each dog\n",
    "    def add_trick(self, trick):\n",
    "        self.tricks.append(trick)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "d = Dog('Fido')\n",
    "e = Dog('Buddy')\n",
    "d.add_trick('roll over')\n",
    "e.add_trick('play dead')\n",
    "d.tricks # => ['roll over']\n",
    "e.tricks # => ['play dead']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Privacy and Style"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "# Nothing is truly private!\n",
    "# Clients can modify anything\n",
    "# \"With great power…\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Stylistic Conventions\n",
    "\n",
    "- A method's first parameter should always be **`self`**\n",
    "    - Why? Explicitly differentiate instance and local variables\n",
    "    - Method calls already provide the calling object as the first argument to the class function\n",
    "- Attribute names prefixed with a leading underscore are intended to be private (e.g. _spam)\n",
    "- Use verbs for methods and nouns for data attributes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class DerivedClassName(BaseClassName):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Facts about Single Inheritance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- A class object 'remembers' its base class\n",
    "- Python 3 class objects inherit from object (by default)\n",
    "- Method and attribute lookup begins in the derived class\n",
    "    - Proceeds down the chain of base classes\n",
    "- Derived methods override (shadow) base methods\n",
    "    - Like `virtual` in C++"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Multiple Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Derived(Base1, Base2, …, BaseN):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Attribute Resolution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Attribute lookup is (almost) depth-first, left-to-right\n",
    "- Officially, **C3 superclass linearization** ([Wikipedia](https://en.wikipedia.org/wiki/C3_linearization#Example))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "Class objects have a (hidden) function attribute .mro()\n",
    "- Shows linearization of base classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class A: pass\n",
    "class B: pass\n",
    "class C: pass\n",
    "class D: pass\n",
    "class E: pass\n",
    "class K1(A, B, C): pass\n",
    "class K2(D, B, E): pass\n",
    "class K3(D, A): pass\n",
    "class Z(K1, K2, K3): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Z.mro() # [Z, K1, K2, K3, D, A, B, C, E, object]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Magic Methods"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Python uses `__init__`to build classes\n",
    "    - Overriding `__init__` lets us hook into the language\n",
    "- What else can we do? Can we define classes that act like:\n",
    "    - iterators? lists?\n",
    "    - sets? dictionaries?\n",
    "    - numbers?\n",
    "    - comparables?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class MagicClass:\n",
    "    def __init__(self): pass\n",
    "    def __contains__(self, key): pass\n",
    "    def __add__(self, other): pass\n",
    "    def __iter__(self): pass\n",
    "    def __next__(self): pass\n",
    "    def __getitem__(self, key): pass\n",
    "    def __len__(self): pass\n",
    "    def __lt__(self, other): pass\n",
    "    def __eq__(self, other): pass\n",
    "    def __str__(self): pass\n",
    "    def __repr__(self): pass # And even more..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = MagicClass()\n",
    "y = MagicClass()\n",
    "str(x) # => x.__str__()\n",
    "x == y # => x.__eq__(y)\n",
    "\n",
    "x < y # => x.__lt__(y)\n",
    "x + y # => x.__add__(y)\n",
    "iter(x) # => x.__iter__()\n",
    "next(x) # => x.__next__()\n",
    "len(x) # => x.__len__()\n",
    "el in x # => x.__contains__(el)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### Example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "class Point:\n",
    "    def __init__(self, x=0, y=0):\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "    def rotate_90_CC(self):\n",
    "        self.x, self.y = -self.y, self.x\n",
    "    def __add__(self, other):\n",
    "        return Point(self.x + other.x, self.y + other.y)\n",
    "    def __str__(self):\n",
    "        return \"Point({0}, {1})\".format(self.x, self.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "o = Point()\n",
    "print(o) # Point(0, 0)\n",
    "\n",
    "p1 = Point(3, 5)\n",
    "p2 = Point(4, 6)\n",
    "print(p1, p2) # Point(3, 5) Point(4, 6)\n",
    "\n",
    "p1.rotate_90_CC()\n",
    "\n",
    "print(p1) # Point(-5, 3)\n",
    "print(p1 + p2) # Point(-1, 9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "https://python-course.eu/oop/magic-methods.php"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Iterators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "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": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "rev = Reverse('spam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<__main__.Reverse at 0x222fb2bd390>"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "iter(rev)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "m\n",
      "a\n",
      "p\n",
      "s\n"
     ]
    }
   ],
   "source": [
    "for char in rev:\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## instance method / class method / static method"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def method(self):\n",
    "        return 'instance method called', self\n",
    "\n",
    "    @classmethod\n",
    "    def classmethod(cls):\n",
    "        return 'class method called', cls\n",
    "\n",
    "    @staticmethod\n",
    "    def staticmethod():\n",
    "        return 'static method called'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Instance Methods\n",
    "The first method on `MyClass`, called method, is a regular instance method. That’s the basic, no-frills method type you’ll use most of the time. You can see the method takes one parameter, `self`, which points to an instance of MyClass when the method is called (but of course instance methods can accept more than just one parameter).\n",
    "\n",
    "Through the self parameter, instance methods can freely access attributes and other methods on the same object. This gives them a lot of power when it comes to modifying an object’s state.\n",
    "\n",
    "Not only can they modify object state, instance methods can also access the class itself through the `self.__class__` attribute. This means instance methods can also modify class state."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Class Methods\n",
    "Let’s compare that to the second method, MyClass.classmethod. I marked this method with a `@classmethod` decorator to flag it as a class method.\n",
    "\n",
    "Instead of accepting a `self` parameter, class methods take a `cl`s parameter that points to the class — and not the object instance — when the method is called.\n",
    "\n",
    "Because the class method only has access to this `cls` argument, it can’t modify object instance state. That would require access to `self.` However, class methods can still modify class state that applies across all instances of the class.\n",
    "\n",
    "**The biggest reason for using a @classmethod is in an alternate constructor that is intended to be inherited**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Pizza:\n",
    "    def __init__(self, ingredients):\n",
    "        self.ingredients = ingredients\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f'Pizza({self.ingredients!r})'\n",
    "\n",
    "    @classmethod\n",
    "    def margherita(cls):\n",
    "        return cls(['mozzarella', 'tomatoes'])\n",
    "\n",
    "    @classmethod\n",
    "    def prosciutto(cls):\n",
    "        return cls(['mozzarella', 'tomatoes', 'ham'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    ">>> Pizza.margherita()\n",
    "Pizza(['mozzarella', 'tomatoes'])\n",
    "\n",
    ">>> Pizza.prosciutto()\n",
    "Pizza(['mozzarella', 'tomatoes', 'ham'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Static Methods\n",
    "The third method, `MyClass.staticmethod` was marked with a `@staticmethod` decorator to flag it as a static method.\n",
    "\n",
    "This type of method takes neither a `self` nor a `cls` parameter (but of course it’s free to accept an arbitrary number of other parameters).\n",
    "\n",
    "Therefore a static method can neither modify object state nor class state. Static methods are restricted in what data they can access - and they’re primarily a way to namespace your methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "class Pizza:\n",
    "    def __init__(self, radius, ingredients):\n",
    "        self.radius = radius\n",
    "        self.ingredients = ingredients\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (f'Pizza({self.radius!r}, '\n",
    "                f'{self.ingredients!r})')\n",
    "\n",
    "    def area(self):\n",
    "        return self.circle_area(self.radius)\n",
    "\n",
    "    @staticmethod\n",
    "    def circle_area(r):\n",
    "        return r ** 2 * math.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    ">>> p = Pizza(4, ['mozzarella', 'tomatoes'])\n",
    ">>> p\n",
    "Pizza(4, ['mozzarella', 'tomatoes'])\n",
    ">>> p.area()\n",
    "50.26548245743669\n",
    ">>> Pizza.circle_area(4)\n",
    "50.26548245743669"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Errors and Exceptions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Errors before execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-11-614901b0e5ee>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-11-614901b0e5ee>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    while True print('Hello world')\u001b[0m\n\u001b[1;37m                   ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "while True print('Hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Errors during execution"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-9ce172bd90a7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m10\u001b[0m \u001b[1;33m*\u001b[0m \u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m/\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "10 * (1/0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'spam' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-14-6b1dfe582d2e>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m4\u001b[0m \u001b[1;33m+\u001b[0m \u001b[0mspam\u001b[0m\u001b[1;33m*\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'spam' is not defined"
     ]
    }
   ],
   "source": [
    "4 + spam*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "must be str, not int",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-4c6dd5170204>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;34m'2'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: must be str, not int"
     ]
    }
   ],
   "source": [
    "'2' + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## And many more...\n",
    "\n",
    "[ Built-in Exceptions - Exception hierarchy](https://docs.python.org/3/library/exceptions.html#exception-hierarchy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Handling Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def read_int():\n",
    "    \"\"\"Reads an integer from the user (broken)\"\"\"\n",
    "    return int(input(\"Please enter a number: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "What happens if the user enters a nonnumeric input?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def read_int():\n",
    "    \"\"\"Reads an integer from the user (fixed)\"\"\"\n",
    "    while True:\n",
    "        try:\n",
    "            x = int(input(\"Please enter a number: \"))\n",
    "            break\n",
    "        except ValueError:\n",
    "            print(\"Oops! Invalid input. Try again...\")\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Mechanics of try statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Attempt to execute the try clause\n",
    "\n",
    "then \n",
    "\n",
    "- If no exception occurs, skip the except clause. Done!\n",
    "- If an exception occurs, skip the rest of the try clause.\n",
    "    - If the exception's type matches (/ is a subclass of) that named by except, then execute the except clause. Done!\n",
    "    - Otherwise, hand off the exception to any outer try statements. If unhandled, halt execution. Done!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How far? d\n",
      "invalid literal for int() with base 10: 'd'\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    distance = int(input(\"How far? \"))\n",
    "    time = car.speed / distance\n",
    "    car.drive(time)\n",
    "except ValueError as e: # Bind a name to the exception instance\n",
    "    print(e)\n",
    "except ZeroDivisionError:\n",
    "    print(\"Division by zero!\")\n",
    "except (NameError, AttributeError): # Catch multiple exceptions\n",
    "    print(\"Bad Car\")\n",
    "except: # \"Wildcard\" catches everything\n",
    "    print(\"Car unexpectedly crashed!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def read_int():\n",
    "    \"\"\"Reads an integer from the user (fixed?)\"\"\"\n",
    "    while True:\n",
    "        try:\n",
    "            x = int(input(\"Please enter a number: \"))\n",
    "            break\n",
    "        except: # catch all exceptions\n",
    "            print(\"Oops! Invalid input. Try again...\")\n",
    "    return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Raising Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "Why hello there!",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-18-1ea802685ca5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mNameError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Why hello there!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: Why hello there!"
     ]
    }
   ],
   "source": [
    "raise NameError('Why hello there!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-19-a586bde47246>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;32mraise\u001b[0m \u001b[0mNameError\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "raise NameError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Looks like an exception to me!\n"
     ]
    },
    {
     "ename": "NotImplementedError",
     "evalue": "TODO",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-20-9fc1915596f8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mtry\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"TODO\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[1;32mexcept\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Looks like an exception to me!'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32mraise\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNotImplementedError\u001b[0m: TODO"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    raise NotImplementedError(\"TODO\")\n",
    "except NotImplementedError:\n",
    "    print('Looks like an exception to me!')\n",
    "    raise\n",
    "# Looks like an exception to me!\n",
    "# Traceback (most recent call last):\n",
    "# File \"<stdin>\", line 2, in <module>\n",
    "# NotImplementedError: TODO"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Using `else`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    # ...\n",
    "except ...:\n",
    "    # ...\n",
    "else:  # Code that executes if the try clause does not raise an exception\n",
    "    do_something()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "> Why? Avoid accidentally catching an exception raised by something other than the code being protected"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    update_the_database()\n",
    "except TransactionError:\n",
    "    rollback()\n",
    "    raise\n",
    "else:\n",
    "    commit()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "Same usefull tips:\n",
    "    \n",
    "- Don't check if a file exists, then open it.\n",
    "    - Just try to open it!\n",
    "    - Handle exceptional cases with an except clause (or two) (avoids race conditions too)\n",
    "- Don't check if a queue is nonempty before popping\n",
    "    - Just try to pop the element!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Custom Exceptions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "class Error(Exception):\n",
    "    \"\"\"Base class for errors in this module.\"\"\"\n",
    "    pass\n",
    "class BadLoginError(Error):\n",
    "    \"\"\"A user attempted to login with\n",
    "    an incorrect password.\"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "UNDEFINED = object()\n",
    "def divide_json(path):\n",
    "    handle = open(path, ‘r+’) # May raise IOError\n",
    "    try:\n",
    "        data = handle.read() # May raise UnicodeDecodeError\n",
    "        op = json.loads(data) # May raise ValueError\n",
    "        value = (\n",
    "        op[‘numerator’] /\n",
    "        op[‘denominator’]) # May raise ZeroDivisionError\n",
    "    except ZeroDivisionError as e:\n",
    "        return UNDEFINED\n",
    "    else:\n",
    "        op[‘result’] = value\n",
    "        result = json.dumps(op)\n",
    "        handle.seek(0)\n",
    "        handle.write(result) # May raise IOError\n",
    "        return value\n",
    "    finally:\n",
    "        handle.close() # Always runs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_json_key(data, key):\n",
    "    try:\n",
    "        result_dict = json.loads(data) # May raise ValueError\n",
    "    except ValueError as e:\n",
    "        raise KeyError from e\n",
    "    else:\n",
    "        return result_dict[key] # May raise KeyError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Clean-Up Actions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "The `finally` clause"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "try:\n",
    "    raise NotImplementedError\n",
    "finally:\n",
    "    print('Goodbye, world!')\n",
    "# Goodbye, world!\n",
    "# Traceback (most recent call last):\n",
    "# File \"<stdin>\", line 2, in <module>\n",
    "# NotImplementedError"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "#### How finally works"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "- Always executed before leaving the try statement.\n",
    "- Unhandled exceptions (not caught, or raised in except) are re-raised after finally executes.\n",
    "- Also executed \"on the way out\" (break, continue, return)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# This is what enables us to use with ... as ...\n",
    "with open(filename) as f:\n",
    "    raw = f.read()\n",
    "\n",
    "# is (almost) equivalent to\n",
    "f = open(filename)\n",
    "f.__enter__()\n",
    "try:\n",
    "    raw = f.read()\n",
    "finally:\n",
    "    f.__exit__() # Closes the file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## You can do this better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def divide(a, b):\n",
    "    try:\n",
    "        return a / b\n",
    "    except ZeroDivisionError:\n",
    "        return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "result = divide(x, y)\n",
    "if result is None:\n",
    "    print('Invalid inputs')\n",
    "else:\n",
    "    print(x, y, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "... better way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def divide(a, b):\n",
    "    try:\n",
    "        return True, a / b\n",
    "    except ZeroDivisionError:\n",
    "        return False, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "success, result = divide(x, y)\n",
    "if not success:\n",
    "    print(‘Invalid inputs’)\n",
    "else:\n",
    "    print(x, y, result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "... or even better"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "def divide(a, b):\n",
    "    try:\n",
    "        return a / b\n",
    "    except ZeroDivisionError as e:\n",
    "        raise ValueError(‘Invalid inputs’) from e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "x, y = 5, 2\n",
    "try:\n",
    "    result = divide(x, y)\n",
    "except ValueError:\n",
    "    print(‘Invalid inputs’)\n",
    "else:\n",
    "    print(‘Result is %.1f’ % result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## with"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "with open(\"poem.txt\") as f:\n",
    "    for line in f:\n",
    "        print(line, end='')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "What happens behind the scenes is that there is a protocol used by the with statement. It fetches the object returned by the open statement, let's call it `f` in this case.\n",
    "\n",
    "It always calls the `f.__enter__` function before starting the block of code under it and always calls `f.__exit__` after finishing the block of code.\n",
    "\n",
    "So the code that we would have written in a finally block should be taken care of automatically by the `__exit__` method. This is what helps us to avoid having to use explicit `try..finally` statements repeatedly."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Metaclass\n",
    "\n",
    "https://realpython.com/python-data-classes/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Data Classes in Python\n",
    "\n",
    "https://realpython.com/python-data-classes/"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}