Mod04-Python/ClassNotes/Day4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Generators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Generators simplifies creation of iterators. A generator is a function that produces a sequence of results instead of a single value.<br>\n",
    "Each time the yield statement is executed the function generates a new value.<br>\n",
    "**next()** : next is a generator function which takes a generator object and returns it next value <br>\n",
    "1. Repeatedly calling next function with same gen objects resumes exactly where it left of and continues until it hit the next else statment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "Hi\n",
      "Hello\n",
      "15\n",
      "World\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def simpel_generator():\n",
    "    print(\"Hi\")\n",
    "    yield 'Hello'\n",
    "    x=10\n",
    "    y=x+5\n",
    "    print(y)\n",
    "    yield \"World\"\n",
    "    yield x\n",
    "    \n",
    "ret=simpel_generator()\n",
    "print(type(ret))\n",
    "#print(next(ret))\n",
    "#print(next(ret))\n",
    "\n",
    "for i in ret:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n"
     ]
    }
   ],
   "source": [
    "def fib_gen(max):\n",
    "    first,second=0,1\n",
    "    while first < max:\n",
    "        yield first\n",
    "        first,second=second,first+second\n",
    "gen = fib_gen(1000)\n",
    "\n",
    "for i in gen:\n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "55\n",
      "89\n",
      "144\n",
      "233\n",
      "377\n",
      "610\n",
      "987\n",
      "1597\n",
      "2584\n"
     ]
    }
   ],
   "source": [
    "def fib_gen(max):\n",
    "    first,second=0,1\n",
    "    for i in range(0,max):\n",
    "        yield first\n",
    "        first,second=second,first+second\n",
    "gen = fib_gen(19)\n",
    "\n",
    "for i in gen:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KEYWORD Arguements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Different ways of passing arguements to function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter name of empl:akshay\n",
      "name of empl is akshay\n",
      "emp id: 101\n",
      "dept is ADMIN\n"
     ]
    }
   ],
   "source": [
    "def employees(e,c,dept='IT',sal=0):\n",
    "    name=input('enter name of empl:')\n",
    "    print('name of empl is',name)\n",
    "    print('emp id:',e)\n",
    "    print('dept is',dept)\n",
    "empl_id = 101\n",
    "#employees(empl_id)\n",
    "course='dbda'\n",
    "employees(empl_id,course,'ADMIN',sal=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def employees(e,c,dept='IT',sal=0):\n",
    "    name=input('enter name of empl:')\n",
    "    print('name of empl is',name)\n",
    "    print('emp id:',e)\n",
    "    print('dept is',dept)\n",
    "empl_id = 101\n",
    "#employees(empl_id)\n",
    "course='dbda'\n",
    "employees(emp_id,course,dept='ADMIN',sal=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def employees(e,c,dept='IT',sal=0):\n",
    "    name=input('enter name of empl:')\n",
    "    print('name of empl is',name)\n",
    "    print('emp id:',e)\n",
    "    print('dept is',dept)\n",
    "empl_id = 101\n",
    "#employees(empl_id)\n",
    "course='dbda'\n",
    "employees(emp_id,course)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Emp ID is 101\n",
      "emp id: ('dbda', 25)\n"
     ]
    }
   ],
   "source": [
    "def employees(e,*args,dept='IT',sal=0):\n",
    "    print('Emp ID is',e)\n",
    "    print('emp id:',args)\n",
    "empl_id = 101\n",
    "course='dbda'\n",
    "employees(empl_id,course,25,dept='Admin',sal=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "emp id: (101, 'dbda', 25)\n"
     ]
    }
   ],
   "source": [
    "def employees(*args,dept='IT',sal=0):\n",
    "    #print(e)\n",
    "    print('emp id:',args)\n",
    "empl_id = 101\n",
    "course='dbda'\n",
    "employees(empl_id,course,25,dept='Admin',sal=1000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "All non-key arguements:->  (101, 'dbda', 25, 'pune')\n",
      "All key arguements:->  Admin\n"
     ]
    }
   ],
   "source": [
    "def employees(*args,**other_info):\n",
    "    print('All non-key arguements:-> ',args)\n",
    "    print('All key arguements:-> ',other_info[\"dept\"])\n",
    "empl_id = 101\n",
    "course='dbda'\n",
    "employees(empl_id,course,25,'pune',dept='Admin',sal=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lambda Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is a simple and light weight and un-named.\n",
    "1. It is a single expression function.\n",
    "2. There is no return type\n",
    "3. Anonymous function\n",
    "4. Cann't have doc-string\n",
    "5."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Why Use Lambda Functions?\n",
    "***The power of lambda is better shown when you use them as an anonymous function inside another function.***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v=lambda x,y: x+y\n",
    "type(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "print(v(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n"
     ]
    }
   ],
   "source": [
    "x = lambda a : a + 10\n",
    "print(x(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "v=lambda x,y: x-y if x>y else y-x\n",
    "print(v(3,4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MAP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The map() function applies a given function to each item of an iterable (list, tuple etc.) and returns a list of the results.<br>\n",
    "**SYNTAX**<br>\n",
    "~~~~\n",
    "map(function, iterable, ...)\n",
    "~~~~\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map() Parameter\n",
    "***function - map()*** passes each item of the **iterable** to this function.<br>\n",
    "**iterable** - iterable which is to be mapped<br>\n",
    " 1. ** You can pass more than one iterable to the map() function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "#Example\n",
    "\n",
    "def square(x):\n",
    "    return x**2\n",
    "print(list(map(square,[1,2,3,4,5])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n",
      "9\n",
      "16\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "def square(x):\n",
    "    return x**2\n",
    "res=(map(square,[1,2,3,4,5]))\n",
    "for i in res:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 24, 25]\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "    Convert a list of strings into list of integers\n",
    "'''\n",
    "lst=['23','24','25']\n",
    "new_lst=list(map(int,lst))\n",
    "print(new_lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[112, 121, 116, 104, 111, 110, 32, 105, 115, 32, 102, 117, 110]\n"
     ]
    }
   ],
   "source": [
    "#string to ascii\n",
    "new=list(map(ord,'python is fun'))\n",
    "print(new)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Aakash Sharma', 'Vinay Kumar', 'Jatin Doshi']\n",
      "['Jatin Doshi', 'Vinay Kumar', 'Aakash Sharma']\n"
     ]
    }
   ],
   "source": [
    "def surname_based(name):\n",
    "    return name.split()[1]\n",
    "\n",
    "students=['Aakash Sharma','Vinay Kumar','Jatin Doshi']\n",
    "print(students)\n",
    "students.sort(key=surname_based,reverse=False)\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Aakash Sharma', 'Vinay Kumar', 'Jatin Doshi']\n",
      "['Jatin Doshi', 'Vinay Kumar', 'Aakash Sharma']\n"
     ]
    }
   ],
   "source": [
    "students=['Aakash Sharma','Vinay Kumar','Jatin Doshi']\n",
    "print(students)com\n",
    "students.sort(key=lambda x:x.split()[1],reverse=False)\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Sharma'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "students=['Aakash Sharma','Vinay Kumar','Jatin Doshi']\n",
    "x=students\n",
    "x[0].split()[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### SORT Algorithm\n",
    "\n",
    "1. Get a list\n",
    "2. Apply the key\n",
    "3. Sort it\n",
    "4. Arrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[['Z', 98], ['Y', 97], ['X', 96]]\n",
      "[['X', 96], ['Y', 97], ['Z', 98]]\n"
     ]
    }
   ],
   "source": [
    "employees=[['Z',98],['Y',97],['X',96]]\n",
    "print(employees)\n",
    "employees.sort(key=lambda x:x[1])\n",
    "print(employees)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Z', 98]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test=['Z',98],['y',87]\n",
    "test[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SET\n",
    "\n",
    "\n",
    "**Def**-> A set is a <br>\n",
    " 1. Collection of unique elements.\n",
    " 2. Unordered Collections\n",
    " 3. Mutable\n",
    " 4. can't be indexed\n",
    "----------------------------------------------------------\n",
    "*Operations on Sets*\n",
    "1. Union\n",
    "2. Intersection\n",
    "3. Differeence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set={1,2,3,3,4,5,6,6,6,7}\n",
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__and__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iand__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__ior__',\n",
       " '__isub__',\n",
       " '__iter__',\n",
       " '__ixor__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__or__',\n",
       " '__rand__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__ror__',\n",
       " '__rsub__',\n",
       " '__rxor__',\n",
       " '__setattr__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__sub__',\n",
       " '__subclasshook__',\n",
       " '__xor__',\n",
       " 'add',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'difference',\n",
       " 'difference_update',\n",
       " 'discard',\n",
       " 'intersection',\n",
       " 'intersection_update',\n",
       " 'isdisjoint',\n",
       " 'issubset',\n",
       " 'issuperset',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'symmetric_difference',\n",
       " 'symmetric_difference_update',\n",
       " 'union',\n",
       " 'update']"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(my_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_set.add((123,5,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{(123, 5, 6), 1, 2, 3, 4, 5, 6, 7}"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "set()"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eng={'A','B','C'}\n",
    "prog={'D','E','F'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'A', 'B', 'C'}"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eng - prog"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset({'a', 'b'})"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fs=frozenset(['a','b'])\n",
    "fs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "frozenset"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(fs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc = [ x for x in range(10) if x%2==0 ]\n",
    "lc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 2, 4, 6, 8}"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lc = { x for x in range(10) if x%2==0 }\n",
    "lc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lc "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>\n",
    "    If you quit from the Python interpreter and enter it again, the definitions you have made (functions and variables) are lost. Therefore, if you want to write a somewhat longer program, you are better off using a text editor to prepare the input for the interpreter and running it with that file as input instead. This is known as creating a script. As your program gets longer, you may want to split it into several files for easier maintenance. You may also want to use a handy function that you’ve written in several programs without copying its definition into each program.</p>\n",
    "<p>\n",
    "    To support this, Python has a way to put definitions in a file and use them in a script or in an interactive instance of the interpreter. Such a file is called a module; definitions from a module can be imported into other modules or into the main module (the collection of variables that you have access to in a script executed at the top level and in calculator mode).</p>\n",
    "<p>\n",
    "    A module is a file containing Python definitions and statements. The file name is the module name with the suffix .py appended. Within a module, the module’s name (as a string) is available as the value of the global variable __name__. For instance, use your favorite text editor to create a file called fibo.py in the current directory with the following contents:</p>\n",
    "    \n",
    "~~~~\n",
    "# Fibonacci numbers module\n",
    "\n",
    "def fib(n):    # write Fibonacci series up to n\n",
    "    a, b = 0, 1\n",
    "    while b < n:\n",
    "        print b,\n",
    "        a, b = b, a+b\n",
    "\n",
    "def fib2(n):   # return Fibonacci series up to n\n",
    "    result = []\n",
    "    a, b = 0, 1\n",
    "    while b < n:\n",
    "        result.append(b)\n",
    "        a, b = b, a+b\n",
    "    return result\n",
    "~~~~\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50.26548245743669"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# WAP To calculate area of a circle\n",
    "from math import pi\n",
    "def acircle(radius):\n",
    "    return pi*radius**2\n",
    "def ccircle(radius):\n",
    "    return 2*pi*radius\n",
    "\n",
    "acircle(4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25.132741228718345"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ccircle(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2 µs, sys: 0 ns, total: 2 µs\n",
      "Wall time: 4.77 µs\n",
      "50.26548245743669\n"
     ]
    }
   ],
   "source": [
    "%time\n",
    "from math import pi\n",
    "print(pi*4**2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 2 µs, sys: 0 ns, total: 2 µs\n",
      "Wall time: 4.77 µs\n",
      "50.26548245743669\n"
     ]
    }
   ],
   "source": [
    "%time\n",
    "from math import pi\n",
    "print(pi*4*4)"
   ]
  }
 ],
 "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
}