004_Python_Decorators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<small><small><i>\n",
    "All the IPython Notebooks in **Python Advanced Topics** lecture series by Dr. Milaan Parmar are available @ **[GitHub](https://github.com/milaan9/07_Python_Advanced_Topics)**\n",
    "</i></small></small>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Decorators\n",
    "\n",
    "A decorator takes in a function, adds some functionality and returns it. In this tutorial, you will learn how you can create a decorator and why you should use it."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorators in Python\n",
    "\n",
    "Python has an interesting feature called **decorators** to add functionality to an existing code.\n",
    "\n",
    "A **decorator** is a design pattern in Python that allows a user to add new functionality to an existing object without modifying its structure. Decorators are usually called before the definition of a function you want to decorate.\n",
    "\n",
    "This is also called **metaprogramming** because a part of the program tries to modify another part of the program at compile time."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisites for learning decorators\n",
    "\n",
    "In order to understand about decorators, we must first know a few basic things in Python.\n",
    "\n",
    "We must be comfortable with the fact that everything in Python (Yes! Even classes), are **[objects](https://github.com/milaan9/06_Python_Object_Class/blob/main/002_Python_Classes_and_Objects.ipynb)**. Names that we define are simply identifiers bound to these objects. **[Functions](https://github.com/milaan9/04_Python_Functions/blob/main/001_Python_Functions.ipynb)** are no exceptions, they are objects too (with attributes). Various different names can be bound to the same function object.\n",
    "\n",
    "For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.317301Z",
     "start_time": "2021-10-18T07:48:26.300703Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n",
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def first(msg):\n",
    "    print(msg)\n",
    "\n",
    "\n",
    "first(\"Hello\")\n",
    "\n",
    "second = first\n",
    "second(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run the code, both functions **`first`** and **`second`** give the same output. Here, the names **`first`** and **`second`** refer to the same function object.\n",
    "\n",
    "Now things start getting weirder.\n",
    "\n",
    "Functions can be passed as arguments to another function.\n",
    "\n",
    "If you have used functions like **`map`**, **`filter`** and **`reduce`** in Python, then you already know about this.\n",
    "\n",
    "Such functions that take other functions as arguments are also called **higher order functions**. Here is an example of such a function.\n",
    "\n",
    "```python\n",
    ">>> def inc(x):\n",
    ">>>     return x + 1\n",
    "\n",
    "\n",
    ">>> def dec(x):\n",
    ">>>     return x - 1\n",
    "\n",
    "\n",
    ">>> def operate(func, x):\n",
    ">>>     result = func(x)\n",
    ">>>     return result\n",
    "```\n",
    "\n",
    "We invoke the function as follows:\n",
    "\n",
    "```python\n",
    ">>> operate(inc,3)\n",
    "4\n",
    ">>> operate(dec,3)\n",
    "2\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Furthermore, a function can return another function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.441323Z",
     "start_time": "2021-10-18T07:48:26.325114Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "def is_called():  # created 1st function\n",
    "    def is_returned():  # Created 2nd function (nested)\n",
    "        print(\"Hello\")\n",
    "    return is_returned\n",
    "\n",
    "\n",
    "new = is_called()\n",
    "\n",
    "# Outputs \"Hello\"\n",
    "new()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, **`is_returned()`** is a nested function which is defined and returned each time we call **`is_called()`**.\n",
    "\n",
    "Finally, we must know about **[Closures in Python](https://github.com/milaan9/07_Python_Advanced_Topics/blob/main/003_Python_Closure.ipynb)**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.564373Z",
     "start_time": "2021-10-18T07:48:26.445231Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WELCOME TO PYTHON\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "# Normal function\n",
    "def greeting():\n",
    "    return 'Welcome to Python'\n",
    "def uppercase_decorator(function):\n",
    "    def wrapper():\n",
    "        func = function()\n",
    "        make_uppercase = func.upper()\n",
    "        return make_uppercase\n",
    "    return wrapper\n",
    "g = uppercase_decorator(greeting)\n",
    "print(g())          # WELCOME TO PYTHON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us implement the example above with a decorator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.656167Z",
     "start_time": "2021-10-18T07:48:26.569255Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WELCOME TO PYTHON\n"
     ]
    }
   ],
   "source": [
    "'''This decorator function is a higher order function\n",
    "that takes a function as a parameter'''\n",
    "def uppercase_decorator(function):\n",
    "    def wrapper():\n",
    "        func = function()\n",
    "        make_uppercase = func.upper()\n",
    "        return make_uppercase\n",
    "    return wrapper\n",
    "@uppercase_decorator\n",
    "def greeting():\n",
    "    return 'Welcome to Python'\n",
    "print(greeting())   # WELCOME TO PYTHON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Getting back to Decorators\n",
    "\n",
    "Functions and methods are called **callable** as they can be called.\n",
    "\n",
    "In fact, any object which implements the special **`__call__()`** method is termed callable. So, in the most basic sense, a decorator is a callable that returns a callable.\n",
    "\n",
    "Basically, a decorator takes in a function, adds some functionality and returns it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.732339Z",
     "start_time": "2021-10-18T07:48:26.662029Z"
    }
   },
   "outputs": [],
   "source": [
    "def make_pretty(func):\n",
    "    def inner():\n",
    "        print(\"I got decorated\")\n",
    "        func()\n",
    "    return inner\n",
    "\n",
    "\n",
    "def ordinary():\n",
    "    print(\"I am ordinary\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run the following codes in shell,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.855386Z",
     "start_time": "2021-10-18T07:48:26.738200Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am ordinary\n"
     ]
    }
   ],
   "source": [
    "ordinary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:26.947183Z",
     "start_time": "2021-10-18T07:48:26.859294Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I got decorated\n",
      "I am ordinary\n"
     ]
    }
   ],
   "source": [
    "pretty = make_pretty(ordinary)\n",
    "pretty()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example shown above, **`make_pretty()`** is a decorator. In the assignment step:\n",
    "\n",
    "```python\n",
    ">>> pretty = make_pretty(ordinary)\n",
    "```\n",
    "\n",
    "The function **`ordinary()`** got decorated and the returned function was given the name **`pretty`**.\n",
    "\n",
    "We can see that the decorator function added some new functionality to the original function. This is similar to packing a gift. The decorator acts as a wrapper. The nature of the object that got decorated (actual gift inside) does not alter. But now, it looks pretty (since it got decorated).\n",
    "\n",
    "Generally, we decorate a function and reassign it as,\n",
    "\n",
    "```python\n",
    ">>> ordinary = make_pretty(ordinary).\n",
    "```\n",
    "\n",
    "This is a common construct and for this reason, Python has a syntax to simplify this.\n",
    "\n",
    "We can use the **`@`** symbol along with the name of the decorator function and place it above the definition of the function to be decorated. For example,\n",
    "\n",
    "```python\n",
    ">>> @make_pretty\n",
    ">>> def ordinary():\n",
    ">>>     print(\"I am ordinary\")\n",
    "```\n",
    "\n",
    "is equivalent to\n",
    "\n",
    "```python\n",
    ">>> def ordinary():\n",
    ">>>     print(\"I am ordinary\")\n",
    ">>> ordinary = make_pretty(ordinary)\n",
    "```\n",
    "\n",
    "This is just a syntactic sugar to implement decorators."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Decorating Functions with Parameters\n",
    "\n",
    "The above decorator was simple and it only worked with functions that did not have any parameters. What if we had functions that took in parameters like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:27.039956Z",
     "start_time": "2021-10-18T07:48:26.950114Z"
    }
   },
   "outputs": [],
   "source": [
    "def divide(a, b):\n",
    "    return a/b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This function has two parameters, **`a`** and **`b`**. We know it will give an error if we pass in **`b`** as **`0`**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:27.178627Z",
     "start_time": "2021-10-18T07:48:27.045818Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.4"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "divide(2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:27.549723Z",
     "start_time": "2021-10-18T07:48:27.193281Z"
    }
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-10-030e2eec799d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdivide\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-8-7507bdc665d5>\u001b[0m in \u001b[0;36mdivide\u001b[1;34m(a, b)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mdivide\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mb\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m/\u001b[0m\u001b[0mb\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "divide(2,0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's make a decorator to check for this case that will cause the error."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:42.911066Z",
     "start_time": "2021-10-18T07:48:42.900326Z"
    }
   },
   "outputs": [],
   "source": [
    "def smart_divide(func):\n",
    "    def inner(a, b):\n",
    "        print(\"I am going to divide\", a, \"and\", b)\n",
    "        if b == 0:\n",
    "            print(\"Whoops! cannot divide with 0\")\n",
    "            return\n",
    "\n",
    "        return func(a, b)\n",
    "    return inner\n",
    "\n",
    "\n",
    "@smart_divide\n",
    "def divide(a, b):\n",
    "    print(a/b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This new implementation will return **`None`** if the error condition arises."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:43.709409Z",
     "start_time": "2021-10-18T07:48:43.699644Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am going to divide 2 and 5\n",
      "0.4\n"
     ]
    }
   ],
   "source": [
    "divide(2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:43.986754Z",
     "start_time": "2021-10-18T07:48:43.973080Z"
    },
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am going to divide 2 and 0\n",
      "Whoops! cannot divide with 0\n"
     ]
    }
   ],
   "source": [
    "divide(2,0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:44.264095Z",
     "start_time": "2021-10-18T07:48:44.256284Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am Milaan Parmar. I love to teach.\n",
      "I live in London\n"
     ]
    }
   ],
   "source": [
    "# Example:\n",
    "\n",
    "def decorator_with_parameters(function):\n",
    "    def wrapper_accepting_parameters(para1, para2, para3):\n",
    "        function(para1, para2, para3)\n",
    "        print(\"I live in {}\".format(para3))\n",
    "    return wrapper_accepting_parameters\n",
    "\n",
    "@decorator_with_parameters\n",
    "def print_full_name(first_name, last_name, country):\n",
    "    print(\"I am {} {}. I love to teach.\".format(\n",
    "        first_name, last_name, country))\n",
    "\n",
    "print_full_name(\"Milaan\", \"Parmar\",'London')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this manner, we can decorate functions that take parameters.\n",
    "\n",
    "A keen observer will notice that parameters of the nested **`inner()`** function inside the decorator is the same as the parameters of functions it decorates. Taking this into account, now we can make general decorators that work with any number of parameters.\n",
    "\n",
    "In Python, this magic is done as **`function(*args, **kwargs)`**. In this way, **`args`** will be the **[tuple](https://github.com/milaan9/02_Python_Datatypes/blob/main/004_Python_Tuple.ipynb)** of positional arguments and **`kwargs`** will be the **[dictionary](https://github.com/milaan9/02_Python_Datatypes/blob/main/005_Python_Dictionary.ipynb)** of keyword arguments. An example of such a decorator will be:\n",
    "\n",
    "```python\n",
    ">>> def works_for_all(func):\n",
    ">>>     def inner(*args, **kwargs):\n",
    ">>>         print(\"I can decorate any function\")\n",
    ">>>         return func(*args, **kwargs)\n",
    ">>>     return inner\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chaining Decorators in Python\n",
    "\n",
    "Multiple decorators can be chained in Python.\n",
    "\n",
    "This is to say, a function can be decorated multiple times with different (or same) decorators. We simply place the decorators above the desired function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:45.171321Z",
     "start_time": "2021-10-18T07:48:45.147886Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "******************************\n",
      "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
      "Hello\n",
      "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
      "******************************\n"
     ]
    }
   ],
   "source": [
    "def star(func):\n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"*\" * 30)\n",
    "        func(*args, **kwargs)\n",
    "        print(\"*\" * 30)\n",
    "    return inner\n",
    "\n",
    "\n",
    "def percent(func):\n",
    "    def inner(*args, **kwargs):\n",
    "        print(\"%\" * 30)\n",
    "        func(*args, **kwargs)\n",
    "        print(\"%\" * 30)\n",
    "    return inner\n",
    "\n",
    "\n",
    "@star\n",
    "@percent\n",
    "def printer(msg):\n",
    "    print(msg)\n",
    "\n",
    "\n",
    "printer(\"Hello\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The above syntax of,\n",
    "\n",
    "```python\n",
    ">>> @star\n",
    ">>> @percent\n",
    ">>> def printer(msg):\n",
    ">>>     print(msg)\n",
    "```\n",
    "\n",
    "is equivalent to\n",
    "\n",
    "```python\n",
    ">>> def printer(msg):\n",
    ">>>     print(msg)\n",
    ">>> printer = star(percent(printer))\n",
    "```\n",
    "\n",
    "The order in which we chain decorators matter. If we had reversed the order as,\n",
    "\n",
    "```python\n",
    ">>> @percent\n",
    ">>> @star\n",
    ">>> def printer(msg):\n",
    ">>>     print(msg)\n",
    "```\n",
    "\n",
    "The output would be:\n",
    "\n",
    "```python\n",
    "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
    "******************************\n",
    "Hello\n",
    "******************************\n",
    "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:40:54.311772Z",
     "start_time": "2021-10-18T07:40:54.298104Z"
    }
   },
   "source": [
    "Applying Multiple Decorators to a Single Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:48:46.476012Z",
     "start_time": "2021-10-18T07:48:46.467225Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['WELCOME', 'TO', 'PYTHON']\n"
     ]
    }
   ],
   "source": [
    "'''These decorator functions are higher order functions\n",
    "that take functions as parameters'''\n",
    "\n",
    "# First Decorator\n",
    "def uppercase_decorator(function):\n",
    "    def wrapper():\n",
    "        func = function()\n",
    "        make_uppercase = func.upper()\n",
    "        return make_uppercase\n",
    "    return wrapper\n",
    "\n",
    "# Second decorator\n",
    "def split_string_decorator(function):\n",
    "    def wrapper():\n",
    "        func = function()\n",
    "        splitted_string = func.split()\n",
    "        return splitted_string\n",
    "\n",
    "    return wrapper\n",
    "\n",
    "@split_string_decorator\n",
    "@uppercase_decorator     # order with decorators is important in this case - .upper() function does not work with lists\n",
    "def greeting():\n",
    "    return 'Welcome to Python'\n",
    "print(greeting())   # WELCOME TO PYTHON"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Higher Order Functions\n",
    "\n",
    "Some of the built-in higher order functions that we cover in this part are **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** and **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)**.\n",
    "**[Lambda function](https://github.com/milaan9/04_Python_Functions/blob/main/006_Python_Function_Anonymous.ipynb)** can be passed as a parameter and the best use case of lambda functions is in functions like **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** and **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python - `map` Function\n",
    "\n",
    "The **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** function is a built-in function that takes a function and iterable as parameters.\n",
    "\n",
    "```py\n",
    "    # syntax\n",
    "    map(function, iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:58:12.653217Z",
     "start_time": "2021-10-18T07:58:12.625877Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 9, 16, 25]\n",
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "numbers = [1, 2, 3, 4, 5] # iterable\n",
    "def square(x):\n",
    "    return x ** 2\n",
    "numbers_squared = map(square, numbers)\n",
    "print(list(numbers_squared))    # [1, 4, 9, 16, 25]\n",
    "# Lets apply it with a lambda function\n",
    "numbers_squared = map(lambda x : x ** 2, numbers)\n",
    "print(list(numbers_squared))    # [1, 4, 9, 16, 25]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:58:15.406639Z",
     "start_time": "2021-10-18T07:58:15.393946Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "numbers_str = ['1', '2', '3', '4', '5']  # iterable\n",
    "numbers_int = map(int, numbers_str)\n",
    "print(list(numbers_int))    # [1, 2, 3, 4, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:58:17.009176Z",
     "start_time": "2021-10-18T07:58:16.991604Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['MILAAN', 'ARTHUR', 'BILL', 'CLARK']\n",
      "['MILAAN', 'ARTHUR', 'BILL', 'CLARK']\n"
     ]
    }
   ],
   "source": [
    "# Example 3: \n",
    "\n",
    "names = ['Milaan', 'Arthur', 'Bill', 'Clark']  # iterable\n",
    "\n",
    "def change_to_upper(name):\n",
    "    return name.upper()\n",
    "\n",
    "names_upper_cased = map(change_to_upper, names)\n",
    "print(list(names_upper_cased))    # ['Milaan', 'Arthur', 'Bill', 'Clark']\n",
    "\n",
    "# Let us apply it with a lambda function\n",
    "names_upper_cased = map(lambda name: name.upper(), names)\n",
    "print(list(names_upper_cased))    # ['Milaan', 'Arthur', 'Bill', 'Clark']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What actually map does is iterating over a list. For instance, it changes the names to upper case and returns a new list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python - `filter` Function\n",
    "\n",
    "The **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)** function calls the specified function which returns boolean for each item of the specified iterable (list). It filters the items that satisfy the filtering criteria.\n",
    "\n",
    "```py\n",
    "    # syntax\n",
    "    filter(function, iterable)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:58:20.377344Z",
     "start_time": "2021-10-18T07:58:20.365629Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "# Example 1: \n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]  # iterable\n",
    "\n",
    "def is_even(num):\n",
    "    if num % 2 == 0:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "even_numbers = filter(is_even, numbers)\n",
    "print(list(even_numbers))       # [2, 4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:58:21.963768Z",
     "start_time": "2021-10-18T07:58:21.948147Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "# Example 2: \n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]  # iterable\n",
    "\n",
    "def is_odd(num):\n",
    "    if num % 2 != 0:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "odd_numbers = filter(is_odd, numbers)\n",
    "print(list(odd_numbers))       # [1, 3, 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-10-18T07:58:50.435957Z",
     "start_time": "2021-10-18T07:58:50.416432Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Milaan', 'Arthur']\n"
     ]
    }
   ],
   "source": [
    "# Example 3: Filter long name\n",
    "\n",
    "names = ['Milaan', 'Arthur', 'Bill', 'Clark']  # iterable\n",
    "def is_name_long(name):\n",
    "    if len(name) > 5:\n",
    "        return True\n",
    "    return False\n",
    "\n",
    "long_names = filter(is_name_long, names)\n",
    "print(list(long_names))         # ['Milaan', 'Arthur']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 💻 Exercises ➞ <span class='label label-default'>Higher order functions, Closure and Decorators</span>\n",
    "\n",
    "- countries = ['India', 'Russia', 'China', 'Denmark', 'USA', 'Finland']\n",
    "- names = ['Milaan', 'Arthur', 'Bill', 'Clark']\n",
    "- numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 1</span>\n",
    "\n",
    "1. Explain the difference between **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** and **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)**.\n",
    "2. Explain the difference between higher order function, closure and decorator\n",
    "3. Define a call function before **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** and **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)**. see examples.\n",
    "4. Use for loop to print each country in the countries list.\n",
    "5. Use for to print each name in the names list.\n",
    "6. Use for to print each number in the numbers list.\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 2</span>\n",
    "\n",
    "1. Use **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** to create a new list by changing each country to uppercase in the countries list\n",
    "2. Use **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** to create a new list by changing each number to its square in the numbers list\n",
    "3. Use **[map()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/043_Python_map%28%29.ipynb)** to change each name to uppercase in the names list\n",
    "4. Use **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)** to filter out countries containing 'land'.\n",
    "5. Use **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)** to filter out countries having exactly six characters.\n",
    "6. Use **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)** to filter out countries containing six letters and more in the country list.\n",
    "7. Use **[filter()](https://github.com/milaan9/04_Python_Functions/blob/main/002_Python_Functions_Built_in/020_Python_filter%28%29.ipynb)** to filter out countries starting with an 'C'\n",
    "8. Chain two or more list iterators (eg. **`arr.map(callback).filter(callback)`**)\n",
    "9. Declare a function called **`get_string_lists`** which takes a list as a parameter and then returns a list containing only string items.\n",
    "10. Declare a function called categorize_countries that returns a list of countries with some common pattern (you can find the **[countries data](https://github.com/milaan9/02_Python_Datatypes/blob/main/countries_data.py)** in this repository as countries(eg 'land', 'ia', 'island', 'stan')).\n",
    "11. Create a function returning a dictionary, where keys stand for starting letters of countries and values are the number of country names starting with that letter.\n",
    "12. Declare a **`get_first_ten_countries`** function - it returns a list of first ten countries from the countries.js list in the data folder.\n",
    "15. Declare a **`get_last_ten_countries`** function that returns the last ten countries in the countries list.\n",
    "\n",
    "### Exercises ➞ <span class='label label-default'>Level 3</span>\n",
    "\n",
    "1. Use the **[countries_details_data.py](https://github.com/milaan9/03_Python_Flow_Control/blob/main/countries_details_data.py)** file and follow the tasks below:\n",
    "   - Sort countries by name, by capital, by population\n",
    "   - Sort out the ten most spoken languages by location.\n",
    "   - Sort out the ten most populated countries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.8.8"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}