9_ Magic Methods Properties Iterators.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Constructors\n",
    "class FooBar:\n",
    "    def __init__(self):    # constructor\n",
    "        self.somevar = 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = FooBar()\n",
    "f.somevar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class FooBar:\n",
    "    def __init__(self, value=42):\n",
    "        self.somevar = value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'This is a constructor argument'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = FooBar('This is a constructor argument')\n",
    "f.somevar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = FooBar()\n",
    "f.somevar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = FooBar(45)\n",
    "f.somevar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Method Overriding\n",
    "class A:\n",
    "    def hello(self):\n",
    "        print(\"Hello, I'm A.\")\n",
    "class B(A):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, I'm A.\n",
      "Hello, I'm A.\n"
     ]
    }
   ],
   "source": [
    "a = A()\n",
    "b = B()\n",
    "a.hello()\n",
    "b.hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "class A:\n",
    "    def hello(self):\n",
    "        print(\"Hello, I'm A.\")\n",
    "class B(A):\n",
    "    def hello(self):\n",
    "        print(\"Hello, I'm B.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, I'm A.\n",
      "Hello, I'm B.\n"
     ]
    }
   ],
   "source": [
    "a = A()\n",
    "b = B()\n",
    "a.hello()\n",
    "b.hello()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Bird:\n",
    "    def __init__(self):\n",
    "        self.hungry = True\n",
    "    def eat(self):\n",
    "        if self.hungry:\n",
    "            print('Aaaah ...')\n",
    "            self.hungry = False\n",
    "        else:\n",
    "            print('No, thanks!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Aaaah ...\n",
      "No, thanks!\n"
     ]
    }
   ],
   "source": [
    "b = Bird()\n",
    "b.eat()\n",
    "b.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Calling the super class constructor\n",
    "class SongBird(Bird):\n",
    "    def __init__(self):\n",
    "        Bird.__init__(self)\n",
    "        self.sound = 'Squawk!'\n",
    "    def sing(self):\n",
    "        print(self.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squawk!\n",
      "Aaaah ...\n",
      "No, thanks!\n"
     ]
    }
   ],
   "source": [
    "sb = SongBird()\n",
    "sb.sing()\n",
    "sb.eat()\n",
    "sb.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# using super function : A new way of usage\n",
    "class SongBird(Bird):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.sound = 'Squawk!'\n",
    "    def sing(self):\n",
    "        print(self.sound)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Squawk!\n",
      "Aaaah ...\n",
      "No, thanks!\n"
     ]
    }
   ],
   "source": [
    "sb = SongBird()\n",
    "sb.sing()\n",
    "sb.eat()\n",
    "sb.eat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# The Basic Sequence and Mapping Protocol\n",
    "__len__(self): length. For Sequence: # no items. For Mapping # no key-value pairs\n",
    "__getitem__(self): return the value. For Seq it will be integer, for mapping: any kind of key\n",
    "__setitem__(self, key, value)\n",
    "__delitem__(self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_index(key):\n",
    "    \"\"\"\n",
    "    Is the given key an acceptable index?\n",
    "    To be acceptable, the key should be a non-negative integer. If it\n",
    "    is not an integer, a TypeError is raised; if it is negative, an\n",
    "    IndexError is raised (since the sequence is of infinite length).\n",
    "    \"\"\"\n",
    "    if not isinstance(key, int): raise TypeError\n",
    "    if key < 0: raise IndexError\n",
    "        \n",
    "class ArithmeticSequence:\n",
    "    def __init__(self, start=0, step=1):\n",
    "        \"\"\"\n",
    "        Initialize the arithmetic sequence.\n",
    "        start - the first value in the sequence\n",
    "        step - the difference between two adjacent values\n",
    "        changed - a dictionary of values that have been modified by\n",
    "        the user\n",
    "        \"\"\"\n",
    "        self.start = start # Store the start value\n",
    "        self.step = step # Store the step value\n",
    "        self.changed = {} # No items have been modified\n",
    "    def __getitem__(self, key):\n",
    "        \"\"\"\n",
    "        Get an item from the arithmetic sequence.\n",
    "        \"\"\"\n",
    "        check_index(key)\n",
    "        try: return self.changed[key] # Modified?\n",
    "        except KeyError: # otherwise ...\n",
    "            return self.start + key * self.step # ... calculate the value\n",
    "    def __setitem__(self, key, value):\n",
    "        \"\"\"\n",
    "        Change an item in the arithmetic sequence.\n",
    "        \"\"\"\n",
    "        check_index(key)\n",
    "        self.changed[key] = value # Store the changed value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = ArithmeticSequence(1, 2)\n",
    "s[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subclassing list, dict, and str\n",
    "class CounterList(list):\n",
    "    def __init__(self, *args):\n",
    "        super().__init__(*args)\n",
    "        self.counter = 0\n",
    "    def __getitem__(self, index):\n",
    "        self.counter += 1\n",
    "        return super(CounterList, self).__getitem__(index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "cl = CounterList(range(10))\n",
    "print(cl)\n",
    "print(cl[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.reverse()\n",
    "cl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 8, 7, 3, 2, 1, 0]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del cl[3:6]\n",
    "cl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl[4]+cl[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cl.counter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# More Magic: Properties\n",
    "class Rectangle:\n",
    "    def __init__(self):\n",
    "        self.width = 0\n",
    "        self.height = 0\n",
    "    def set_size(self, size):\n",
    "        self.width, self.height = size\n",
    "    def get_size(self):\n",
    "        return self.width, self.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 5)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = Rectangle()\n",
    "r.width = 10\n",
    "r.height = 5\n",
    "r.get_size()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "150"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.set_size((150,100))\n",
    "r.width"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#  The get_size and set_size methods are accessors for a fictitious attribute called size—which is simply\n",
    "# the tuple consisting of width and height.\n",
    "# This code isn’t directly wrong, but it is flawed\n",
    "# If you someday wanted to change the implementation so that size was a real attribute and width and height\n",
    "# were calculated on the fly, you would need to wrap them in accessors, and any programs using the class\n",
    "# would also have to be rewritten\n",
    "\n",
    "# Solution 1: Property method\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__ (self):\n",
    "        self.width = 0\n",
    "        self.height = 0\n",
    "    def set_size(self, size):\n",
    "        self.width, self.height = size\n",
    "    def get_size(self):\n",
    "        return self.width, self.height\n",
    "    size = property(get_size, set_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 5)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r = Rectangle()\n",
    "r.width = 10\n",
    "r.height = 5\n",
    "r.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r.size = (15, 25)\n",
    "r.height"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Static Methods and Class Methods\n",
    "# Static methods and class methods are created by wrapping methods in objects of the staticmethod and classmethod classes resp\n",
    "# Static methods are defined without self arguments, and they can be called directly on the class itself\n",
    "# Class methods are defined with a self-like parameter normally called cls, You can call class methods directly on the class \n",
    "#     object too, but the cls parameter then automatically is bound to the class\n",
    "class MyClass:\n",
    "    def smeth():\n",
    "        print('This is a static method')\n",
    "    smeth = staticmethod(smeth)\n",
    "    def cmeth(cls):\n",
    "        print('This is a class method of', cls)\n",
    "    cmeth = classmethod(cmeth)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a static method\n"
     ]
    }
   ],
   "source": [
    "obj = MyClass()\n",
    "MyClass.smeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a static method\n"
     ]
    }
   ],
   "source": [
    "obj.smeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a class method of <class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "obj.cmeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a class method of <class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "MyClass.cmeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'int' object has no attribute 'width'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-0b28cc90a893>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mRectangle\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mget_size\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-6-49bfffce5c62>\u001b[0m in \u001b[0;36mget_size\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m      7\u001b[0m         \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwidth\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mheight\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0msize\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m     \u001b[1;32mdef\u001b[0m \u001b[0mget_size\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mself\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m         \u001b[1;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mwidth\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mheight\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'int' object has no attribute 'width'"
     ]
    }
   ],
   "source": [
    "Rectangle.get_size(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# or we can use decorators @\n",
    "class MyClass:\n",
    "    @staticmethod\n",
    "    def smeth():\n",
    "        print('This is a static method')\n",
    "    @classmethod\n",
    "    def cmeth(cls):\n",
    "        print('This is a class method of', cls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a static method\n",
      "This is a class method of <class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "MyClass.smeth()\n",
    "MyClass.cmeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a static method\n",
      "This is a class method of <class '__main__.MyClass'>\n"
     ]
    }
   ],
   "source": [
    "obj1 = MyClass()\n",
    "obj1.smeth()\n",
    "obj1.cmeth()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# __getattr__, __setattr__, and Friends\n",
    "# It’s possible to intercept every attribute access on an object. Among other things, you could use this to\n",
    "#   implement properties with old-style classes (where property won’t necessarily work as it should)\n",
    "#__getattribute__(self, name): Automatically called when the attribute name is accessed. (This works correctly on new-style classes only.)\n",
    "# __getattr__(self, name): Automatically called when the attribute name is accessed and the object has no such attribute.\n",
    "# __setattr__(self, name, value): Automatically called when an attempt is made to bind the attribute name to value.\n",
    "# __delattr__(self, name): Automatically called when an attempt is made to delete the attribute name.\n",
    "\n",
    "class Rectangle:\n",
    "    def __init__ (self):\n",
    "        self.width = 0\n",
    "        self.height = 0\n",
    "    def __setattr__(self, name, value):\n",
    "        if name == 'size':\n",
    "            self.width, self.height = value\n",
    "        else:\n",
    "            self. __dict__[name] = value\n",
    "    def __getattr__(self, name):\n",
    "        if name == 'size':\n",
    "            return self.width, self.height\n",
    "        else:\n",
    "            raise AttributeError()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "rr = Rectangle()\n",
    "rr.size = (100,150)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 150)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "rr.abhi = (100,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, 10)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rr.abhi  # __getattribute__ is automatically called, abhi param is added to dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "#iterators\n",
    "# To iterate means to repeat something several times\n",
    "# The __iter__ method returns an iterator, which is any object with a method called __next__, which is callable without any arguments.\n",
    "# When you call the __next__ method, the iterator should return its “next value.”\n",
    "# If the method is called and the iterator has no more values to return, it should raise a StopIteration exception.\n",
    "# There is a built-in convenience function called next that you can use, where next(it) is equivalent to it.__next__().\n",
    "\n",
    "class Fibs:\n",
    "    def __init__(self):\n",
    "        self.a = 0\n",
    "        self.b = 1\n",
    "    def __next__(self):\n",
    "        self.a, self.b = self.b, self.a + self.b\n",
    "        if self.b > 100: raise StopIteration \n",
    "        return self.a\n",
    "    def __iter__(self):\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "fibs = Fibs()\n",
    "for f in fibs:\n",
    "    print(f)\n",
    "    if f>1000: \n",
    "        break\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "it = iter([1, 2, 3])\n",
    "next(it)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TestIterator:\n",
    "    value = 0\n",
    "    def __next__(self):\n",
    "        self.value += 1\n",
    "        if self.value > 10: raise StopIteration\n",
    "        return self.value\n",
    "    def __iter__(self):\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ti = TestIterator()\n",
    "list(ti)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Generators\n",
    "# A generator is a kind of iterator that is defined with normal function\n",
    "def flatten(nested):\n",
    "    for sublist in nested:\n",
    "        for element in sublist:\n",
    "            yield element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "nested = [[1, 2], [3, 4], [5]]\n",
    "for num in flatten(nested):\n",
    "    print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g = ((i + 2) ** 2 for i in range(2, 27))  #interative generators\n",
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(i ** 2 for i in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(i for i in range(11))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# There is a lot of work in building an iterator in Python. We have to implement a class with __iter__() and __next__() method, keep track of internal states, \n",
    "# and raise StopIteration when there are no values to be returned.\n",
    "# This is both lengthy and counterintuitive. Generator comes to the rescue in such situations.\n",
    "# Python generators are a simple way of creating iterators. All the work we mentioned above are automatically handled by generators in Python.\n",
    "# It is fairly simple to create a generator in Python. It is as easy as defining a normal function, but with a yield statement instead of a return statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_gen():\n",
    "    n = 1\n",
    "    print('This is printed first')\n",
    "    # Generator function contains yield statements\n",
    "    yield n\n",
    "\n",
    "    n += 1\n",
    "    print('This is printed second')\n",
    "    yield n\n",
    "\n",
    "    n += 1\n",
    "    print('This is printed at last')\n",
    "    yield n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is printed first\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = my_gen()\n",
    "next(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is printed second\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is printed at last\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-29-15841f3f11d4>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is printed first\n",
      "1\n",
      "This is printed second\n",
      "2\n",
      "This is printed at last\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# or\n",
    "for item in my_gen():\n",
    "    print(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Differences between Generator function and a Normal function\n",
    "\n",
    "#Here is how a generator function differs from a normal function.\n",
    "\n",
    " #   Generator function contains one or more yield statements.\n",
    " #   When called, it returns an object (iterator) but does not start execution immediately.\n",
    " #   Methods like __iter__() and __next__() are implemented automatically. So we can iterate through the items using next().\n",
    " #   Once the function yields, the function is paused and the control is transferred to the caller.\n",
    " #   Local variables and their states are remembered between successive calls.\n",
    " #   Finally, when the function terminates, StopIteration is raised automatically on further calls.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n",
      "l\n",
      "l\n",
      "e\n",
      "h\n"
     ]
    }
   ],
   "source": [
    "# Python Generators with a Loop\n",
    "def rev_str(my_str):\n",
    "    length = len(my_str)\n",
    "    for i in range(length - 1, -1, -1):\n",
    "        yield my_str[i]\n",
    "\n",
    "\n",
    "# For loop to reverse the string\n",
    "for char in rev_str(\"hello\"):\n",
    "    print(char)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "Hello\n",
      "hi\n"
     ]
    }
   ],
   "source": [
    "# https://www.programiz.com/python-programming/generator\n",
    "\n",
    "# Python closures\n",
    "# First look to Nonlocal variable in a nested function\n",
    "def print_msg(msg):\n",
    "# This is the outer enclosing function\n",
    "\n",
    "    def printer():\n",
    "# This is the nested function\n",
    "        print(msg)\n",
    "    \n",
    "    print(\"hello\")\n",
    "    printer()\n",
    "    print(\"hi\")\n",
    "\n",
    "# We execute the function\n",
    "# Output: Hello\n",
    "print_msg(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# In the example above, what would happen if the last line of the function print_msg() returned the printer() function \n",
    "# instead of calling it? This means the function was defined as follows.\n",
    "\n",
    "def print_msg(msg):\n",
    "# This is the outer enclosing function\n",
    "\n",
    "    def printer():\n",
    "# This is the nested function\n",
    "        print(msg)\n",
    "\n",
    "    return printer  # this got changed\n",
    "\n",
    "# Now let's try calling this function.\n",
    "# Output: Hello\n",
    "another = print_msg(\"Hello\")\n",
    "another()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'print_msg' 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-4-f48ddd5d4c4f>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;32mdel\u001b[0m \u001b[0mprint_msg\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0manother\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint_msg\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Hello\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m: name 'print_msg' is not defined"
     ]
    }
   ],
   "source": [
    "# The print_msg() function was called with the string \"Hello\" and the returned function was bound to the name another. On calling another(), \n",
    "#the message was still remembered although we had already finished executing the print_msg() function.\n",
    "\n",
    "# This technique by which some data (\"Hello\") gets attached to the code is called closure in Python.\n",
    "del print_msg\n",
    "another()\n",
    "print_msg(\"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "27\n",
      "15\n",
      "30\n"
     ]
    }
   ],
   "source": [
    "# When do we have a closure?\n",
    "\n",
    "#    We must have a nested function (function inside a function).\n",
    "#   The nested function must refer to a value defined in the enclosing function.\n",
    "#    The enclosing function must return the nested function.\n",
    "\n",
    "#\n",
    "# Closures can avoid the use of global values and provides some form of data hiding. It can also provide an object oriented solution to the problem.\n",
    "# When there are few methods (one method in most cases) to be implemented in a class, closures can provide an alternate and more elegant solutions. \n",
    "#   But when the number of attributes and methods get larger, better implement a class.\n",
    "# Here is a simple example where a closure might be more preferable than defining a class and making objects. But the preference is all yours.\n",
    "\n",
    "\n",
    "def make_multiplier_of(n):\n",
    "    def multiplier(x):\n",
    "        return x * n\n",
    "    return multiplier\n",
    "\n",
    "# Multiplier of 3\n",
    "times3 = make_multiplier_of(3)\n",
    "\n",
    "# Multiplier of 5\n",
    "times5 = make_multiplier_of(5)\n",
    "\n",
    "# Output: 27\n",
    "print(times3(9))\n",
    "\n",
    "# Output: 15\n",
    "print(times5(3))\n",
    "\n",
    "# Output: 30\n",
    "print(times5(times3(2)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Decorators\n",
    "# Functions can be passed as arguments to another function.\n",
    "# Such function that take other functions as arguments are also called higher order functions\n",
    "def inc(x):\n",
    "    return x + 1\n",
    "\n",
    "def dec(x):\n",
    "    return x - 1\n",
    "\n",
    "def operate(func, x):\n",
    "    result = func(x)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operate(inc,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "operate(dec,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "# a function can return another function.\n",
    "def is_called():\n",
    "    def is_returned():\n",
    "        print(\"Hello\")\n",
    "    return is_returned\n",
    "\n",
    "new = is_called()\n",
    "\n",
    "#Outputs \"Hello\"\n",
    "new()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am ordinary\n",
      "----\n",
      "I got decorated\n",
      "I am ordinary\n"
     ]
    }
   ],
   "source": [
    "# a decorator takes in a function, adds some functionality and returns it.\n",
    "def make_pretty(func):\n",
    "    def inner():\n",
    "        print(\"I got decorated\")\n",
    "        func()\n",
    "    return inner\n",
    "\n",
    "def ordinary():\n",
    "    print(\"I am ordinary\")\n",
    "    \n",
    "ordinary()\n",
    "\n",
    "print(\"----\")\n",
    "p = make_pretty(ordinary)\n",
    "p()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Decorating Functions with Parameters\n",
    "# Simple defination\n",
    "def divide(a, b):\n",
    "    return a/b\n",
    "\n",
    "divide(5,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am going to divide 2 and 0\n",
      "Whoops! cannot divide\n"
     ]
    }
   ],
   "source": [
    "# Using decorator\n",
    "def smart_divide(func):\n",
    "   def inner(a,b):\n",
    "      print(\"I am going to divide\",a,\"and\",b)\n",
    "      if b == 0:\n",
    "         print(\"Whoops! cannot divide\")\n",
    "         return\n",
    "\n",
    "      return func(a,b)\n",
    "   return inner\n",
    "\n",
    "@smart_divide\n",
    "def divide(a,b):\n",
    "    return a/b\n",
    "\n",
    "\n",
    "divide(2,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******************************\n",
      "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
      "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
      "******************************\n"
     ]
    }
   ],
   "source": [
    "# Chaining Decorators in Python\n",
    "def star(func):\n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"*\" * 30)\n",
    "        func(*args, **kwargs)\n",
    "        print(\"*\" * 30)\n",
    "    return inner\n",
    "\n",
    "def percent(func):\n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"%\" * 30)\n",
    "        func(*args, **kwargs)\n",
    "        print(\"%\" * 30)\n",
    "    return inner\n",
    "\n",
    "@star\n",
    "@percent\n",
    "def printer(msg):\n",
    "    print(msg)\n",
    "    \n",
    "printer(\"Hello\")\n",
    "\n",
    "# this is equals to \n",
    "# def printer(msg):\n",
    "#    print(msg)\n",
    "#printer = star(percent(printer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}