tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advance Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Advance Python is a collection of deeper concepts in Python. It is the NEXT step for Python learners who have already learnt the basics."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Table of Contents\n",
    "\n",
    "#### 01) [Args and Kwargs](#ch1)\n",
    "#### 02) [Generators](#ch2)\n",
    "#### 03) [Map, Reduce, Filter](#ch3)\n",
    "#### 04) [Sets](#ch4)\n",
    "#### 05) [Decorators](#ch5)\n",
    "#### 06) [Threading](#ch6)\n",
    "#### 07) [`__slot__`](#ch7)\n",
    "#### 08) [Collections](#ch8)\n",
    "#### 09) [Enumerate](#ch9)\n",
    "#### 10) [Object Inspection](#ch10)\n",
    "#### 11) [Comprehensions](#ch11)\n",
    "#### 12) [Exceptions](#ch12)\n",
    "#### 13) [OOP(Object Oriented Python)](#ch13)\n",
    "#### 14) [Lambdas](#ch14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch1\"></a>\n",
    "## Chapter 1 - Args and Kwargs\n",
    "\n",
    "You must have frequently seen such things in Python.\n",
    "\n",
    "```python\n",
    "def function_name(*args, *kwargs):\n",
    "    # body\n",
    "```\n",
    "Confused with these notations? Don't worry. We all have been there.\n",
    "\n",
    "First of all, it is not mandatory to write the words `args` and `kwargs`. You can go with anything unless you have the asterisk (`*`) sign.\n",
    "\n",
    "#### What is an asterisk (`*`) in Python?\n",
    "\n",
    "https://stackoverflow.com/questions/400739/what-does-asterisk-mean-in-python <br>\n",
    "https://stackoverflow.com/questions/36901/what-does-double-star-asterisk-and-star-asterisk-do-for-parameters\n",
    "\n",
    "Check the above links.\n",
    "\n",
    "#### So, what is `*args` doing?\n",
    "`*args` allows you to pass a desired number of arguments to the function. Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def demo(*args):\n",
    "    print(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Humpty', 'Dumpty')\n"
     ]
    }
   ],
   "source": [
    "demo(\"Humpty\", \"Dumpty\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Humpty', 'Dumpty', 'Sat', 'On', 'The', 'Wall')\n"
     ]
    }
   ],
   "source": [
    "demo(\"Humpty\", \"Dumpty\", \"Sat\", \"On\", \"The\", \"Wall\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Thus, regardless of number of arguments passed, `*args` is showing you the result.\n",
    "Doesn't matter if you pass `(\"Humpty\", \"Dumpty\")` or `(\"Humpty\", \"Dumpty\", \"Sat\", \"On\", \"The\", \"Wall\")`, `*args` will handle that for you.\n",
    "Note: As mentioned, you can write anything and not just `args`. Let's try `*whatever`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Humpty', 'Dumpty', 'Sat', 'On', 'The', 'Wall')\n"
     ]
    }
   ],
   "source": [
    "def demo(*whatever):\n",
    "    print(whatever)\n",
    "\n",
    "demo(\"Humpty\", \"Dumpty\", \"Sat\", \"On\", \"The\", \"Wall\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's perfectly fine!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's write a function that sums up as many inputs as we want."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum(*args):\n",
    "    c = 0\n",
    "    for arg in args:\n",
    "        c+=arg\n",
    "    return c\n",
    "\n",
    "sum(1,2,3,4,5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(1,2,3,4,5,6,7,8,9,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Doesn't matter if you sum 1 to 5 or 1 to 10, Python will calculate the result for you irrespective of the number of paramters. This is the beauty of `*args`.\n",
    "What about `**kwargs`?\n",
    "Well, they are not much different. Let's try an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'Humpty', 'location': 'Wall'}\n"
     ]
    }
   ],
   "source": [
    "def demo(**kwargs):\n",
    "    print(kwargs)\n",
    "\n",
    "demo(name=\"Humpty\", location=\"Wall\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`**kwargs` stands for keyword arguments. The only difference is that it uses keywords and returns the values in the form of a dictionary.\n",
    "\n",
    "Now, lets write a normal function and pass arguments through `args` and `kwargs`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def list_numbers(first, second, third):\n",
    "    print(\"First number\", first)\n",
    "    print(\"Second number\", second)\n",
    "    print(\"Third number\", third)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First number One\n",
      "Second number Two\n",
      "Third number Three\n"
     ]
    }
   ],
   "source": [
    "args = (\"One\",\"Two\",\"Three\")\n",
    "list_numbers(*args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First number One\n",
      "Second number Two\n",
      "Third number Three\n"
     ]
    }
   ],
   "source": [
    "kwargs = {\"third\": \"Three\", \"second\": \"Two\", \"first\": \"One\"}\n",
    "list_numbers(**kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch2\"></a>\n",
    "## Chapter 2 - Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iterators:\n",
    "First, let's talk about iterators. Iterators simply iterate through a series of item. It is an object in Python which has a __next__ method defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = [1,2,3,5,8,13]\n",
    "final_list = iter(my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<list_iterator at 0x7f3824376358>"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(final_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(final_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(final_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... and so on."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generators:\n",
    "Python generators are a simple way of creating iterators.\n",
    "It is a function that returns an object (iterator) which we can iterate over (one value at a time)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generator():\n",
    "    for i in range(3):\n",
    "        yield i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for each in generator():\n",
    "    print(each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = generator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-6e72e47198db>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgen\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(gen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This time we got a StopIteration error because our iteration ends after 2. Thus, there is no `next()` item"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets implement our `iter()` function once again, but this time to see the StopIteration error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<list_iterator object at 0x7fc2840e5ba8>\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "x = iter(a)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-67-92de4e9f6b1e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We worked with lists. What about strings? Let's see what happens if that is the case."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = \"Akash\"\n",
    "new = iter(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'A'"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'k'"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a'"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s'"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h'"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And that's it. There will no longer be further iterations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "def fact(n):\n",
    "    c = 1\n",
    "    for i in range(1,n+1):\n",
    "        c=c*i\n",
    "    print(c)\n",
    "fact(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch3\"></a>\n",
    "## Chapter 3 - Map, Reduce and Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Map\n",
    "Map applies a function to all the items in an input_list.\n",
    "First, see this normal approach."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = [1, 2, 3, 4, 5]\n",
    "squared = []\n",
    "for i in items:\n",
    "    squared.append(i**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Map approach syntax: `map(function_to_apply, list_of_inputs)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "items = [1, 2, 3, 4, 5]\n",
    "squared = list(map(lambda x: x**2, items))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try another one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x7f382428ba90>"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = (1,2,3,4)\n",
    "out = map(lambda a: a**2, a)\n",
    "out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(out)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How cool would it be to pass a function instead?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0]\n",
      "[1, 1]\n",
      "[4, 8]\n",
      "[9, 27]\n",
      "[16, 64]\n"
     ]
    }
   ],
   "source": [
    "def squared(x):\n",
    "    return x**2\n",
    "\n",
    "def cubed(x):\n",
    "    return x**3\n",
    "\n",
    "functions = [squared, cubed]\n",
    "for i in range(5):\n",
    "    li = list(map(lambda x: x(i), functions))\n",
    "    print(li)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Normal way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "product = 1\n",
    "list = [1, 2, 3, 4]\n",
    "for num in list:\n",
    "    product = product * num\n",
    "\n",
    "product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The Reduce way:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from functools import reduce\n",
    "product = reduce((lambda x, y: x * y), [1, 2, 3, 4])\n",
    "\n",
    "product"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter\n",
    "As the name suggests, a filter method literally filters out the elements defined.\n",
    "Let's filter only the negative numbers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_list = range(-5, 5)\n",
    "less_than_zero = filter(lambda x: x < 0, number_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-5"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(less_than_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(less_than_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(less_than_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(less_than_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(less_than_zero)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-87-373734c2136e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mless_than_zero\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(less_than_zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because that's it. The filtered list only contains `[-5, -4, -3, -2, -1]`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch4\"></a>\n",
    "## Chapter 4 - Sets\n",
    "\n",
    "We all have heard of lists, tuples and dictionary from the very beginning. But many beginners tend to forget another important datatype in Python -- called set.\n",
    "\n",
    "A set is an unordered collection with no duplicate elements. Basic uses include membership testing and eliminating duplicate entries. Set objects also support mathematical operations like union, intersection, difference, and symmetric difference.<br>\n",
    "Curly braces or the `set()` function can be used to create sets. Note: to create an empty set you have to use `set()`, not {}; the latter creates an empty dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'apple', 'banana', 'orange', 'pear'}"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}\n",
    "basket"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Demonstrate set operations on unique letters from two words\n",
    "a = set('abracadabra')\n",
    "b = set('alacazam')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'r'}"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'c', 'l', 'm', 'z'}"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b', 'd', 'r'}"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a-b # letters in a but not in b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'l', 'm', 'z'}"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b-a # letters in b but not in a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'c'}"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a & b # letters in both a and b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'l', 'm', 'r', 'z'}"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a | b # letters in a or b or both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b', 'd', 'l', 'm', 'r', 'z'}"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a ^ b # letters in a or b but not both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'d', 'r'}"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set comprehension\n",
    "a = {x for x in 'abracadabra' if x not in 'abc'}\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'h', 'k', 's'}"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = \"akash\"\n",
    "set(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See the duplicates from the list."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{2, 6, 9}"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "duplicated_list = [1,2,2,4,6,3,9,6,9,7]\n",
    "final_list = set([x for x in duplicated_list if duplicated_list.count(x)>1])\n",
    "final_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch5\"></a>\n",
    "## Chapter 5 - Decorators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Decorators are functions which modify the functionality of another function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum(x,y):\n",
    "    return x+y\n",
    "\n",
    "def double(anything):\n",
    "    final = anything*2\n",
    "    return final\n",
    "\n",
    "double(sum(4,6)) # Take a sum of 4 and 6 and double that result."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this above example, we first defined a `sum()` function that sums up two numbers.<br>\n",
    "After that, we defined another function named `double()` that takes **function as an argument.**\n",
    "In our case, the `double` function took the earlier result of the `sum` function and simply doubled it.  \n",
    "Let's try another simple example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "def multiply(x,y):\n",
    "    return x*y\n",
    "def final():\n",
    "    print(\"This is a multiplication operation\")\n",
    "    print(multiply(4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is a multiplication operation\n",
      "16\n"
     ]
    }
   ],
   "source": [
    "final()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**But where is `@`?**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [],
   "source": [
    "def a_new_decorator(a_func):\n",
    "\n",
    "    def wrapTheFunction():\n",
    "        print(\"This is before executing a_func()\")\n",
    "\n",
    "        a_func()\n",
    "\n",
    "        print(\"Decorated!!!\")\n",
    "\n",
    "    return wrapTheFunction\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This is before executing a_func()\n",
      "I am the function which needs some decoration.\n",
      "Decorated!!!\n"
     ]
    }
   ],
   "source": [
    "@a_new_decorator\n",
    "def a_function_requiring_decoration():\n",
    "    print(\"I am the function which needs some decoration.\")\n",
    "\n",
    "a_function_requiring_decoration()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def doubler(a_func):\n",
    "\n",
    "    def stuff_to_do():\n",
    "        a_func() # Take the function that was passed as the argument\n",
    "        final = a_func()*2 # Multiply that function with 2\n",
    "        print(final)\n",
    "\n",
    "    return stuff_to_do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18\n"
     ]
    }
   ],
   "source": [
    "@doubler\n",
    "def sum():\n",
    "    a = 4\n",
    "    b = 5\n",
    "    return a+b\n",
    "sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There it is!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch6\"></a>\n",
    "## Chapter 6 - Threading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Threading allows us to run multiple tasks run concurrently. For eg: If Task A is running, I can still start Task B and execute it. I don't have to wait for Task A to finish.  \n",
    "Let's first see a normal example of running one task using a normal function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "def sleep(n,name):\n",
    "    print(\"My name is Thread {}. I am going to sleep for 5 sec.\\n\".format(name))\n",
    "    time.sleep(5)\n",
    "    print(\"Thread {} has woken up.\\n\".format(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Thread Jon Snow. I am going to sleep for 5 sec.\n",
      "\n",
      "Thread Jon Snow has woken up.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "sleep(5, 'Jon Snow')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Time to implement threading."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Thread Lannister. I am going to sleep for 5 sec.\n",
      "Hello, it's me\n",
      "Hello from the other side\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import threading\n",
    "\n",
    "t = threading.Thread(target=sleep, name='thread1', args=(5,'Lannister'))\n",
    "t.start()\n",
    "print(\"Hello, it's me\")\n",
    "print(\"Hello from the other side\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Introduce `t.join()` to ensure that the next is executed only if the first one is completed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My name is Thread Lannister. I am going to sleep for 5 sec.\n",
      "\n",
      "Thread Lannister has woken up.\n",
      "\n",
      "Thread Lannister has woken up.\n",
      "\n",
      "Hello, it's me\n",
      "Hello from the other side\n"
     ]
    }
   ],
   "source": [
    "t = threading.Thread(target=sleep, name='thread1', args=(5,'Lannister'))\n",
    "t.start()\n",
    "t.join()\n",
    "print(\"Hello, it's me\")\n",
    "print(\"Hello from the other side\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch7\"></a>\n",
    "## Chapter 7 - `__slot__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You would want to use `__slot__` if you are going to instantiate a lot (hundreds, thousands) of objects of the same class. `__slot__` exists as a memory optimization tool.\n",
    "\n",
    "Check this too: https://stackoverflow.com/questions/472000/usage-of-slots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "    \n",
    "    def __init__(self, name, address):\n",
    "        self.name = name\n",
    "        self.address = address\n",
    "        self.set_up()\n",
    "    # ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person(object):\n",
    "    \n",
    "    __slots__ = ['name', 'address']\n",
    "    \n",
    "    def __init__(self, name, identifier):\n",
    "        self.name = name\n",
    "        self.address = address\n",
    "        self.set_up()\n",
    "    # ..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple and effective implementation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch8\"></a>\n",
    "## Chapter 8 - Collections\n",
    "\n",
    "Python ships with a module that contains a number of container data types called Collections. Let's talk about some of them.\n",
    "\n",
    "Python uses these listed set of collections:\n",
    "\n",
    "- `defaultdict`\n",
    "- `OrderedDict`\n",
    "- `UserDict`\n",
    "- `UserList`\n",
    "- `UserString`\n",
    "- `Counter`\n",
    "- `ChainMap`\n",
    "- `namedtuple`\n",
    "- `enum.Enum`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Using `defaultDict`\n",
    "Unlike `dict`, with `defaultdict` you do not need to check whether a key is present or not. So we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(list,\n",
       "            {'Flower': ['Yellow', 'Red'],\n",
       "             'Sky': ['Blue'],\n",
       "             'Grass': ['Green'],\n",
       "             'Coal': ['Black'],\n",
       "             'Fish': ['Silver']})"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "colours = (\n",
    "    ('Flower', 'Yellow'),\n",
    "    ('Sky', 'Blue'),\n",
    "    ('Grass', 'Green'),\n",
    "    ('Coal', 'Black'),\n",
    "    ('Flower', 'Red'),\n",
    "    ('Fish', 'Silver'),\n",
    ")\n",
    "\n",
    "favourite_colours = defaultdict(list)\n",
    "\n",
    "for name, colour in colours:\n",
    "    favourite_colours[name].append(colour)\n",
    "\n",
    "favourite_colours"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that unlike a normal dictionary, a default dictionary doesn't throw you a `KeyError` while executing an invalid key. Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ball'"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabets = {\n",
    "    'a':'apple',\n",
    "    'b':'ball',\n",
    "    'c':'cat'\n",
    "}\n",
    "\n",
    "alphabets['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'x'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-afdd43d819d0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0malphabets\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'x'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m: 'x'"
     ]
    }
   ],
   "source": [
    "alphabets['x']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It shows you a key error because key `x` isn't present. Sure, there is also another way to tackle this issue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ball'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alphabets.get('b')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "alphabets.get('x')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice, it didn't raise an error. Now, let's try this with a defaultdict."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyError",
     "evalue": "'colours'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-23-85447ef2cc56>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0msome_dict\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m{\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msome_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'colours'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'favourite'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"yellow\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;31m# Raises KeyError: 'colours'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mKeyError\u001b[0m: 'colours'"
     ]
    }
   ],
   "source": [
    "some_dict = {}\n",
    "some_dict['colours']['favourite'] = \"yellow\"\n",
    "# Raises KeyError: 'colours'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree = lambda: defaultdict(tree)\n",
    "some_dict = tree()\n",
    "some_dict['colours']['favourite'] = \"yellow\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "defaultdict(<function __main__.<lambda>()>,\n",
       "            {'colours': defaultdict(<function __main__.<lambda>()>,\n",
       "                         {'favourite': 'yellow'})})"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "some_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### OrderedDict\n",
    "\n",
    "Unlinke normal dictionary, an `OrderedDict` keeps the entries in the same order as inserted.\n",
    "Let's try out an example with a normal dict and then with `OrderedDict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "USA 1\n",
      "China 3\n",
      "Japan 5\n"
     ]
    }
   ],
   "source": [
    "colours =  {\"USA\" : 1, \"China\" : 3, \"Japan\" : 5}\n",
    "for key, value in colours.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "USA 1\n",
      "China 3\n",
      "Japan 5\n"
     ]
    }
   ],
   "source": [
    "from collections import OrderedDict\n",
    "\n",
    "colours = OrderedDict([(\"USA\", 1), (\"China\", 3), (\"Japan\", 5)])\n",
    "for key, value in colours.items():\n",
    "    print(key, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Deque\n",
    "Dequeue or double ended queue allows to append and delete elements from either side of the queue."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G\n",
      "H\n",
      "I\n"
     ]
    }
   ],
   "source": [
    "from collections import deque\n",
    "d = deque('ghi')                 # make a new deque with three items\n",
    "for elem in d:                   # iterate over the deque's elements\n",
    "    print(elem.upper())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "deque(['f', 'g', 'h', 'i', 'j'])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.append('j')                    # add a new entry to the right side\n",
    "d.appendleft('f')                # add a new entry to the left side\n",
    "d                                # show the representation of the deque"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'j'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.pop()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'f'"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.popleft()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Python documentation on deque](https://docs.python.org/3/library/collections.html#deque-objects) covers a whole lot of other interesting things that can be done with it. Make sure to check that out."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### namedtuple()\n",
    "A namedtuple() is a factory function for creating tuple subclasses with named fields. Let's see what that means."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Point = namedtuple('Point', ['x', 'y'])\n",
    "p = Point(5,10)\n",
    "p[0]+p[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p.y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Point(x=5, y=10)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And thats all. Don't miss out [Python Collections](https://docs.python.org/3/library/collections.html) documentation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch9\"></a>\n",
    "## Chapter 9 - Enumerate\n",
    "\n",
    "The `enumerate()` method adds a counter to an iterable and returns it in a form of enumerate object. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 Neur\n",
      "2 Schweinsteiger\n",
      "3 Lahm\n",
      "4 Muller\n"
     ]
    }
   ],
   "source": [
    "my_list = ['Neur', 'Schweinsteiger', 'Lahm', 'Muller']\n",
    "for c, value in enumerate(my_list, 1):\n",
    "    print(c, value)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that `(my_list, 1)` indicates the starting index of the enumerated list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can also create tuples containing the index and list item using a list. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 'Neur'), (2, 'Schweinsteiger'), (3, 'Lahm'), (4, 'Muller')]\n"
     ]
    }
   ],
   "source": [
    "my_list = ['Neur', 'Schweinsteiger', 'Lahm', 'Muller']\n",
    "counter_list = list(enumerate(my_list, 1))\n",
    "print(counter_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's it. Enumerate is fun, easy and useful in many context."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch10\"></a>\n",
    "## Chapter 10 - Object Inspection\n",
    "\n",
    "Everything in Python is an object and we can examine those objects with an ease. Python ships with a few built-in functions and modules to help us with that."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### a) ```__dir__```  \n",
    "The ```__dir__``` method allows us to list all the attributes and methods belonging to an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1, 2, 3]\n",
    "dir(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### b) ```type``` and ```id```  \n",
    "The ```type``` function returns the type of an object.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'list'>\n",
      "<class 'dict'>\n",
      "<class 'type'>\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(''))\n",
    "\n",
    "print(type([]))\n",
    "\n",
    "print(type({}))\n",
    "\n",
    "print(type(dict))\n",
    "\n",
    "print(type(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ```id``` function returns the unique ID of an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140342687412040"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name = \"Akash\"\n",
    "id(name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### c) ```inspect```  \n",
    "The ```inspect``` method allows us to list all the attributes and methods belonging to an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('__add__', <slot wrapper '__add__' of 'str' objects>), ('__class__', <class 'type'>), ('__contains__', <slot wrapper '__contains__' of 'str' objects>), ('__delattr__', <slot wrapper '__delattr__' of 'object' objects>), ('__dir__', <method '__dir__' of 'object' objects>), ('__doc__', \"str(object='') -> str\\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\\n\\nCreate a new string object from the given object. If encoding or\\nerrors is specified, then the object must expose a data buffer\\nthat will be decoded using the given encoding and error handler.\\nOtherwise, returns the result of object.__str__() (if defined)\\nor repr(object).\\nencoding defaults to sys.getdefaultencoding().\\nerrors defaults to 'strict'.\"), ('__eq__', <slot wrapper '__eq__' of 'str' objects>), ('__format__', <method '__format__' of 'str' objects>), ('__ge__', <slot wrapper '__ge__' of 'str' objects>), ('__getattribute__', <slot wrapper '__getattribute__' of 'str' objects>), ('__getitem__', <slot wrapper '__getitem__' of 'str' objects>), ('__getnewargs__', <method '__getnewargs__' of 'str' objects>), ('__gt__', <slot wrapper '__gt__' of 'str' objects>), ('__hash__', <slot wrapper '__hash__' of 'str' objects>), ('__init__', <slot wrapper '__init__' of 'object' objects>), ('__init_subclass__', <built-in method __init_subclass__ of type object at 0x9e6ae0>), ('__iter__', <slot wrapper '__iter__' of 'str' objects>), ('__le__', <slot wrapper '__le__' of 'str' objects>), ('__len__', <slot wrapper '__len__' of 'str' objects>), ('__lt__', <slot wrapper '__lt__' of 'str' objects>), ('__mod__', <slot wrapper '__mod__' of 'str' objects>), ('__mul__', <slot wrapper '__mul__' of 'str' objects>), ('__ne__', <slot wrapper '__ne__' of 'str' objects>), ('__new__', <built-in method __new__ of type object at 0x9e6ae0>), ('__reduce__', <method '__reduce__' of 'object' objects>), ('__reduce_ex__', <method '__reduce_ex__' of 'object' objects>), ('__repr__', <slot wrapper '__repr__' of 'str' objects>), ('__rmod__', <slot wrapper '__rmod__' of 'str' objects>), ('__rmul__', <slot wrapper '__rmul__' of 'str' objects>), ('__setattr__', <slot wrapper '__setattr__' of 'object' objects>), ('__sizeof__', <method '__sizeof__' of 'str' objects>), ('__str__', <slot wrapper '__str__' of 'str' objects>), ('__subclasshook__', <built-in method __subclasshook__ of type object at 0x9e6ae0>), ('capitalize', <method 'capitalize' of 'str' objects>), ('casefold', <method 'casefold' of 'str' objects>), ('center', <method 'center' of 'str' objects>), ('count', <method 'count' of 'str' objects>), ('encode', <method 'encode' of 'str' objects>), ('endswith', <method 'endswith' of 'str' objects>), ('expandtabs', <method 'expandtabs' of 'str' objects>), ('find', <method 'find' of 'str' objects>), ('format', <method 'format' of 'str' objects>), ('format_map', <method 'format_map' of 'str' objects>), ('index', <method 'index' of 'str' objects>), ('isalnum', <method 'isalnum' of 'str' objects>), ('isalpha', <method 'isalpha' of 'str' objects>), ('isdecimal', <method 'isdecimal' of 'str' objects>), ('isdigit', <method 'isdigit' of 'str' objects>), ('isidentifier', <method 'isidentifier' of 'str' objects>), ('islower', <method 'islower' of 'str' objects>), ('isnumeric', <method 'isnumeric' of 'str' objects>), ('isprintable', <method 'isprintable' of 'str' objects>), ('isspace', <method 'isspace' of 'str' objects>), ('istitle', <method 'istitle' of 'str' objects>), ('isupper', <method 'isupper' of 'str' objects>), ('join', <method 'join' of 'str' objects>), ('ljust', <method 'ljust' of 'str' objects>), ('lower', <method 'lower' of 'str' objects>), ('lstrip', <method 'lstrip' of 'str' objects>), ('maketrans', <built-in method maketrans of type object at 0x9e6ae0>), ('partition', <method 'partition' of 'str' objects>), ('replace', <method 'replace' of 'str' objects>), ('rfind', <method 'rfind' of 'str' objects>), ('rindex', <method 'rindex' of 'str' objects>), ('rjust', <method 'rjust' of 'str' objects>), ('rpartition', <method 'rpartition' of 'str' objects>), ('rsplit', <method 'rsplit' of 'str' objects>), ('rstrip', <method 'rstrip' of 'str' objects>), ('split', <method 'split' of 'str' objects>), ('splitlines', <method 'splitlines' of 'str' objects>), ('startswith', <method 'startswith' of 'str' objects>), ('strip', <method 'strip' of 'str' objects>), ('swapcase', <method 'swapcase' of 'str' objects>), ('title', <method 'title' of 'str' objects>), ('translate', <method 'translate' of 'str' objects>), ('upper', <method 'upper' of 'str' objects>), ('zfill', <method 'zfill' of 'str' objects>)]\n"
     ]
    }
   ],
   "source": [
    "import inspect\n",
    "print(inspect.getmembers(str))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch11\"></a>\n",
    "## Chapter 11 - Comprehensions\n",
    "\n",
    "Python allows you to write smart, effective and reduced code to solve a same problem that requires multiple lines for execution. Comprehensions are one of such features that doesn't solve a new problem, but provides a syntactic sugar to the older problem because of which the code content gets significantly reduced.  \n",
    "Comprehensions are of four types:\n",
    "- list comprehensions\n",
    "- dictionary comprehensions\n",
    "- set comprehensions\n",
    "- generator comprehensions\n",
    "Let's see them"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### List comprehensions\n",
    "List comprehensions provide a short and concise way to create lists.\n",
    "\n",
    "If you used to do it like this:\n",
    "```python\n",
    "new_list = []\n",
    "for i in old_list:\n",
    "    if filter(i):\n",
    "        new_list.append(expressions(i))\n",
    "```\n",
    "You can obtain the same thing using list comprehension:\n",
    "```python\n",
    "new_list = [expression(i) for i in old_list if filter(i)]\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try out a normal example and then solve it using comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64, 100]"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Square all the list members that are EVEN\n",
    "\n",
    "old_list = [1,2,3,4,5,6,7,8,9,10]\n",
    "new_list = []\n",
    "for i in old_list:\n",
    "    if i%2 == 0:\n",
    "        new_list.append(i**2)\n",
    "new_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Solving the same problem with list comprehension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 16, 36, 64, 100]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "old_list = [1,2,3,4,5,6,7,8,9,10]\n",
    "new_ = [i**2 for i in old_list if i%2==0]\n",
    "new_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Dictionary comprehensions\n",
    "Syntax:\n",
    "```python\n",
    "{v: k for k, v in some_dict.items()}\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 2, 'b': 4, 'c': 6, 'd': 8, 'e': 10}"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Double each value in the dictionary\n",
    "\n",
    "dict1 = {\n",
    "    'a': 1, \n",
    "    'b': 2, \n",
    "    'c': 3, \n",
    "    'd': 4, \n",
    "    'e': 5\n",
    "}\n",
    "\n",
    "double_dict1 = {k:v*2 for (k,v) in dict1.items()}\n",
    "\n",
    "double_dict1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Set comprehensions\n",
    "Has a similar implementation like list comprehensions except for the curly braces."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 4, 9, 25, 36, 169}"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "li = [1,1,2,3,5,6,13]\n",
    "squared = {x**2 for x in li}\n",
    "squared"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Generator comprehensions\n",
    "They are also similar to list comprehensions. The only difference is that they don’t allocate memory for the whole list but generate one item at a time, thus more memory effecient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<generator object <genexpr> at 0x7f30701ea6d0>\n",
      "0\n",
      "2\n",
      "4\n",
      "6\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "multiples_gen = (i for i in range(10) if i % 2 == 0)\n",
    "print(multiples_gen)\n",
    "\n",
    "for x in multiples_gen:\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch12\"></a>\n",
    "## Chapter 12 - Exception\n",
    "\n",
    "Exception handling is the process of responding to exceptions in the program. It is the art that will allow you to detect and solve the problems with relevant ease.  \n",
    "Let's see some examples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please enter a number: 3.3\n",
      "Oops!  That was no valid number.  Try again...\n",
      "Please enter a number: 434.3\n",
      "Oops!  That was no valid number.  Try again...\n",
      "Please enter a number: 123\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    try:\n",
    "        x = int(input(\"Please enter a number: \"))\n",
    "        break\n",
    "    except ValueError:\n",
    "        print(\"Oops!  That was no valid number.  Try again...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An IOError occurred. No such file or directory\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    file = open('test.txt', 'rb')\n",
    "except IOError as e:\n",
    "    print('An IOError occurred. {}'.format(e.args[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, we were just checking the existence of `IOError`. We don't have the file named \"test.txt\". Thus, sure enough, we would get the `IOError`. But we are treating that error as the exception and printing out the bove message just in case whenever get the `IOError`.  \n",
    "**Note**: You can pass and handle multiple exceptions too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "An error occurred. No such file or directory\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    file = open('test.txt', 'rb')\n",
    "except (IOError, EOFError) as e:\n",
    "    print(\"An error occurred. {}\".format(e.args[-1]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we passed two errors - `IOError` and `EOFError`  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `Finally` block\n",
    "The `finally` block can be used to perform clean-up after a script. Let's see a syntactic example and then an actual example.\n",
    "\n",
    "```python\n",
    "try:\n",
    "    run_code1()\n",
    "except TypeError:\n",
    "    run_code2()\n",
    "    return None   # The finally block is run before the method returns\n",
    "finally:\n",
    "    other_code()\n",
    "```\n",
    "Compare to this:\n",
    "```python\n",
    "try:\n",
    "    run_code1()\n",
    "except TypeError:\n",
    "    run_code2()\n",
    "    return None   \n",
    "\n",
    "other_code()  # This doesn't get run if there's an exception.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, let's include the `finally` block."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This will still get printed even if we couldn't catch the exception in the except block.\n"
     ]
    },
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'test.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-04cc2b2a323c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test.txt'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mEOFError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# EOFError to not catch the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'An IOError occurred. {}'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;32mfinally\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'test.txt'"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    file = open('test.txt', 'rb')\n",
    "except EOFError as e: # EOFError to not catch the exception\n",
    "    print('An IOError occurred. {}'.format(e.args[-1]))\n",
    "finally:\n",
    "    print(\"This will still get printed even if we couldn't catch the exception in the except block.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What about removing the `finally` block and casually printing it out by creating an uncaught exception?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'test.txt'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-19-378748c94733>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mfile\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'test.txt'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'rb'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mEOFError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# EOFError to not catch the exception\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Oops!! EOFError.'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Now, this will not be printed because we couldn't catch the actual error.\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'test.txt'"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    file = open('test.txt', 'rb')\n",
    "except EOFError as e: # EOFError to not catch the exception\n",
    "    print('Oops!! EOFError.')\n",
    "print(\"Now, this will not be printed because we couldn't catch the actual error.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### The `try` - `else`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basic idea: The statements in the `else` block are executed if execution falls off the bottom of the `try` - if there was no exception.  \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cannot open -f\n",
      "/run/user/1000/jupyter/kernel-6b8f5b2c-6e22-4ec5-b9fd-cc5fab98b50e.json has 12 lines\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "for arg in sys.argv[1:]:\n",
    "    try:\n",
    "        f = open(arg, 'r')\n",
    "    except OSError:\n",
    "        print('cannot open', arg)\n",
    "    else:\n",
    "        print(arg, 'has', len(f.readlines()), 'lines')\n",
    "        f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That is all for today!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch13\"></a>\n",
    "## Chapter 13 - OOP (Object Oriented Python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The concepts of Class and Objects in Python (or any other object oriented language) is one of the most essential features for solving problems with relevant ease and reuse.  \n",
    "This tutorial doesn't cover the fundamentals of class and objects but the inner mechanisms and some of the confusing cases with object oriented python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Object inheritance\n",
    "There is a subtle difference with the old and the new style classes in Python -- inheriting objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am an old class\n",
      "I am a jazzy new class\n"
     ]
    }
   ],
   "source": [
    "class OldClass():\n",
    "    def __init__(self):\n",
    "        print('I am an old class')\n",
    "\n",
    "class NewClass(object):\n",
    "    def __init__(self):\n",
    "        print('I am a jazzy new class')\n",
    "\n",
    "old = OldClass()\n",
    "# Output: I am an old class\n",
    "\n",
    "new = NewClass()\n",
    "# Output: I am a jazzy new class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This inheritance from object allows new style classes to utilize some `magic`. A major advantage is that you can employ some useful optimizations like `__slots__`. You can use `super()` and descriptors and the likes. Bottom line? Always try to use new-style classes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Magic Methods\n",
    "\n",
    "Python’s classes are famous for their magic methods, commonly called dunder (double underscore) methods. Let's discuss a few of them.\n",
    "\n",
    "#### * `__init__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Greetings!!\n",
      "I am another method which is not automatically called\n"
     ]
    }
   ],
   "source": [
    "class GetTest(object):\n",
    "    def __init__(self):\n",
    "        print('Greetings!!')\n",
    "    def another_method(self):\n",
    "        print('I am another method which is not'\n",
    "              ' automatically called')\n",
    "\n",
    "a = GetTest()\n",
    "\n",
    "a.another_method()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### * `getitem`\n",
    "The `__getitem__` method allows to create a subscriptable class in Python.  \n",
    "Subscriptable basically means that the object implements the __getitem__() method. In other words, it describes objects that are \"containers\", meaning they contain other objects. This includes lists, tuples, and dictionaries.  \n",
    "Let's see an example."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Akash\n",
      "11223344\n"
     ]
    }
   ],
   "source": [
    "class Information(object):\n",
    "    def __init__(self):\n",
    "        self.info = {\n",
    "            'name':'Akash',\n",
    "            'country':'Nepal',\n",
    "            'number':11223344\n",
    "        }\n",
    "\n",
    "    def __getitem__(self,i):\n",
    "        return self.info[i]\n",
    "\n",
    "foo = Information()\n",
    "print(foo['name'])\n",
    "print(foo['number'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### New style class in Python\n",
    "The major difference between new and old style class in Python is that the new style class inherits from `object`.  \n",
    "Also check the link below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am an old class\n",
      "I am a jazzy new class\n"
     ]
    }
   ],
   "source": [
    "class OldClass():\n",
    "    def __init__(self):\n",
    "        print('I am an old class')\n",
    "\n",
    "class NewClass(object):\n",
    "    def __init__(self):\n",
    "        print('I am a jazzy new class')\n",
    "\n",
    "old = OldClass()\n",
    "# Output: I am an old class\n",
    "\n",
    "new = NewClass()\n",
    "# Output: I am a jazzy new class"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id=\"ch14\"></a>\n",
    "## Chapter 14 - Lambdas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's face it — Lambdas are mysterious! We might have often wondered about the very usability of lambdas. Let's explore this mysterious thing and try to debunk it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Syntax    \n",
    "`lambda argument: manipulate(argument)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### But what are they really?\n",
    "Let's try creating a function that adds two numbers using a \"normal\" way."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def add(x,y):\n",
    "    return x+y\n",
    "\n",
    "add(5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Simple, right? But, can we do better than this?  \n",
    "Sure, we can! Here is the same thing done using the `lambda` expression."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_again = lambda x,y: x+y\n",
    "add_again(5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Thus, `lambda`, in a way, are one line \"anonymous\" functions.  \n",
    "### But why use `lambda` at all?\n",
    "Well, the answer lies in using `lambda` inside another function.  \n",
    "Let's see what that means."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imagine(a_number):\n",
    "    return lambda x: x * a_number\n",
    "multiply_this_number = imagine(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_this_number(0) # with a_number , i.e,  0 * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_this_number(1) # 1 * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "multiply_this_number(5) # 5 * 10"
   ]
  },
  {
   "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.6.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}