Python_adv.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Advanced Python Features "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we'll talk about some not-so-basics stuffs in python, which are very helpful in doing complex tasks or making things simpler and clean."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehensions\n",
    "These are the one liners that shorten our code and you can say its a Pythonic Way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# My data\n",
    "my_list = [1,2,3,4,5,6,7,8,9,0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now if I want to get all the even numbers from it and store it in another list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 0]\n"
     ]
    }
   ],
   "source": [
    "even = []\n",
    "for number in my_list:\n",
    "    if number % 2 == 0:\n",
    "        even.append(number)\n",
    "print(even)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now lets do that in Pythonic Way"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4, 6, 8, 0]\n"
     ]
    }
   ],
   "source": [
    "new_even = [number for number in my_list if number % 2 == 0]\n",
    "print(new_even)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also turn lists into dictionaries or sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0: 0, 1: 1, 2: 8, 3: 27, 4: 64}\n",
      "{8, 1, 27, 64}\n"
     ]
    }
   ],
   "source": [
    "my_dict = {x: x**3 for x in range(5)}\n",
    "print(my_dict)\n",
    "my_set = {x**3 for x in [1,1,2,3,4,4]}\n",
    "print(my_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can have multiple <b>for</b> in list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0, 0), (0, 1), (0, 2), (0, 3), (0, 4), (1, 0), (1, 1), (1, 2), (1, 3), (1, 4), (2, 0), (2, 1), (2, 2), (2, 3), (2, 4), (3, 0), (3, 1), (3, 2), (3, 3), (3, 4), (4, 0), (4, 1), (4, 2), (4, 3), (4, 4)]\n"
     ]
    }
   ],
   "source": [
    "data = [(x,y) for x in range(5) for y in range(5)]\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets implement <b>Stack</b> using Object oriented programming in python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Stack():\n",
    "    def __init__(self): # constructor\n",
    "        self.items = [] # empty list\n",
    "    \n",
    "    def push(self, item):\n",
    "        self.items.append(item) # adds an item to stack\n",
    "        \n",
    "    def pop(self):\n",
    "        return self.items.pop() # removes the most recently added item\n",
    "\n",
    "    def is_empty(self):\n",
    "        return self.items == [] # returns boolean whether the list is empty or not  \n",
    "    \n",
    "    def top(self):\n",
    "        return self.items[-1] # returns the top most item in the stack\n",
    "    \n",
    "    def get_stack(self):\n",
    "        return self.items # gives the entire stack\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stack:  <bound method Stack.get_stack of <__main__.Stack object at 0x000001CF7AA00940>>\n",
      "Top:  C\n",
      "After Pop:  ['A', 'B']\n",
      "After Pop:  ['A']\n",
      "After Pop:  []\n",
      "Is the stack empty? :  True\n"
     ]
    }
   ],
   "source": [
    "s = Stack() # object intialized to an empty_list\n",
    "s.push('A') # calling method\n",
    "s.push('B')\n",
    "s.push('C')\n",
    "print(\"Stack: \", s.get_stack)\n",
    "print(\"Top: \", s.top())\n",
    "for i in range(len(s.items)):\n",
    "    s.pop()\n",
    "    print(\"After Pop: \", s.get_stack())\n",
    "print(\"Is the stack empty? : \", s.is_empty())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before this, in python there are many features that can be added via modules or you can say libraries. Python has a huge set of modules for many purposes from data visualization to deep learning. Here we'll be adding a module called random. Which can be done by \"import random\". The import keyword includes the module to the python session and from that we can assess the functions inside the module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>random.random()</b> returns numbers uniformly in the range (0,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.25584182353798945\n",
      "0.7199503199879009\n",
      "0.4272423011495452\n",
      "0.3355628019471306\n",
      "0.09626018949473558\n"
     ]
    }
   ],
   "source": [
    "# Say I want to print a random number in every iteration\n",
    "for i in range(5):\n",
    "    print(random.random()) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If I like to keep a randomly generated number to use it another time then we'll use <b>random.seed(<i>number</i>)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6229016948897019\n",
      "0.6229016948897019\n"
     ]
    }
   ],
   "source": [
    "random.seed(5)\n",
    "print(random.random())\n",
    "random.seed(5)\n",
    "print(random.random())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can also give a range from which random numbers will be generated by using <b>random.randrange(<i>range</i>)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "0\n",
      "8\n",
      "6\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(random.randrange(10)) # it gives integers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Unable to decide who's gonna pay the bill? Let python choose that for you by <b>random.choice(<i>list</i>)</b>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sasuke\n"
     ]
    }
   ],
   "source": [
    "bill_payer = random.choice([\"Naruto\", \"Sasuke\", \"kakashi\"])\n",
    "print(bill_payer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Zip \n",
    "Some times we need to use more than on list at a time. In that case <b>zip</b> is used to transform multiple lists to a single list of tuples of corresponding elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "name:  Naruto | attack:  Rasengan\n",
      "name:  Sasuke | attack:  Chidori\n",
      "name:  Kakashi | attack:  Raikiri\n"
     ]
    }
   ],
   "source": [
    "list_1 = ['Naruto', 'Sasuke', 'Kakashi']\n",
    "list_2 = ['Rasengan', 'Chidori', 'Raikiri']\n",
    "\n",
    "for name, attack in zip(list_1, list_2): # Here zip is [('Naruto', 'Rasengan'), ('Sasuke', 'Chidori'), ('Kakashi', 'Raikiri')]\n",
    "    print(\"name: \", name, \"| attack: \", attack)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>What if the lists have different length?</b><br>\n",
    "In that case, zip will stop as soon as the first list ends"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Argument unpacking"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It unpacks any packed data. Like, if we have a list of 2 element and we unpack that then it will return 2 separate elements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "print(my_list)\n",
    "print(*my_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "def add(x,y,z):\n",
    "    return x+y+z\n",
    "# Directly inputting values\n",
    "print(add(1,2,3))\n",
    "# Using argument unpacking\n",
    "print(add(*my_list))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## args and kwargs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's say we want to create a higher-order function that takes a function as an input and returns another function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube(f):\n",
    "    def g(x):\n",
    "        return f(x) ** 3\n",
    "    return g"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "512\n"
     ]
    }
   ],
   "source": [
    "# Our test function\n",
    "def f1(x):\n",
    "    return x * 2\n",
    "\n",
    "output_function = cube(f1)\n",
    "print(output_function(4)) # this is (4*2) ^ 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But if we do that with a function having multiple parameters we'll get an error"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TypeError: g() takes exactly 1 argument but 2 given\n"
     ]
    }
   ],
   "source": [
    "def f2(x,y):\n",
    "    return x * y\n",
    "output_function = cube(f2)\n",
    "try:\n",
    "    print(output_function(3,4))\n",
    "except:\n",
    "    print(\"TypeError: g() takes exactly 1 argument but 2 given\") \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we need a technique to specify a function that takes arbitary arguments. We can do this with argument unpacking and a little bit of magic :-)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "args:  (1, 2, 3)\n",
      "kwargs:  {'arg1': 'Hello', 'arg2': 'Hi'}\n"
     ]
    }
   ],
   "source": [
    "# here args is a tuple of unnamed arguments and kwargs is a dictionay of named arguments.\n",
    "def magic(*args, **kwargs): \n",
    "    print(\"args: \", args)\n",
    "    print(\"kwargs: \", kwargs)\n",
    "\n",
    "magic(1, 2, 3, arg1=\"Hello\", arg2=\"Hi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now Lets fix the error that we've had earlier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1728\n"
     ]
    }
   ],
   "source": [
    "def cube_fixed(f):\n",
    "    def g(*args, **kwargs):\n",
    "        return f(*args, **kwargs) ** 3\n",
    "    return g\n",
    "\n",
    "output_function = cube_fixed(f2)\n",
    "\n",
    "print(output_function(3,4)) # (3 x 4) ** 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These are some cool advance stuffs in python which can be very handy in certain situations. "
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}