Day_06_Advanced_Python.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Day_6_Advanced_Python_with_Code_Implementation.ipynb",
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyMN9xE1ueE8l3o4YXjhGlGe"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "## Decorators in Python\n",
        "In Python, a decorator is any callable Python object that is used to modify a function or a class. It takes a function, adds some functionality, and returns it.\n",
        "\n",
        "*   Decorators are very powerful and useful tool in Python since it allows programmers to modify & control the behavior of function or class.\n",
        "*   In Decorators, functions are passed as an argument into another function and then called inside the wrapper function.\n",
        "*   Decorators are usually called before the deficion of a function you want to decorate.\n",
        "*   When using Multiple Decorators to a single function, the decorators will be applied in the order they’ve been called\n",
        "*   By recalling that decorator function, we can re-use the decorator\n"
      ],
      "metadata": {
        "id": "muTuXX5LW5fy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Decorators\n",
        "\n",
        "def test_decorator(func):\n",
        "  def function_wrapper(x):\n",
        "    print(\"Before calling \" + func.__name__)\n",
        "    res = func(x)\n",
        "    print(res)\n",
        "    print(\"After calling \" + func.__name__)\n",
        "  return function_wrapper\n",
        "\n",
        "@test_decorator\n",
        "def sqr(n):\n",
        "  return n**2\n",
        "\n",
        "sqr(20)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jvMyLYBRX1lk",
        "outputId": "54f80b32-deba-4e02-ae5a-2c386bd628d6"
      },
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Before calling sqr\n",
            "400\n",
            "After calling sqr\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiple Decorators\n",
        "def lowercase_decorator(function):\n",
        "  def wrapper():\n",
        "    func= function()\n",
        "    make_lowercase = func.lower()\n",
        "    return make_lowercase\n",
        "  return wrapper\n",
        "\n",
        "def split_string(function):\n",
        "  def wrapper():\n",
        "    func= function()\n",
        "    split_string =func.split()\n",
        "    return split_string\n",
        "  return wrapper\n",
        "\n",
        "@split_string\n",
        "@lowercase_decorator\n",
        "def test_func():\n",
        "  return 'MOTHER OF DRAGONS'\n",
        "\n",
        "test_func()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ud2AU52FYRVZ",
        "outputId": "44b391af-6448-4fdf-b791-17d0bb31f8dc"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['mother', 'of', 'dragons']"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Memorization using Decorators\n",
        "In Python, memoization is a technique which allows you to optimize a Python function by caching its output based on the parameters you supply to it.\n",
        "\n",
        "*   Once you memoize a function, it will only compute its output once for each set of parameters you call it with. Every call after the first will be quickly retrieved from a cache.\n",
        "*   If you want to speed up the parts in your program that are expensive, memoization can be a great technique to use.\n",
        "\n"
      ],
      "metadata": {
        "id": "f4PtkpuoW47T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# fibonacci series using Memoization using decorators\n",
        "def memoization_func(t):\n",
        "  dict_one = {}\n",
        "  def h(z):\n",
        "    if z not in dict_one:            \n",
        "      dict_one[z] = t(z)\n",
        "    return dict_one[z]\n",
        "  return h\n",
        "    \n",
        "@memoization_func\n",
        "def fib(n):\n",
        "  if n == 0:\n",
        "    return 0\n",
        "  elif n == 1:\n",
        "    return 1\n",
        "  else:\n",
        "    return fib(n-1) + fib(n-2)\n",
        "\n",
        "print(fib(20))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XenfEyOjZN95",
        "outputId": "dc888e66-02b7-4179-e231-b5f0aa7adb16"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "6765\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## DefaultDict\n",
        "In python, a dictionary is a container that holds key-value pairs. Keys must be unique, immutable objects\n",
        "\n",
        "*   If you try to access or modify keys that don’t exist in the dictionary, it raise a KeyError and break up your code execution. To tackle this issue, Python defaultdict type, a dictionary-like class is used\n",
        "*   If you try to access or modify a missing key, then defaultdict will automatically create the key and generate a default value for it\n",
        "*   A defaultdict will never raise a KeyError\n",
        "*   Any key that does not exist gets the value returned by the default factory\n",
        "*   Hence, whenever you need a dictionary, and each element’s value should start with a default value, use a defaultdict\n"
      ],
      "metadata": {
        "id": "PCc3JxCUW44y"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import defaultdict \n",
        "     \n",
        "default_dict_var = defaultdict(list) \n",
        "  \n",
        "for i in range(10): \n",
        "  default_dict_var[i].append(i) \n",
        "  \n",
        "print(default_dict_var)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0LrvFPeUaJWj",
        "outputId": "01f71348-0b52-43e4-b016-c8d6496fa9e7"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "defaultdict(<class 'list'>, {0: [0], 1: [1], 2: [2], 3: [3], 4: [4], 5: [5], 6: [6], 7: [7], 8: [8], 9: [9]})\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## OrderedDict\n",
        "In python, OrderedDict is one of the high performance container datatypes and a subclass of dict object. It maintains the order in which the keys are inserted. In case of deletion or re-insertion of the key, the order is maintained and used when creating an iterator\n",
        "\n",
        "*   It’s a dictionary subclass that remembers the order in which its contents are added\n",
        "*   When the value of a specified key is changed, the ordering of keys will not change for the OrderedDict\n",
        "*   If an item is overwritten in the OrderedDict, it’s position is maintained\n",
        "*   OrderedDict popitem removes the items in FIFO order\n",
        "*   The reversed() function can be used with OrderedDict to iterate elements in the reverse order\n",
        "*   OrderedDict has a move_to_end() method to efficiently reposition an element to an endpoint\n"
      ],
      "metadata": {
        "id": "kVTNlijSW42c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from collections import OrderedDict\n",
        "\n",
        "my_dict = {'Sunday': 0, 'Monday': 1, 'Tuesday': 2}\n",
        "\n",
        "# creating ordered dict\n",
        "ordered_dict = OrderedDict(my_dict)\n",
        "print(ordered_dict)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4OajsVAbCsa",
        "outputId": "f1d67ec9-a7e6-4e0b-a5a4-48401e8bc591"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "OrderedDict([('Sunday', 0), ('Monday', 1), ('Tuesday', 2)])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Generators in Python\n",
        "In Python, Generator functions act just like regular functions with just one difference that they use the Python `yield` keyword instead of `return` . A generator function is a function that returns an iterator A generator expression is an expression that also returns an iterator\n",
        "\n",
        "*   Generator objects are used either by calling the next method on the generator object or using the generator object in a “for in” loop.\n",
        "*   A return statement terminates a function entirely but a yield statement pauses the function saving all its states and later continues from there on successive calls.\n",
        "*   Generator expressions can be used as the function arguments. Just like list comprehensions, generator expressions allow you to quickly create a generator object within minutes with just a few lines of code.\n",
        "*   The major difference between a list comprehension and a generator expression is that a list comprehension produces the entire list while the generator expression produces one item at a time as lazy evaluation. For this reason, compared to a list comprehension, a generator expression is much more memory efficient\n"
      ],
      "metadata": {
        "id": "Crk9BVhsW4zy"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "THbcMtcTWs3b",
        "outputId": "57f3709c-2dfa-4a00-ad0a-198f9881a8fe"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0,1,2,3,4,5,6,7,8,9,"
          ]
        }
      ],
      "source": [
        "def test_sequence():\n",
        "  num = 0\n",
        "  while num<10:\n",
        "    yield num\n",
        "    num += 1\n",
        "\n",
        "for i in test_sequence():\n",
        "  print(i, end=\",\")"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Python generator with Loop\n",
        "# Reverse a string\n",
        "def reverse_str(test_str):\n",
        "  length = len(test_str)\n",
        "  for i in range(length - 1, -1, -1):\n",
        "    yield test_str[i]\n",
        "\n",
        "for char in reverse_str(\"Trojan\"):\n",
        "  print(char,end =\" \")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8CqighwhcY_t",
        "outputId": "0b87c196-24d3-4db3-df08-87e993da8059"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "n a j o r T "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Generator Expression\n",
        "# Initialize the list\n",
        "test_list = [1, 3, 6, 10]\n",
        "\n",
        "# list comprehension\n",
        "list_comprehension = [x**3 for x in test_list]\n",
        "\n",
        "# generator expression\n",
        "test_generator = (x**3 for x in test_list)\n",
        "\n",
        "print(list_comprehension)\n",
        "print(type(test_generator))\n",
        "print(tuple(test_generator))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9GbOx_ovckcz",
        "outputId": "2ea7424c-b4da-4d91-c6da-4bd163064254"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 27, 216, 1000]\n",
            "<class 'generator'>\n",
            "(1, 27, 216, 1000)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Coroutine in Python\n",
        "\n",
        "*   Coroutines are computer program components that generalize subroutines for non-preemptive multitasking, by allowing execution to be suspended and resumed\n",
        "*   Because coroutines can pause and resume execution context, they’re well suited to concurrent processing\n",
        "*   Coroutines are a special type of function that yield control over to the caller, but does not end its context in the process, instead maintaining it in an idle state\n",
        "*   Using coroutines the yield directive can also be used on the right-hand side of an `=` operator to signify it will accept a value at that point in time.\n"
      ],
      "metadata": {
        "id": "8RuZM23fcuSD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def func(): \n",
        "  print(\"My first Coroutine\") \n",
        "  while True: \n",
        "    var = (yield) \n",
        "    print(var) \n",
        "\n",
        "coroutine = func() \n",
        "next(coroutine)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VrIjtz5WdFvZ",
        "outputId": "ce499f3f-cb28-4e1c-b518-7e8e876b50ec"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "My first Coroutine\n"
          ]
        }
      ]
    }
  ]
}