AI6-Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# StackOverflow :- So you want to write *_Pythonic code_* in *_Python_* \n",
    "## Learn These \n",
    "        1. Lambda and Comphresions\n",
    "        2. Decorators\n",
    "        3. Context Managers\n",
    "        4. Iterators and Generators\n",
    "        6. Functools and Itertools\n",
    "        5. Data Classes\n",
    "        7. Some Sweet Python tips and tricks"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# _Lambda and Comphresions_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Functions in python are first class Objects that means you can assign them to variable, store them in data structure, pass them as a parameter to other functions and even return them from other function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " function is add(5,6) = 11\n",
      " function is myAdd(5,6) = 11\n",
      "add\n"
     ]
    }
   ],
   "source": [
    "# addition function \n",
    "def add(x, y):\n",
    "    return x+y\n",
    "print (f\" function is add(5,6) = {add(5,6)}\")\n",
    "# you can assign them to other variable\n",
    "myAdd = add\n",
    "# wait you can also delete the add function and  the myAdd still points to underlying function\n",
    "del add\n",
    "print (f\" function is myAdd(5,6) = {myAdd(5,6)}\")\n",
    "#functions have their own set of attributes \n",
    "print(f\"{myAdd.__name__}\")\n",
    "# to see a complete list of attributes of a function type dir(myAdd) in console"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<method 'upper' of 'str' objects> AI6-SATURDAYS\n",
      "<method 'lower' of 'str' objects> ai6-saturdays\n",
      "<method 'title' of 'str' objects> Ai6-Saturdays\n"
     ]
    }
   ],
   "source": [
    "# functions as data structures\n",
    "List_Funcs = [str.upper , str.lower , str.title]\n",
    "for f in List_Funcs:\n",
    "    print (f , f(\"aI6-saturdays\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### So lambdas are a  sweet Little anonymous Single-Expression functions "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lambda value add_lambda(2,3)= 5\n"
     ]
    }
   ],
   "source": [
    "add_lambda = lambda x , y : x+y # lambda automaticaly returns the value after colon\n",
    "print(f\"lambda value add_lambda(2,3)= {add_lambda(2,3)}\") #you call lambda function as normal functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- But Wait  it's an anonymous function and how can you  give it a name\n",
    "## StackOverflow :- Relax, Searching for another example"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'We will democratize AI by teaching everyone AI'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def someFunc(func):\n",
    "    quote = func(\"We will democratize AI \")\n",
    "    return quote\n",
    "# here the lambda function is passes to a normal function \n",
    "# the lambda here is anonymous and the parameter my_sentence = We will democratize AI \n",
    "# so we are adding some text of ours and returning the string\n",
    "someFunc(lambda my_sentence: my_sentence+\"by teaching everyone AI\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here is one more example\n",
    "tuples = [(1, 'd'), (2, 'b'), (4, 'a'), (3, 'c')]\n",
    "sorted(tuples, key=lambda x: x[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],\n",
       " [0, 2, 4, 6, 8, 10, 12, 14, 16, 18],\n",
       " [0, 0, 2, 0, 4, 0, 6, 0, 8, 0, 10, 0, 12, 0, 14, 0, 16, 0, 18, 0])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# list comphrensions\n",
    "l = [ x for x in range(20)]\n",
    "even_list = [x for x in l if x%2==0]\n",
    "even_list_with_Zero = [x if x%2==0 else 0 for x in l ]\n",
    "l , even_list ,even_list_with_Zero"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "({2: 4, 3: 9, 4: 16, 5: 25}, {4: 2, 9: 3, 16: 4, 25: 5})"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# dictionary comphrension\n",
    "d = {x: x**2 for x in range(2,6)}\n",
    "flip_key_value = {value:key for key,value in d.items()}\n",
    "d , flip_key_value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Decorators\n",
    "Python’s decorators allow you to extend and modify the\n",
    "behavior of a callable (functions, methods, and classes) without permanently modifying the callable itself.\n",
    "\n",
    "Any sufficiently generic functionality you can tack on to an existing\n",
    "class or function’s behavior makes a great use case for decoration.\n",
    "This includes the following:\n",
    "\n",
    "1. logging\n",
    "2. enforcing access control and authentication\n",
    "3. instrumentation and timing functions\n",
    "4. rate-limiting\n",
    "5. caching, and more\n",
    "\n",
    "Imagine that you some 50 functions in your code. Now that all functions are working you being a great programmer thought of optimizing each function by checking the amount of time it takes and also you need to log the input/output of few functions. what are you gonna do ? \n",
    "\n",
    "Without decorators you might be spending the next three days modifying each of those 50 functions and clutter them up with your manual logging calls. Fun times, right?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " someFunc value  = Deep learning is fun\n"
     ]
    }
   ],
   "source": [
    "def my_decorator(func):\n",
    "    return func  # It's simple right it takes a function as it's parameter and returns it\n",
    "def someFunc():\n",
    "    return \"Deep learning is fun\"\n",
    "someFunc = my_decorator(someFunc) # it is similar to i = i + 1\n",
    "print(f\" someFunc value  = {someFunc()}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " someFunc value  = Deep learning is fun\n"
     ]
    }
   ],
   "source": [
    "# now just to add syntatic sugar to the code so that we can brag how easy and terse python code is \n",
    "# we gonna write this way\n",
    "def my_decorator(func):\n",
    "    return func \n",
    "\n",
    "@my_decorator  # the awesomeness of this block of code lies here which can be used as toggle switch\n",
    "def someFunc():\n",
    "    return \"Deep learning is fun\"\n",
    "\n",
    "print(f\" someFunc value  = {someFunc()}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Stackoverflow :- Now that you got a little taste of Decorators let's write another decorator that actually does something and modifies the behavior of the decorated function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(' Executed output is YOU HAD ME AT HELLO WORLD and time is 2.0032527446746826 ',\n",
       " None,\n",
       " 'wrapper')"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# This blocks contains and actual implementation of decorator\n",
    "import time\n",
    "#import functools\n",
    "\n",
    "def myTimeItDeco(func):\n",
    "    #@functools.wraps(func)\n",
    "    def wrapper(*args,**kwargs):\n",
    "        starttime = time.time()\n",
    "        call_of_func = func(*args,**kwargs) # this works because you can function can be nested and they remember the state\n",
    "        function_modification = call_of_func.upper()\n",
    "        endtime = time.time()\n",
    "        return f\" Executed output is {function_modification} and time is {endtime-starttime} \"\n",
    "    return wrapper\n",
    "\n",
    "@myTimeItDeco\n",
    "def myFunc(arg1,arg2,arg3): # some arguments of no use to show how to pass them in code\n",
    "    \"\"\"Documentation of a obfuscate function\"\"\"\n",
    "    time.sleep(2) # just to show some complex calculation\n",
    "    return \"You had me at Hello world\"\n",
    "\n",
    "myFunc(1,2,3) , myFunc.__doc__ , myFunc.__name__ "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :-  Why didn't I got the doc and the name of my function. Hmmm....\n",
    "## StackOverflow :- Great Programmers use me as there debugging tool, so use It.\n",
    "Hints functools.wrap "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### StackOverflow : - Applying Multiple Decorators to a Function (This is really fascinating as it's gonna confuse you)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<strong><em>Hello!</em></strong>'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def strong(func):\n",
    "    def wrapper():\n",
    "        return '<strong>' + func() + '</strong>'\n",
    "    return wrapper\n",
    "\n",
    "def emphasis(func):\n",
    "    def wrapper():\n",
    "        return '<em>' + func() + '</em>'\n",
    "    return wrapper\n",
    "\n",
    "@strong\n",
    "@emphasis\n",
    "def greet():\n",
    "    return 'Hello!'\n",
    "\n",
    "\n",
    "greet()\n",
    "# this is your assignment to understand it hints strong(emphasis(greet))()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Disclaimer Execute this at your own risk \n",
    "#Only  80's kids will remember this\n",
    "import dis\n",
    "dis.dis(greet)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Context Managers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let's open  a file and write some thing into it\n",
    "file = open('hello.txt', 'w')\n",
    "try:\n",
    "    file.write('Some thing')\n",
    "finally:\n",
    "    file.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- ok now that I have wrote something into the file I want to read it,  but try and finally again, it suck's. There should be some other way around\n",
    "\n",
    "## StackOverflow :-  Context manger for your Rescue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some thing\n"
     ]
    }
   ],
   "source": [
    "with open(\"hello.txt\") as file:\n",
    "    print(file.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- That's pretty easy but what is *_with_*\n",
    "## Stackoverflow :- \n",
    "It helps python programmers like you to simplify some common resource management patterns by abstracting their functionality\n",
    "and allowing them to be factored out and reused. \n",
    "\n",
    "So in this case you don't have to open and close file all done for you automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# A good pattern for with use case is this \n",
    "some_lock = threading.Lock()\n",
    "\n",
    "# Harmful:\n",
    "some_lock.acquire()\n",
    "    try:\n",
    "        # Do something complicated because you are coder and you love to do so ...\n",
    "    finally:\n",
    "        some_lock.release()\n",
    "\n",
    "# Better :\n",
    "with some_lock:\n",
    "    # Do something awesome Because you are a Data Scientist..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- But I want to use *_with_* for my own use case how do I do it? \n",
    "\n",
    "## StackOverflow :- Use Data Models and relax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some thing\n"
     ]
    }
   ],
   "source": [
    "# Python is language full of hooks and protocol\n",
    "# Here MyContextManger abides context manager protocol\n",
    "class MyContextManger:\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name=name\n",
    "# with statement automatically calls __enter__ and __exit__ methods        \n",
    "    def __enter__(self):  ## Acquire the lock do the processing in this method\n",
    "        self.f = open(self.name,\"r\")\n",
    "        return self.f\n",
    "    \n",
    "    def __exit__(self,exc_type,exc_val,exc_tb): ## release the lock and free allocated resources in this method\n",
    "        if self.f:\n",
    "            self.f.close()\n",
    "            \n",
    "with MyContextManger(\"hello.txt\") as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- It works but what are those parameters in __exit__ method \n",
    "## Stackoverflow :- Google It !\n",
    "## You :- But writing a class in python is hectic, I want to do functional Programming\n",
    "## StackOverflow :- Use Decorators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Some thing\n"
     ]
    }
   ],
   "source": [
    "from contextlib import contextmanager\n",
    "\n",
    "@contextmanager\n",
    "def mySimpleContextManager(name):\n",
    "    try:\n",
    "        f = open(name, 'r')\n",
    "        yield f\n",
    "    finally:\n",
    "        f.close()\n",
    "        \n",
    "with mySimpleContextManager(\"hello.txt\")  as f:\n",
    "    print(f.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- Ok, that's what I call a pythonic code but what is yeild\n",
    "## Stackoverflow :-  Hang On! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Iterators and Generators\n",
    "\n",
    "An iterator is an object representing a stream of data; this object returns the data one element at a time. A Python iterator must support a method called __next__() that takes no arguments and always returns the next element of the stream. If there are no more elements in the stream, __next__() must raise the StopIteration exception. Iterators don’t have to be finite, though; it’s perfectly reasonable to write an iterator that produces an infinite stream of data.\n",
    "\n",
    "The built-in iter() function takes an arbitrary object and tries to return an iterator that will return the object’s contents or elements, raising TypeError if the object doesn’t support iteration. Several of Python’s built-in data types support iteration, the most common being lists and dictionaries. An object is called iterable if you can get an iterator for it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "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-90-ff980989da7a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mit\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m## gives 2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mit\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m## gives 3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mit\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m## gives error StopIteration\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "l = [1,2,3]\n",
    "it = l.__iter__()  ## same as iter(l)\n",
    "it.__next__() ## gives 1\n",
    "next(it) ## gives 2\n",
    "next(it) ## gives 3\n",
    "next(it) ## gives error StopIteration"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#lets replicate the simple range method\n",
    "class MyRange:\n",
    "    def __init__(self,start,stop):\n",
    "        self.start = start -1\n",
    "        self.stop = stop\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __next__(self):\n",
    "        self.start = self.start+1\n",
    "        if self.start<self.stop:\n",
    "            return self.start\n",
    "        else:\n",
    "            raise StopIteration()\n",
    "                \n",
    "for i in MyRange(2,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## You :- Again a class\n",
    "## StackOverflow :- OK here's a easy way Use Generators\n",
    "They Simplify writing Iterators, kind of iterable you can only iterate over once. Generators do not store the values in memory, they generate the values on the fly so no storage is required.\n",
    "So you ask one value it will generate and spit it out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "def myRange(start,stop):\n",
    "    while True:\n",
    "        if start<stop:\n",
    "            yield start\n",
    "            start = start+1\n",
    "        else:\n",
    "            return \n",
    "for i in myRange(2,10):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You’re doubtless familiar with how regular function calls work in Python or C. When you call a function, it gets a private namespace where its local variables are created. When the function reaches a return statement, the local variables are destroyed and the value is returned to the caller. A later call to the same function creates a new private namespace and a fresh set of local variables. But, what if the local variables weren’t thrown away on exiting a function? What if you could later resume the function where it left off? This is what generators provide; they can be thought of as resumable functions.\n",
    "\n",
    "Any function containing a yield keyword is a generator function; this is detected by Python’s bytecode compiler which compiles the function specially as a result.\n",
    "\n",
    "When you call a generator function, it doesn’t return a single value; instead it returns a generator object that supports the iterator protocol. On executing the yield expression, the generator outputs the value start , similar to a return statement. The big difference between yield and a return statement is that on reaching a yield the generator’s state of execution is suspended and local variables are preserved. On the next call to the generator’s __next__() method, the function will resume executing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<generator object <genexpr> at 0x7f6f905e0fc0>"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# generator comphresnsive\n",
    "l = ( x for x in range(20))\n",
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[*l]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let’s look in more detail at built-in functions often used with iterators.\n",
    "\n",
    "Two of Python’s built-in functions, map() and filter() duplicate the features of generator expressions:\n",
    "\n",
    "map(f, iterA, iterB, ...) returns an iterator over the sequence\n",
    "\n",
    "    f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ....\n",
    "\n",
    "filter(predicate, iter) \n",
    "returns an iterator over all the sequence elements that meet a certain condition, and is similarly duplicated by list comprehensions. A predicate is a function that returns the truth value of some condition; for use with filter(), the predicate must take a single value."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# why did it returned an empty list think?\n",
    "[*map(lambda x :x **2 , l)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<filter at 0x7f6f9057f9e8>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[*filter(lambda x :x%2!=0,l)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip(iterA, iterB, ...) takes one element from each iterable and returns them in a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1\n",
      "b 2\n",
      "c 3\n"
     ]
    }
   ],
   "source": [
    "z = zip(['a', 'b', 'c'], (1, 2, 3))\n",
    "for x , y in z:\n",
    "    print (x,y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functools and Itertools (This is going to blow your mind)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "These two python modules are super helpful in writing Efficient Functional Code "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# reduce\n",
    "from functools import reduce\n",
    "l = (x for x in range(1,10))\n",
    "reduce(lambda x,y : x+y , l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For programs written in a functional style, you’ll sometimes want to construct variants of existing functions that have some of the parameters filled in. Consider a Python function f(a, b, c); you may wish to create a new function g(b, c) that’s equivalent to f(1, b, c); you’re filling in a value for one of f()’s parameters. This is called “partial function application”.\n",
    "\n",
    "The constructor for partial() takes the arguments (function, arg1, arg2, ..., kwarg1=value1, kwarg2=value2). The resulting object is callable, so you can just call it to invoke function with the filled-in arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "server: Unable to open socket\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "def log(message, subsystem):\n",
    "    \"\"\"Write the contents of 'message' to the specified subsystem.\"\"\"\n",
    "    print('%s: %s' % (subsystem, message))\n",
    "    ...\n",
    "\n",
    "server_log = partial(log, subsystem='server')\n",
    "server_log('Unable to open socket')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import islice ,takewhile,dropwhile\n",
    "\n",
    "# here is a very simple implementation of the fibonacci sequence \n",
    "def fib(x=0 , y=1):\n",
    "    while True:\n",
    "        yield x\n",
    "        x , y = y , x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(islice(fib(),10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 1, 2, 3]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(takewhile(lambda x : x < 5  , islice(fib(),10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 8, 13, 21, 34]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dropwhile(lambda x : x < 5  , islice(fib(),10)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[13, 21, 34, 55, 89, 144]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(dropwhile(lambda x :x<11 , takewhile(lambda x : x < 211  , islice(fib(),15))))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### To read more about itertools https://docs.python.org/3.6/howto/functional.html#creating-new-iterators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Some Python Tricks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#normal calculator prorgramm\n",
    "def calculator(operator , x , y):\n",
    "    if operator==\"add\":\n",
    "        return x+y\n",
    "    elif operator==\"sub\":\n",
    "        return x-y\n",
    "    elif operator == \"div\":\n",
    "        return x/y\n",
    "    elif operator==\"mul\":\n",
    "        return x*y\n",
    "    else :\n",
    "        return \"unknow\"\n",
    "calculator(\"add\",2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Pythonic way \n",
    "calculatorDict = {\n",
    "    \"add\":lambda x,y:x+y,\n",
    "    \"sub\":lambda x,y:x-y,\n",
    "    \"mul\":lambda x,y:x*y,\n",
    "    \"div\":lambda x,y:x/y\n",
    "}\n",
    "calculatorDict.get(\"add\",lambda x , y:None)(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# because we are repeating x,y in all lambda so better approach\n",
    "def calculatorCorrected(operator,x,y):\n",
    "    return {\n",
    "    \"add\":lambda :x+y,\n",
    "    \"sub\":lambda :x-y,\n",
    "    \"mul\":lambda :x*y,\n",
    "    \"div\":lambda :x/y\n",
    "}.get(operator , lambda :\"None\")()\n",
    "\n",
    "calculatorCorrected(\"add\",2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 2, 3: 5, 6: 7}"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# How to merge multiple dictionaries\n",
    "x = {1:2,3:4} \n",
    "y = {3:5,6:7}\n",
    "{**x,**y}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how to merge multiple list you gussed it correct \n",
    "a = [1,2,3]\n",
    "b=[2,3,4,5]\n",
    "[*a,*b]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Vector(x=11, y=12, z=212, k=343), 11, 12)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Named tuple\n",
    "from collections import namedtuple\n",
    "from sys import getsizeof\n",
    "vector = namedtuple(\"Vector\" , [\"x\",\"y\",\"z\",\"k\"])(11,12,212,343)\n",
    "vector,vector[0], vector.y # can be accessed lke list and dic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Counter({'7.76mm': 60, 'kar98': 1})\n",
      "Counter({'7.76mm': 90, '5.56mm': 30, 'kar98': 1, 'scarl': 1})\n"
     ]
    }
   ],
   "source": [
    "# how to manage a dictionary with count\n",
    "from collections import Counter\n",
    "pubg_level3_bag = Counter()\n",
    "kill = {\"kar98\":1 , \"7.76mm\":60}\n",
    "pubg_level3_bag.update(kill)\n",
    "print(pubg_level3_bag)\n",
    "more_kill = {\"7.76mm\":30 , \"scarl\":1 , \"5.56mm\":30}\n",
    "pubg_level3_bag.update(more_kill)\n",
    "print(pubg_level3_bag)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# don't remove element from the front of a list in python use instead deque\n",
    "from collections import deque\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for Datastructure with locking functionality use queue module in python\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# how to check if the data structure is iterable\n",
    "from collections import Iterable\n",
    "isinstance([1,2,3] , Iterable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Refer these To be *GREAT IN PYTHON*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Python Doc](https://docs.python.org/3/)\n",
    "\n",
    "### [Real Python](https://realpython.com/)\n",
    "\n",
    "### [Youtube PyData](https://www.youtube.com/user/PyDataTV)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# THE END"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n"
   ]
  }
 ],
 "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}