YogeshMedz/LetsUpgrade.in (Day 07 - Assignment 07).ipynb

## LetsUpgrade.in (Day 07 - Assignment 07).ipynb
{
    "cells": [
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "   ## Assignment 07 - Day 07 - PYTHON (LetsUpgrade.in)\n   - Yogesh Raghupati (yogeshraghupati13396@gmail.com)"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## |--------------------------------------------------------TWO ----------------------------------------------------------------|"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## Q2.\n<p> Write a Python program to add the digits of a positive integer repeatedly until the result has a\nsingle digit.</p>\n<p><b>Input Format:</b></p>\nThe first line of the input contains a number n.\n<p><b>Output:</b></p>\nPrint the resultant number\n<p><b>Example:</b></p>\n<p><b>Input:</b></p>\n48\n<p><b>Output:</b></p>\n3\n<p>Explanation: If you add digits 4 and 8, you will get 12. Again adding 1 and 2 will give 3\nwhich is a single digit and hence the answer.</p>"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "x = int(input(\"Enter your Number: \"))\na= (x - 1) % 9 + 1\nprint(a)",
            "execution_count": 1,
            "outputs": [
                {
                    "output_type": "stream",
                    "name": "stdout",
                    "text": "Enter your Number: 98\n8\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## |--------------------------------------------------------ONE ----------------------------------------------------------------|"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## <b>Map(), Filter() and Reduce() are built-in functions of Python.</b>\n<p>These functions enable the functional program aspect of python.</p>\n<p> In Functional Programming, the arguments passed are the only factors that decide upon the output.</p>\n<p>These functions can take any other function as a parameter and can be supplied to other functions as parameters as well.</p>\n"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "from IPython.display import YouTubeVideo\n\ndef display_yotube_video(url, **kwargs):\n    \"\"\"\n    Displays a Youtube video in a Jupyter notebook.\n    \n    Args:\n        url (string): a link to a Youtube video.\n        **kwargs: further arguments for IPython.display.YouTubeVideo\n    \n    Returns:\n        YouTubeVideo: a video that is displayed in your notebook.\n    \"\"\"\n    id_ = url.split(\"=\")[-1]\n    return YouTubeVideo(id_, **kwargs)\n\ndisplay_yotube_video(\"https://www.youtube.com/watch?v=hUes6y2b--0\", width=800, height=600)",
            "execution_count": 3,
            "outputs": [
                {
                    "output_type": "execute_result",
                    "execution_count": 3,
                    "data": {
                        "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7fbce84c3ac8>",
                        "text/html": "\n        <iframe\n            width=\"800\"\n            height=\"600\"\n            src=\"https://www.youtube.com/embed/hUes6y2b--0\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                        "image/jpeg": "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\n"
                    },
                    "metadata": {}
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## 1. Map()"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<p>It applies the given function to all iterables and returns a new list.<p>\n    <b>SYNTAX:</b>\n<p>Map(function,iterables)<p>"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# without using map()\ndef sqr(a):\n    return a*a\nx= sqr(9.83)\nprint(x)",
            "execution_count": 73,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "96.6289\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# using map (funtion,iterables) - List\ndef sqr(a):\n    return a*a\n#type your code here\nx=map(sqr,[1,3,8,9,10])\nprint(x)\nprint(list(x))",
            "execution_count": 74,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05CFBD48>\n[1, 9, 64, 81, 100]\n"
                }
            ]
        },
        {
            "metadata": {
                "scrolled": true
            },
            "cell_type": "code",
            "source": "# using map (funtion,iterables) - SET\ndef sqr(a):\n    return a*a\n#type your code here\nx=map(sqr,[1,3,8,9,10])\nprint(x)\nprint(set(x))",
            "execution_count": 75,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05CFBB20>\n{64, 1, 100, 9, 81}\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# map(function,iterables) - List\ndef sqr(a,b):\n    return a/b\n#type your code here\nx= map(sqr,[1,2,3,4],[2,5,6,8,9])\nprint(x)\nprint(type(x))\nprint(list(x))\nprint(tuple(x))\nprint(set(x))",
            "execution_count": 76,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x01068058>\n<class 'map'>\n[0.5, 0.4, 0.5, 0.5]\n()\nset()\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# map(function,iterables) - Tuple\ndef sqr(a,b):\n    return a/b\n#type your code here\nx= map(sqr,[1,2,3,4],[2,5,6,8,9])\nprint(x)\nprint(type(x))\nprint(tuple(x))",
            "execution_count": 77,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05CFBE98>\n<class 'map'>\n(0.5, 0.4, 0.5, 0.5)\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# map(function,iterables) - Set\ndef sqr(a,b):\n    return a/b\n#type your code here\nx= map(sqr,[1,2,3,4],[2,5,6,8])\nprint(x)\nprint(type(x))\nprint(set(x))",
            "execution_count": 78,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05CFB8F8>\n<class 'map'>\n{0.5, 0.4}\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# map(function,iterables) \ndef sqr(a,b):\n    return a-b\n#type your code here\nprint(list(map(sqr,[1,2,3,4],[2,2,3,4])))\n#print(x)\n#print(list(x))",
            "execution_count": 79,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "[-1, 0, 0, 0]\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## 2. Lambda Functions"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "from IPython.display import YouTubeVideo\n\ndef display_yotube_video(url, **kwargs):\n    \"\"\"\n    Displays a Youtube video in a Jupyter notebook.\n    \n    Args:\n        url (string): a link to a Youtube video.\n        **kwargs: further arguments for IPython.display.YouTubeVideo\n    \n    Returns:\n        YouTubeVideo: a video that is displayed in your notebook.\n    \"\"\"\n    id_ = url.split(\"=\")[-1]\n    return YouTubeVideo(id_, **kwargs)\n\ndisplay_yotube_video(\"https://www.youtube.com/watch?v=25ovCm9jKfA\", width=800, height=600)",
            "execution_count": 2,
            "outputs": [
                {
                    "output_type": "execute_result",
                    "execution_count": 2,
                    "data": {
                        "text/plain": "<IPython.lib.display.YouTubeVideo at 0x7fbce84c3748>",
                        "text/html": "\n        <iframe\n            width=\"800\"\n            height=\"600\"\n            src=\"https://www.youtube.com/embed/25ovCm9jKfA\"\n            frameborder=\"0\"\n            allowfullscreen\n        ></iframe>\n        ",
                        "image/jpeg": "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\n"
                    },
                    "metadata": {}
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<p>Everything in the world of programming requires a name, but there are few anonymous mysteris. Lambda functions or Lambda expressions are one of these kind of entities that are nameless.</p>\n\n<p>\u2022 They are the functions that do not have any name.</p>\n<p>\u2022 We also call them as anonymous or nameless functions.</p>\n<p>\u2022 They are generally provided as input to other functions.</p>\n<p>Lambda functions are single line functions. Therefore, we have to provide the expression along with the function itself.</p>\n\n### Note: 'Lambda' is not a name, it is a KEYWORD.\n"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "### Use of Lambda Functions:\n<p>1. One time use: They are used in places where we know that the function will be required just once. Therefore, lambda functions are also called as throw away functions</p>\n<p>2. Input/Output to other functions: They also passed as inputs or returned as outputs of other higher-order functions.</p>\n<p>Reduce Code Size: The body of lamda functions is written in a single line.</p>"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# without lambda\ndef sqr(a):\n    return a*a\nsqr(9)",
            "execution_count": 7,
            "outputs": [
                {
                    "data": {
                        "text/plain": "81"
                    },
                    "execution_count": 7,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# with lambda\n#type your code here\nx= lambda a: a*a\nx(187)",
            "execution_count": 10,
            "outputs": [
                {
                    "data": {
                        "text/plain": "34969"
                    },
                    "execution_count": 10,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# lambda within user defined functions\ndef abc(x):\n    return lambda y: x+y\nt=abc(4)\nprint(t)\nprint(t(5))",
            "execution_count": 12,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<function abc.<locals>.<lambda> at 0x00962850>\n9\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Solving Algebaric ecpressions using lambda \n# Linear Equations\n# Snippet 2: 7x+2y\nz = lambda x,y: 8*x+5*y\nz(8,5)",
            "execution_count": 6,
            "outputs": [
                {
                    "data": {
                        "text/plain": "89"
                    },
                    "execution_count": 6,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Solving Algebaric ecpressions using lambda \n# Linear Equations\n# Snippet 2: 7x+2y\nz = lambda x,y: (x+y)**3\nz(8,5)",
            "execution_count": 7,
            "outputs": [
                {
                    "data": {
                        "text/plain": "2197"
                    },
                    "execution_count": 7,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Use lambda functions along with map function - Type 1\nl = [1,2,3,4]\n# code\nz = map(lambda x: x+3,l)\nlist(z)",
            "execution_count": 10,
            "outputs": [
                {
                    "data": {
                        "text/plain": "[4, 5, 6, 7]"
                    },
                    "execution_count": 10,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Use lambda functions along with map function - Type 2\nl = [1,2,3,4]\n# code\nlist(map(lambda x: x+3,l))",
            "execution_count": 11,
            "outputs": [
                {
                    "data": {
                        "text/plain": "[4, 5, 6, 7]"
                    },
                    "execution_count": 11,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Use lambda functions along with map function - Type 3\nl = [1,2,3,4]\n# code\nx = list(map(lambda x: x+3,l))\nprint(x)",
            "execution_count": 12,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "[4, 5, 6, 7]\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## # FILTER()\n<p>It is used to filter the given iterables with the help of another function passed as an argument to test all the elements to be TRUE or FALSE.</p>\n<p>SYNTAX</p>\n<p>Filter(function,iterables)"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# filter(function, iterables)\ndef sqr(a):\n    if a>=6:\n        return a\n#Code\nx = filter(sqr,[5,6,7,8])\nprint(x)\nprint(type(x))\nprint(list(x))",
            "execution_count": 18,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<filter object at 0x05B276D0>\n<class 'filter'>\n[6, 7, 8]\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "l = [8,9,5,6,8]\n#code\ns = filter(lambda x: x>5,l)\nprint(list(s))",
            "execution_count": 22,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "[8, 9, 6, 8]\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "l=[8,9,6,7,5,9]\nlist(filter(lambda x: x>7,l))",
            "execution_count": 26,
            "outputs": [
                {
                    "data": {
                        "text/plain": "[8, 9, 9]"
                    },
                    "execution_count": 26,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## #REDUCE()\nIt applies some other function to a list that are passed as a parameter to it and finally return a single value.\n<p> SYNTAX: </p>\n<p> reduce(function, iterables)"
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# reduce(function,iterables)\n#code\nfrom functools import reduce # As it's required in the program\ndef sqr(a,b):\n    return a-b\n#code\nx = reduce(sqr,[1,8,5,6])\nprint(x)",
            "execution_count": 31,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "-18\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# Using Lambda funtion\n#code\nreduce(lambda a,b: a+b,[1,5,8,6])",
            "execution_count": 32,
            "outputs": [
                {
                    "data": {
                        "text/plain": "20"
                    },
                    "execution_count": 32,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# filter within map\nx = map(lambda x:x+x, filter(lambda x:x>3,[1,5,8,9,9]))\nprint(x)\nprint(list(x))",
            "execution_count": 43,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05B27EB0>\n[10, 16, 18, 18]\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "x = map(lambda x:x+x, filter(lambda x:x>3,[1,5,8,9,9]))\nprint(x)\nprint(set(x))",
            "execution_count": 50,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05B27D60>\n{16, 10, 18}\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "x = map(lambda x:x+x, filter(lambda x:x>3,[1,5,8,9,9]))\nprint(x)\nprint(tuple(x))",
            "execution_count": 51,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<map object at 0x05B27B68>\n(10, 16, 18, 18)\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# map within filter \nx= filter(lambda x: x>6, map(lambda x: x+4,[4,5,6,7]))\n#code\nprint(x)\nlist(x)",
            "execution_count": 52,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "<filter object at 0x05B27EC8>\n"
                },
                {
                    "data": {
                        "text/plain": "[8, 9, 10, 11]"
                    },
                    "execution_count": 52,
                    "metadata": {},
                    "output_type": "execute_result"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "code",
            "source": "# map and filter within reduce\nz = reduce(lambda x,y: x+y, map(lambda x:x+x, filter(lambda x: x>=3, (1,5,6,7))))\nprint(z)",
            "execution_count": 53,
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": "36\n"
                }
            ]
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "## |--------------------------------------------------------ONE ----------------------------------------------------------------|"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<img src=\"https://images.pexels.com/photos/4133288/pexels-photo-4133288.png?auto=compress&cs=tinysrgb&dpr=2&h=650&w=940\">"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "# \" You can copy all you want but you will always be one step behind. \"\n### <p> |-----------------------LEARN------------------UNDERSTAND------------------------INNOVATE-------------------|</p>"
        },
        {
            "metadata": {},
            "cell_type": "markdown",
            "source": "<blockquote class=\"instagram-media\" data-instgrm-captioned data-instgrm-permalink=\"https://www.instagram.com/p/B-GzoihloBH/?utm_source=ig_embed&amp;utm_campaign=loading\" data-instgrm-version=\"12\" style=\" background:#FFF; border:0; border-radius:3px; box-shadow:0 0 1px 0 rgba(0,0,0,0.5),0 1px 10px 0 rgba(0,0,0,0.15); margin: 1px; max-width:540px; min-width:326px; padding:0; width:99.375%; width:-webkit-calc(100% - 2px); width:calc(100% - 2px);\"><div style=\"padding:16px;\"> <a href=\"https://www.instagram.com/p/B-GzoihloBH/?utm_source=ig_embed&amp;utm_campaign=loading\" style=\" background:#FFFFFF; line-height:0; padding:0 0; text-align:center; text-decoration:none; width:100%;\" target=\"_blank\"> <div style=\" display: flex; flex-direction: row; align-items: center;\"> <div style=\"background-color: #F4F4F4; border-radius: 50%; flex-grow: 0; height: 40px; margin-right: 14px; width: 40px;\"></div> <div style=\"display: flex; flex-direction: column; flex-grow: 1; justify-content: center;\"> <div style=\" background-color: #F4F4F4; border-radius: 4px; flex-grow: 0; height: 14px; margin-bottom: 6px; width: 100px;\"></div> <div style=\" background-color: #F4F4F4; border-radius: 4px; flex-grow: 0; height: 14px; width: 60px;\"></div></div></div><div style=\"padding: 19% 0;\"></div> <div style=\"display:block; height:50px; margin:0 auto 12px; width:50px;\"><svg width=\"50px\" height=\"50px\" viewBox=\"0 0 60 60\" version=\"1.1\" xmlns=\"https://www.w3.org/2000/svg\" xmlns:xlink=\"https://www.w3.org/1999/xlink\"><g stroke=\"none\" stroke-width=\"1\" fill=\"none\" fill-rule=\"evenodd\"><g transform=\"translate(-511.000000, -20.000000)\" fill=\"#000000\"><g><path d=\"M556.869,30.41 C554.814,30.41 553.148,32.076 553.148,34.131 C553.148,36.186 554.814,37.852 556.869,37.852 C558.924,37.852 560.59,36.186 560.59,34.131 C560.59,32.076 558.924,30.41 556.869,30.41 M541,60.657 C535.114,60.657 530.342,55.887 530.342,50 C530.342,44.114 535.114,39.342 541,39.342 C546.887,39.342 551.658,44.114 551.658,50 C551.658,55.887 546.887,60.657 541,60.657 M541,33.886 C532.1,33.886 524.886,41.1 524.886,50 C524.886,58.899 532.1,66.113 541,66.113 C549.9,66.113 557.115,58.899 557.115,50 C557.115,41.1 549.9,33.886 541,33.886 M565.378,62.101 C565.244,65.022 564.756,66.606 564.346,67.663 C563.803,69.06 563.154,70.057 562.106,71.106 C561.058,72.155 560.06,72.803 558.662,73.347 C557.607,73.757 556.021,74.244 553.102,74.378 C549.944,74.521 548.997,74.552 541,74.552 C533.003,74.552 532.056,74.521 528.898,74.378 C525.979,74.244 524.393,73.757 523.338,73.347 C521.94,72.803 520.942,72.155 519.894,71.106 C518.846,70.057 518.197,69.06 517.654,67.663 C517.244,66.606 516.755,65.022 516.623,62.101 C516.479,58.943 516.448,57.996 516.448,50 C516.448,42.003 516.479,41.056 516.623,37.899 C516.755,34.978 517.244,33.391 517.654,32.338 C518.197,30.938 518.846,29.942 519.894,28.894 C520.942,27.846 521.94,27.196 523.338,26.654 C524.393,26.244 525.979,25.756 528.898,25.623 C532.057,25.479 533.004,25.448 541,25.448 C548.997,25.448 549.943,25.479 553.102,25.623 C556.021,25.756 557.607,26.244 558.662,26.654 C560.06,27.196 561.058,27.846 562.106,28.894 C563.154,29.942 563.803,30.938 564.346,32.338 C564.756,33.391 565.244,34.978 565.378,37.899 C565.522,41.056 565.552,42.003 565.552,50 C565.552,57.996 565.522,58.943 565.378,62.101 M570.82,37.631 C570.674,34.438 570.167,32.258 569.425,30.349 C568.659,28.377 567.633,26.702 565.965,25.035 C564.297,23.368 562.623,22.342 560.652,21.575 C558.743,20.834 556.562,20.326 553.369,20.18 C550.169,20.033 549.148,20 541,20 C532.853,20 531.831,20.033 528.631,20.18 C525.438,20.326 523.257,20.834 521.349,21.575 C519.376,22.342 517.703,23.368 516.035,25.035 C514.368,26.702 513.342,28.377 512.574,30.349 C511.834,32.258 511.326,34.438 511.181,37.631 C511.035,40.831 511,41.851 511,50 C511,58.147 511.035,59.17 511.181,62.369 C511.326,65.562 511.834,67.743 512.574,69.651 C513.342,71.625 514.368,73.296 516.035,74.965 C517.703,76.634 519.376,77.658 521.349,78.425 C523.257,79.167 525.438,79.673 528.631,79.82 C531.831,79.965 532.853,80.001 541,80.001 C549.148,80.001 550.169,79.965 553.369,79.82 C556.562,79.673 558.743,79.167 560.652,78.425 C562.623,77.658 564.297,76.634 565.965,74.965 C567.633,73.296 568.659,71.625 569.425,69.651 C570.167,67.743 570.674,65.562 570.82,62.369 C570.966,59.17 571,58.147 571,50 C571,41.851 570.966,40.831 570.82,37.631\"></path></g></g></g></svg></div><div style=\"padding-top: 8px;\"> <div style=\" color:#3897f0; font-family:Arial,sans-serif; font-size:14px; font-style:normal; font-weight:550; line-height:18px;\"> View this post on Instagram</div></div><div style=\"padding: 12.5% 0;\"></div> <div style=\"display: flex; flex-direction: row; margin-bottom: 14px; align-items: center;\"><div> <div style=\"background-color: #F4F4F4; border-radius: 50%; height: 12.5px; width: 12.5px; transform: translateX(0px) translateY(7px);\"></div> <div style=\"background-color: #F4F4F4; height: 12.5px; transform: rotate(-45deg) translateX(3px) translateY(1px); width: 12.5px; flex-grow: 0; margin-right: 14px; margin-left: 2px;\"></div> <div style=\"background-color: #F4F4F4; border-radius: 50%; height: 12.5px; width: 12.5px; transform: translateX(9px) translateY(-18px);\"></div></div><div style=\"margin-left: 8px;\"> <div style=\" background-color: #F4F4F4; border-radius: 50%; flex-grow: 0; height: 20px; width: 20px;\"></div> <div style=\" width: 0; height: 0; border-top: 2px solid transparent; border-left: 6px solid #f4f4f4; border-bottom: 2px solid transparent; transform: translateX(16px) translateY(-4px) rotate(30deg)\"></div></div><div style=\"margin-left: auto;\"> <div style=\" width: 0px; border-top: 8px solid #F4F4F4; border-right: 8px solid transparent; transform: translateY(16px);\"></div> <div style=\" background-color: #F4F4F4; flex-grow: 0; height: 12px; width: 16px; transform: translateY(-4px);\"></div> <div style=\" width: 0; height: 0; border-top: 8px solid #F4F4F4; border-left: 8px solid transparent; transform: translateY(-4px) translateX(8px);\"></div></div></div></a> <p style=\" margin:8px 0 0 0; padding:0 4px;\"> <a href=\"https://www.instagram.com/p/B-GzoihloBH/?utm_source=ig_embed&amp;utm_campaign=loading\" style=\" color:#000; font-family:Arial,sans-serif; font-size:14px; font-style:normal; font-weight:normal; line-height:17px; text-decoration:none; word-wrap:break-word;\" target=\"_blank\">@pillaicollege \u2764</a></p> <p style=\" color:#c9c8cd; font-family:Arial,sans-serif; font-size:14px; line-height:17px; margin-bottom:0; margin-top:8px; overflow:hidden; padding:8px 0 7px; text-align:center; text-overflow:ellipsis; white-space:nowrap;\">A post shared by <a href=\"https://www.instagram.com/yogesh_ahdem/?utm_source=ig_embed&amp;utm_campaign=loading\" style=\" color:#c9c8cd; font-family:Arial,sans-serif; font-size:14px; font-style:normal; font-weight:normal; line-height:17px;\" target=\"_blank\"> Yogesh M Raghupati</a> (@yogesh_ahdem) on <time style=\" font-family:Arial,sans-serif; font-size:14px; line-height:17px;\" datetime=\"2020-03-24T06:29:18+00:00\">Mar 23, 2020 at 11:29pm PDT</time></p></div></blockquote> <script async src=\"//www.instagram.com/embed.js\"></script>"
        }
    ],
    "metadata": {
        "kernelspec": {
            "name": "python3",
            "display_name": "Python 3.6",
            "language": "python"
        },
        "language_info": {
            "name": "python",
            "version": "3.6.9",
            "mimetype": "text/x-python",
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "pygments_lexer": "ipython3",
            "nbconvert_exporter": "python",
            "file_extension": ".py"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}