{
  "cells": [
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Table of content\n* [List Slices](#slice)\n* [List Comprehension](#compre)\n* [Lambda](#lambda)\n* [Map, Filter & Reduce](#map)\n* [Decorator](#dec)\n* [Class](#class)\n* [Iterable, Iterator and Generator](#iter-gen) (optional but recommended to read)"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# List Slices <a name=\"slice\"></a>\n\n__List slices__ provides an advanced way of retrieving values from a list. Basic list slicing involves indexing a list with __two colon-separated integers__. These three arguments are lower limit, upper limit and step. This returns a new list containing all the values in the old list between the indices specified. By default, lower limit is at index 0, upper limit is at the last value and step is +1. \n\nYou can also take a step backwards. When __negative values__ are used for the first and second values in a slice, they __count from the end of list__.\n\n__NOTE__: Slicing can also be done on __tuple__."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:03.418825Z",
          "start_time": "2018-11-13T02:12:03.407403Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "squares = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n\nprint(squares[:])\nprint(squares[::2])\nprint(squares[2:8:2])\nprint(squares[6:])\nprint(squares[4:14])\nprint(squares[1:-2])\nprint(squares[7:1:-2])\nprint(squares[::-1])",
      "execution_count": 1,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n[0, 4, 16, 36, 64]\n[4, 16, 36]\n[36, 49, 64, 81]\n[16, 25, 36, 49, 64, 81]\n[1, 4, 9, 16, 25, 36, 49]\n[49, 25, 9]\n[81, 64, 49, 36, 25, 16, 9, 4, 1, 0]\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# List Comprehension <a name=\"compre\"></a>\n\nList comprehension is a useful way of quickly creating lists using simplified version of _for_ loop statement. A list comprehension __can also contain an if statement__ to enforce a condition on values in the list.\n\n__NOTE__: Trying to create a list, by any means, in a very extensive range will result in a __MemoryError__.\n\n```\nvar = [2*i for i in range(10**100)]\n```\n\n### DON'T EVEN TRY IT!"
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:03.603066Z",
          "start_time": "2018-11-13T02:12:03.460128Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "evens=[i**2 for i in range(10) if i**2 % 2 == 0]\nprint(evens)",
      "execution_count": 2,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "[0, 4, 16, 36, 64]\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Lamda <a name=\"lambda\"></a>\n\nIn Python, __anonymous function__ means a function __without a name__, whereas we use _def_ keyword to create normal functions. The __lambda__ function is used for creating _small, one-time and anonymous_ function objects in Python. The lambda operator can have __any number of arguments__, but it can have __only one expression__. The lambda functions can be assigned to variables, and used like normal functions.\n\nUse lambda functions when an anonymous function is required for a short period of time."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:03.716686Z",
          "start_time": "2018-11-13T02:12:03.606551Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "#named function\ndef polynomial(x):\n    '''\n    Function to perform a polynomial calculation having a single variable x\n    '''\n    return x**2 + 5*x + 4\n\nprint(\"The result for named function: {}\".format(polynomial(-4)))\n\n\n#lambda\npoly = lambda x: x**2 + 5*x + 4\nprint(\"The result for anonymous function: {}\".format(poly(-4)))",
      "execution_count": 3,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "The result for named function: 0\nThe result for anonymous function: 0\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Map, Filter & Reduce <a name=\"map\"></a>\n\nThe built-in functions __map__, __filter__ and __reduce__ are very useful higher-order functions that operate on iterable. \n\nThe function __map__ takes a function and an iterable as _arguments_, and returns a _new iterable_ with the function applied to each argument.\n\nThe function __filter__ filters an iterable by removing items that don't match a __predicate (a function that returns ONLY Boolean True)__.\n\nThe function __reduce__ applies a rolling computation to sequential pairs of values in a iterable i.e., wanted to compute the product of a list items, sum of tuple items.\n\n__NOTE__: Both in map and filter, the result has to be explicitly converted to a list or tuple if you want to print it. Python 2 returns a list by default, but this was changed in Python 3 which returns map or filter object, hence the need for the list or tuple function."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:03.897942Z",
          "start_time": "2018-11-13T02:12:03.720605Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "def add_five(x):\n    return x + 5\n\nnum_var = [11, 22, 33, 44, 55]\nmap_result = list(map(add_five, num_var)) # map\nprint(map_result)\n\nfilter_result = tuple(filter(lambda x: x%2==0, num_var)) # filter\nprint(filter_result)\n\nfrom functools import reduce\nreduce_result = reduce((lambda x, y: x*y), num_var) # reduce\nprint(reduce_result)",
      "execution_count": 4,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "[16, 27, 38, 49, 60]\n(22, 44)\n19326120\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "__Small task__\n\n* Do the same thing shown above in filter code using list comprehension.\n* Solve this:\n\n```\nres = tuple(map(lambda x: x%2==0,num_var))\n```"
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "__Exercise__: Take a n digit (n > 4) number as user input and generate a single digit output by successively adding the digits of the integer."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.187431Z",
          "start_time": "2018-11-13T02:12:03.902454Z"
        },
        "hide_input": true,
        "trusted": true
      },
      "cell_type": "code",
      "source": "num = int(input(\"Enter a number (More than 4 digit number): \"))\nwhile len(str(num))!= 1:\n    num_lst = [int(i) for i in str(num)]\n    num = reduce((lambda x, y: x+y), num_lst)\n    \nprint(num)",
      "execution_count": 5,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "Enter a number (More than 4 digit number): 785234\n2\n"
        }
      ]
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.198080Z",
          "start_time": "2018-11-13T02:12:07.190788Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "# what do you think is the output?\nmylist = [1,2,3,4,5]\n\nprint(tuple(map(lambda x: x if x>1 else 0, mylist)))\nprint(list(filter(lambda x: x if x>1 else 0, mylist)))",
      "execution_count": 6,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "(0, 2, 3, 4, 5)\n[2, 3, 4, 5]\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Decorator <a name=\"dec\"></a>\n\n__Decorator__ are functions which modify the functionality of another function. Let's go one step at a time to understand decorator. In the beginner's article, we have mentioned that Python's function is a __first class object__ which can be\n* dynamically created, destroyed\n* stored in a variable\n* passed to a function as a parameter\n* returned as a value from a function\n\nWe have already seen the first point to be valid in the beginner's article. Let's validate each of these remaining 3 point."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.422834Z",
          "start_time": "2018-11-13T02:12:07.203055Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "## functions can be assigned to a variable\n\ndef my_pymon(text): \n    return \"Let's go, {}\".format(text.upper())\n\ni_choose_you = my_pymon\nprint(i_choose_you('pykachu'))\n\nprint(\"=\"*20)\n\n## functions can be passed as argument to another function\n\ndef your_pymon(text):\n    return f\"{text}\"\n\ndef trainer_select(func):\n    print(func(\"I choose you, 'char'mander\"))\n    \ntrainer_select(your_pymon)\n\nprint(\"=\"*20)\n\n## function returned as a value from another function\n\ndef battle_began_with(mons):\n    def who_won(someone):\n        return f\"In the battle, {someone} won against {mons}\"\n    return who_won\n\nbattle = battle_began_with(\"'char'mander\")(\"pykachu\")\nprint(battle)",
      "execution_count": 7,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "Let's go, PYKACHU\n====================\nI choose you, 'char'mander\n====================\nIn the battle, pykachu won against 'char'mander\n"
        }
      ]
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.559081Z",
          "start_time": "2018-11-13T02:12:07.426901Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "## let's explore more with this \"Marvel\"lous example\n\ndef vision(var = \"Vision\"):\n    print(var+\" is not only a representation of Mind Stone!\")\n    def tony():\n        return \"Yeah! I'm there.\"\n    def banner():\n        return \"I know I'm there too, but what happened with Hulk?\"\n    def mindstone():\n        return \"What are we even discussing?\"\n    \n    print(\"Tony: \",tony())\n    print(\"Banner: \",banner())\n    print(\"Mind Stone: \",mindstone)\n    print(var,\": Enough! I died, came back to life to be killed again! -_-\")\n    \nvision()",
      "execution_count": 8,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "Vision is not only a representation of Mind Stone!\nTony:  Yeah! I'm there.\nBanner:  I know I'm there too, but what happened with Hulk?\nMind Stone:  <function vision.<locals>.mindstone at 0x7f45b05dda60>\nVision : Enough! I died, came back to life to be killed again! -_-\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "__When you put the pair of parentheses after the function name in main of code, only then the function gets executed. If you don’t put parentheses after it, then it can be passed around and can be assigned to other variables without executing it.__"
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.700135Z",
          "start_time": "2018-11-13T02:12:07.565539Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "def my_decor(a_func):\n\n    def wrapper_func():\n        print(\"I am doing some boring work before executing a_func()\")\n        a_func()\n        print(\"I am doing some boring work after executing a_func()\")\n\n    return wrapper_func\n\ndef a_function_requiring_decor():\n    print(\"I am the function which needs some decoration!\")\n    \nprint(a_function_requiring_decor())\n\nprint(\"=\"*50)\n\na_function_requiring_decor = my_decor(a_function_requiring_decor) #the so-called decorator is happening here\nprint(a_function_requiring_decor())",
      "execution_count": 9,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "I am the function which needs some decoration!\nNone\n==================================================\nI am doing some boring work before executing a_func()\nI am the function which needs some decoration!\nI am doing some boring work after executing a_func()\nNone\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The variable __a_function_requiring_decor__ is pointing to the __wrapper_func__ inner function. We are __returning wrapper_func as a function__ when we call __my_decor(a_function_requiring_decor)__. So, __decorator wraps a function, modifying its behavior__.\n\nAnother way to write these decorators is using __\"pie\" syntax, using @ symbol__."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.833876Z",
          "start_time": "2018-11-13T02:12:07.702754Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "def my_decorator(func):\n    def wrapper():\n        print(\"Take the marker and write something on the board.\")\n        func()\n        print(\"Well done!\")\n    return wrapper\n\n@my_decorator\ndef tricky():\n    print(\"SOMETHING!\")\n    \ntricky()",
      "execution_count": 10,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "Take the marker and write something on the board.\nSOMETHING!\nWell done!\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Class <a name=\"class\"></a>\n\nPython is an _object-oriented programming_ (OOP) language and objects are created using __class__ which is actually the focal point of OOP. The class describes an object's blueprint, description or metadata. Multiple object can be instantiated using the _same class_.\n\nClasses are created using the keyword __class__ and an indented block, which contains class _methods_.\n\nLet's take a look at an example."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:07.976210Z",
          "start_time": "2018-11-13T02:12:07.837076Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "class Pet:\n    def __init__(self, genre, name, owner):\n        self.genre = genre \n        self.name = name\n        self.owner = owner\n        \n    def voice(self): #another method added to the class Pet\n        print(\"Growl!\")\n        \npokemon = Pet(\"dog\",\"Arcanine\",\"Tim\")\nprint(pokemon.name)\npokemon.voice()",
      "execution_count": 11,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "Arcanine\nGrowl!\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "The **__ init__** method is the most important method in a class which is called when an instance (object) of the class is created. __All methods must have self as their first parameter__, although you do not need to pass it explicitly when you call the method.\n\nWithin the method definition, __self__ refers to the object itself calling the method. From the above example, we see that\n\n```\npokemon = Pet(\"dog\",\"Arcanine\",\"Tim\")\nprint(pokemon.name)\n>>> Arcanine\n```\n\n* When we create the pokemon object from the class Pet, we are passing _genre, name and owner_ as \"dog\",\"Arcanine\",\"Tim\" and the object (pokemon) will take the place of self.\n* The attributes are accessed using the __dot__ operator.\n* So __pokemon is the object__, \"_Arcanine_\" is the value of the __name__ attribute of this object. \n\nHence, we can access the attributes in a class using this way: __object.attributes__.\n\nClasses can have other methods defined to add functionality to them. These methods are accessed using the same dot syntax as attributes.\n\n__NOTE__: All methods __must have self__ as their first parameter.\n\nTrying to access an attribute of an instance that isn't defined causes an __AttributeError__."
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "# Iterable, Iterator and Generator <a name=\"iter-gen\"></a>\n\n## Iterable and Iterator\n\nIteration -> Repetition of a process.\n\n__Iterable__ is a type of object which would __generate an Iterator__ when passed to in-built method __iter()__.\n\n__Iterator__ is an object which is used to iterate over an _iterable object_ using __next__() method, which returns the next item of the _iterable object_.  Any object that has a __next__() method is therefore an iterator.\n\n__NOTE__: List, Tuple, Set, Frozenset, Dictionary are in-built __iterable objects__. They are __iterable containers__ from which you can get an __iterator__."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:08.127343Z",
          "start_time": "2018-11-13T02:12:07.979739Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "## Let's see an example\nmy_tuple = [\"apple\", \"banana\", \"cherry\"]\niterated_tuple = iter(my_tuple)\n\nprint(type(iterated_tuple))\nprint(next(iterated_tuple))\nprint(next(iterated_tuple))\nprint(next(iterated_tuple))",
      "execution_count": 12,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "<class 'list_iterator'>\napple\nbanana\ncherry\n"
        }
      ]
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:08.245412Z",
          "start_time": "2018-11-13T02:12:08.129778Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "## same thing can be written using for loop\nmy_tuple = (\"apple\", \"banana\", \"cherry\")\n\nfor i in my_tuple:\n    print(i)",
      "execution_count": 13,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "apple\nbanana\ncherry\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "**How for loop actually works?**\n\nThe for loop can iterate over any iterable. \n\n```\nfor element in iterable:\n    # do something with element\n```\n\nis actually implemented as\n\n```\n# create an iterator object from that iterable\niter_obj = iter(iterable)\n\n# infinite loop\nwhile True:\n    try:\n        # get the next item\n        element = next(iter_obj)\n        # do something with element\n    except StopIteration:\n        # if StopIteration is raised, break from loop\n        break\n```\n\n* The for loop creates an iterator object internally, __iter_obj__ by calling _iter()_ on the iterable.\n* Inside the __while loop__, it calls _next()_ to get the next element and executes further\n* After all the items exhaust, __StopIteration__ exception is raised which is internally caught and the loop ends.\n\nTo get a better sense of the internals of an iterator, let's build an iterator producing the __Fibonacci numbers__."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:08.395122Z",
          "start_time": "2018-11-13T02:12:08.250693Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "from itertools import islice\n\nclass fib:\n     def __init__(self):\n        self.prev = 0\n        self.curr = 1\n \n     def __iter__(self):\n        return self\n \n     def __next__(self):\n        value = self.curr\n        self.curr += self.prev\n        self.prev = value\n        return value\n\nf = fib()\nprint(list(islice(f, 0, 10)))",
      "execution_count": 14,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "## Generator\n\nA lot of overhead in building an iterator:\n* implement a class with iter() and next() methods\n* raise StopIteration when there was no values to be returned\n* makes the code lengthy\n\nPython Generators are a simple way of creating iterators. All the above mentioned overhead are automatically handled by generators in Python.\n\n__Generator__ is a block of code, same as defining a function, having a __yield__ statement instead of a __return__ statement.\n\nIf a function contains **at least one yield** statement (it may contain other yield or return statements), it becomes a generator!\n\nThis is how the above Fibonacci number code looks like using generator."
    },
    {
      "metadata": {
        "ExecuteTime": {
          "end_time": "2018-11-13T02:12:08.517831Z",
          "start_time": "2018-11-13T02:12:08.398265Z"
        },
        "trusted": true
      },
      "cell_type": "code",
      "source": "def fib():\n    prev, curr = 0, 1\n    while True:\n        yield curr\n        prev, curr = curr, prev + curr\n\nf = fib()\nprint(list(islice(f, 0, 10)))",
      "execution_count": 15,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": "[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n"
        }
      ]
    },
    {
      "metadata": {},
      "cell_type": "markdown",
      "source": "### Let's see what happened.\n\nTake note that __fib__ is defined as a normal Python function, not as class. However, there's __no return keyword__ inside the function body. __The return value of the function will be a generator__.\n\n1. Now when __f = fib()__ is called, the generator is instantiated and returned. __No code will be executed__ at this point.To be explicit: the line prev, curr = 0, 1 is not executed yet.\n\n2. Then, this generator instance is wrapped in an islice(). This is itself also an iterator. Again, no code executed.\n\n3. Now, this iterator is wrapped in a __list()__, which will take the argument and build a list from it. To do so, it will start calling next() on the islice() instance, which in turn will start calling next() on our f instance.\n\n4. On the first call, the code __prev, curr = 0, 1__ gets executed, then the __while True__ loop is entered, and then it encounters the __yield curr__ statement. It will produce the value that's currently in the _curr_ variable and become idle again. This value is passed to the _islice()_ wrapper, which will produce the value (1 in this case) and list can add the value to the list.\n\n5. Then, list asks islice() for the next value, which will ask f for the next value, which will _unpause_ f from its previous state, resuming with the statement __prev, curr = curr, prev + curr__. \n\n6. Then it re-enters the next iteration of the __while True__ loop, and hits the __yield curr__ statement, returning the next value of curr.\n\n7. This happens until the output list is 10 elements long. When list() asks islice() for the 11th value, islice() will raise a __StopIteration__ exception, indicating that the end has been reached, and list will return the result: a list of 10 items, containing the first 10 Fibonacci numbers.\n\nThere are two types of generators in Python: __generator functions__ and __generator expressions__. A generator function is any function in which the keyword __yield__ appears in its body. We just saw an example of that. Generator expression is equivalent to list comprehension."
    }
  ],
  "metadata": {
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3",
      "language": "python"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "gist": {
      "id": "",
      "data": {
        "description": "Python Notebook | Intermediate | Part 2.ipynb",
        "public": true
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}