Week_01__Introduction(F_21)_Thursday.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Week_01:_Introduction(F-21)-Thursday.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7SjRpRssC2e-"
      },
      "source": [
        "# Introduction to Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B3-JWyWzCwrm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e00d5d5e-3fbb-491d-baef-688634858cab"
      },
      "source": [
        "print('Hello, world!')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello, world!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TI2v4cRlDXaK"
      },
      "source": [
        "## Just for fun!\n",
        "\n",
        "Did you know that entering `import this` prints the 'Zen of Python'?\n",
        "\n",
        "The Zen of Python is a collection of 19 \"guiding principles\" for writing computer programs that influence the design of the Python programming language.\n",
        "\n",
        "It is always good to follow the zen even when you have an opportunity to show off your Python skills! :)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wx9lQCM0DfmX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d6e36cc9-db0f-457e-8928-9d6cb748b3a1"
      },
      "source": [
        "import this"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The Zen of Python, by Tim Peters\n",
            "\n",
            "Beautiful is better than ugly.\n",
            "Explicit is better than implicit.\n",
            "Simple is better than complex.\n",
            "Complex is better than complicated.\n",
            "Flat is better than nested.\n",
            "Sparse is better than dense.\n",
            "Readability counts.\n",
            "Special cases aren't special enough to break the rules.\n",
            "Although practicality beats purity.\n",
            "Errors should never pass silently.\n",
            "Unless explicitly silenced.\n",
            "In the face of ambiguity, refuse the temptation to guess.\n",
            "There should be one-- and preferably only one --obvious way to do it.\n",
            "Although that way may not be obvious at first unless you're Dutch.\n",
            "Now is better than never.\n",
            "Although never is often better than *right* now.\n",
            "If the implementation is hard to explain, it's a bad idea.\n",
            "If the implementation is easy to explain, it may be a good idea.\n",
            "Namespaces are one honking great idea -- let's do more of those!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPcJ_rESHwum"
      },
      "source": [
        "## The `help()` function\n",
        "\n",
        "The `help()` function in python is used to display the documentation of modules, functions, classes, etc.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "44SQH6V9DgVV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d2e2eb1a-8024-4581-a064-317836a2c567"
      },
      "source": [
        "# help([object])\n",
        "\n",
        "help(print)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on built-in function print in module builtins:\n",
            "\n",
            "print(...)\n",
            "    print(value, ..., sep=' ', end='\\n', file=sys.stdout, flush=False)\n",
            "    \n",
            "    Prints the values to a stream, or to sys.stdout by default.\n",
            "    Optional keyword arguments:\n",
            "    file:  a file-like object (stream); defaults to the current sys.stdout.\n",
            "    sep:   string inserted between values, default a space.\n",
            "    end:   string appended after the last value, default a newline.\n",
            "    flush: whether to forcibly flush the stream.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AypvTz1OJgEv"
      },
      "source": [
        "**NOTE:** If the `help()` function is passed without an argument,then the interactive help utility starts up on the console."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U2Gx61gZJ5oj"
      },
      "source": [
        "## Accessing the Attributes (/Methods) of any object\n",
        "\n",
        "In order to understand the pre-loaded attributes of an object, we use the `dir()` function."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HVLY2TTyJuYy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e56e38b7-cd7b-48eb-870d-1b5cb4fd260c"
      },
      "source": [
        "# import [library]\n",
        "# dir([library])\n",
        "\n",
        "import math\n",
        "dir(math)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['__doc__',\n",
              " '__loader__',\n",
              " '__name__',\n",
              " '__package__',\n",
              " '__spec__',\n",
              " 'acos',\n",
              " 'acosh',\n",
              " 'asin',\n",
              " 'asinh',\n",
              " 'atan',\n",
              " 'atan2',\n",
              " 'atanh',\n",
              " 'ceil',\n",
              " 'copysign',\n",
              " 'cos',\n",
              " 'cosh',\n",
              " 'degrees',\n",
              " 'e',\n",
              " 'erf',\n",
              " 'erfc',\n",
              " 'exp',\n",
              " 'expm1',\n",
              " 'fabs',\n",
              " 'factorial',\n",
              " 'floor',\n",
              " 'fmod',\n",
              " 'frexp',\n",
              " 'fsum',\n",
              " 'gamma',\n",
              " 'gcd',\n",
              " 'hypot',\n",
              " 'inf',\n",
              " 'isclose',\n",
              " 'isfinite',\n",
              " 'isinf',\n",
              " 'isnan',\n",
              " 'ldexp',\n",
              " 'lgamma',\n",
              " 'log',\n",
              " 'log10',\n",
              " 'log1p',\n",
              " 'log2',\n",
              " 'modf',\n",
              " 'nan',\n",
              " 'pi',\n",
              " 'pow',\n",
              " 'radians',\n",
              " 'remainder',\n",
              " 'sin',\n",
              " 'sinh',\n",
              " 'sqrt',\n",
              " 'tan',\n",
              " 'tanh',\n",
              " 'tau',\n",
              " 'trunc']"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RKJPIBVeQ-Rr"
      },
      "source": [
        "## Understanding data types in Python\n",
        "\n",
        "Python has the following data types built-in by default:\n",
        "\n",
        "Text: `str`\n",
        "\n",
        "Numeric: `int`, `float`, `complex`\n",
        "\n",
        "Sequence: `list`, `tuple`, `range`\n",
        "\n",
        "Mapping: `dict`\n",
        "\n",
        "Set: `set`, `frozenset`\n",
        "\n",
        "Boolean: `bool`\n",
        "\n",
        "Binary: `bytes`, `bytearray`, `memoryview`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jWGwNMZ3SfpC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fd0e74cf-972c-48ee-da32-adc3171e08c1"
      },
      "source": [
        "# type(variable) prints the data type of the variable. In this case, string\n",
        "\n",
        "name = 'Stephen ' + 'Colbert'\n",
        "print(name)\n",
        "\n",
        "print(type(name))\n",
        "type(name)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Stephen Colbert\n",
            "<class 'str'>\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "str"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c9H2KIZrTP8x"
      },
      "source": [
        "**NOTE:** The initialization of datat type to a particular variable happens automaticaly when we assign a value to a variable."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zd7DOnqVSyNv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f0d9001b-214e-441e-e9c1-089ade046f82"
      },
      "source": [
        "# class integer\n",
        "\n",
        "x = 10\n",
        "print(x)\n",
        "\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "li1jP3axTX-l",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2c8a58b8-03f0-4949-96eb-bf1812bcdaa6"
      },
      "source": [
        "# class float\n",
        "\n",
        "decimal = 0.63000\n",
        "print(decimal)\n",
        "\n",
        "print(type(decimal))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.63\n",
            "<class 'float'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IUflSg0FTjcG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "41b57b6d-2e35-4f01-ad92-a5d995fd4cff"
      },
      "source": [
        "# class list\n",
        "\n",
        "groceries = ['apples', '20', 'cake mix', 'tp']\n",
        "print(groceries)\n",
        "\n",
        "print(type(groceries))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['apples', '20', 'cake mix', 'tp']\n",
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZqWeUPXVT2J4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2d326837-9615-46a6-ad85-75b53c900f9f"
      },
      "source": [
        "# class list, but tuples\n",
        "\n",
        "a = [(1, 2), (3, 4, 5), (6, 7)]\n",
        "print(a)\n",
        "\n",
        "print(type(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(1, 2), (3, 4, 5), (6, 7)]\n",
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4jvnDjzrjJt0",
        "outputId": "05aa4570-9c0b-4fa9-d3ab-85075551d682"
      },
      "source": [
        "x = ('Apple', 'Tim', 'Burns')\n",
        "\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JqynSwC0ULb_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8aa4138-a0fa-4ee2-a0eb-3710095707d5"
      },
      "source": [
        "# class set\n",
        "\n",
        "sets = set((10, 2, 3, 6876))\n",
        "\n",
        "print(sets)\n",
        "print(type(sets))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{3, 10, 2, 6876}\n",
            "<class 'set'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tzzxfQLIUTc5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3a179f69-2c15-4c1a-9ec3-998320c85751"
      },
      "source": [
        "# class dictionary\n",
        "\n",
        "hpc = {'Harry':'10', None:'Weasley', 'Snape':5}\n",
        "\n",
        "print(hpc)\n",
        "print(type(hpc))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'Harry': '10', None: 'Weasley', 'Snape': 5}\n",
            "<class 'dict'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lE-8ouBSUySo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "48ce8250-64cb-4e1c-96b8-62d79ab8250b"
      },
      "source": [
        "# class boolean\n",
        "\n",
        "boolean = True\n",
        "print(type(boolean))\n",
        "\n",
        "print(bool(-2.32))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'bool'>\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K6lHW02cVC6f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "392754b0-1753-4cc4-85ef-377c0f5a755f"
      },
      "source": [
        "#None type\n",
        "\n",
        "z = None\n",
        "print(type(z))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'NoneType'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "43k3bdBWVLdl"
      },
      "source": [
        "## Commonly used operators in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hRgFK9ZzVFrp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3fce2442-68c7-4931-9ec4-a4ec2ff11cde"
      },
      "source": [
        "a = 6.9\n",
        "b = 4.2\n",
        "\n",
        "print('Add: ', a+b)\n",
        "print('Subtract: ', a-b)\n",
        "print('Divide: ', a/b)\n",
        "print('Multiply: ', a*b)\n",
        "print('Floor Division: ', a//b)\n",
        "print('Mod: ', a%b)       \n",
        "print('Power: ', a**b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Add:  11.100000000000001\n",
            "Subtract:  2.7\n",
            "Divide:  1.6428571428571428\n",
            "Multiply:  28.980000000000004\n",
            "Floor Division:  1.0\n",
            "Mod:  2.7\n",
            "Power:  3335.540214978119\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "epgvbOtWVuId"
      },
      "source": [
        "### A few tricks"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NB9-F6tCVpMO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "729b8da0-6ff1-4c86-8aa6-b9db98f544ef"
      },
      "source": [
        "a = 10\n",
        "b = 'Apple'\n",
        "\n",
        "print('Before swap: ', a, b)\n",
        "\n",
        "a, b = b, a\n",
        "print('After swap: ', a, b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Before swap:  10 Apple\n",
            "After swap:  Apple 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SyWaqfHhV6L5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7b3cdef2-b75f-4f4a-a9cc-32371c3a9765"
      },
      "source": [
        "a, *b = 34, 23, 10\n",
        "\n",
        "print(type(a))\n",
        "print(type(b))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'>\n",
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8ttnUtpLWg5W"
      },
      "source": [
        "## Type casting in Python\n",
        "\n",
        "Type Casting is the method to convert the variable data type into a certain data type in order for the operation required to be performed by users."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SzT49t-NWMuS",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "847b090f-2ad2-4286-88db-1f41a67d12c0"
      },
      "source": [
        "# switching from string to integer\n",
        "\n",
        "x = '10'\n",
        "print(type(x))\n",
        "\n",
        "print('String to Integer: ', int(x))\n",
        "\n",
        "x = int(x)\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'str'>\n",
            "String to Integer:  10\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bDZE0cGjW2RG",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "61fbd7b4-a022-4ac9-d49a-9e284ef98b76"
      },
      "source": [
        "# switching from string to float\n",
        "\n",
        "print(float(x))\n",
        "\n",
        "print(type(x))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10.0\n",
            "<class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ByWyHb2yXGGh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "133d3da8-b641-4d86-d967-9921d66940c6"
      },
      "source": [
        "# switching from integer to string\n",
        "\n",
        "x = str(1) + '0'\n",
        "\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-tbNz0ceXS4O",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df101fcd-75a5-487b-e16d-e518574fc817"
      },
      "source": [
        "# switching from set to list\n",
        "\n",
        "s = set((1, 2, 3, 5, 8))\n",
        "\n",
        "list_s = list(s)\n",
        "print(list_s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 3, 5, 8]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "92FyE9vyXwgX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cf851aec-997c-4bad-f32e-ab75314e2fc5"
      },
      "source": [
        "# switching from a tuple to list\n",
        "\n",
        "tuples = ((1, 2), (4, 'Ginny'), (7, 'Fred'))\n",
        "\n",
        "list_tup = list(tuples)\n",
        "print(list_tup)\n",
        "\n",
        "print(type(list_tup))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(1, 2), (4, 'Ginny'), (7, 'Fred')]\n",
            "<class 'list'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "667dU9Hgennd"
      },
      "source": [
        "s = set((1,2,3,4))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fI4hrIYfYLYK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "955e7c9d-aea9-48d4-b8a2-7963c5788115"
      },
      "source": [
        "# ascii value of alpha numeric characters\n",
        "\n",
        "print(chr(120))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "x\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "15IRjR0fYWuA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "26265510-62e9-472f-c076-06a6edbaa86a"
      },
      "source": [
        "# string to ascii\n",
        "\n",
        "print(ord('x'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FOOWQ-hpYfDj"
      },
      "source": [
        "## Using in-built functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ptbOxtLzYkwt"
      },
      "source": [
        "### Using the `random` method\n",
        "\n",
        "This method is used to geenrate 'random' values or ranges depending on the requirement."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Q2-bbLCQYYmo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c80eb521-a701-4fb3-e086-84d57966bec2"
      },
      "source": [
        "import random\n",
        "\n",
        "# adding the start and end paramaters\n",
        "\n",
        "print(random.randint(5, 10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dOhlnJ3cZOG_"
      },
      "source": [
        "### Using the `math` method\n",
        "\n",
        "You can use this method(/library) to make mathematical operations much easier."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OLn6RTezZAQo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "56eba09a-d6e0-446b-8319-61e725719689"
      },
      "source": [
        "import math\n",
        "print('Inbuilt value of pi: ', math.pi)\n",
        "print('Square root: ', math.sqrt(2209))\n",
        "\n",
        "print('Floor value: ', math.ceil(3.1415))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Inbuilt value of pi:  3.141592653589793\n",
            "Square root:  47.0\n",
            "Floor value:  4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AEeN-tSCaPun"
      },
      "source": [
        "### Using the `datetime` method\n",
        "\n",
        "Yeah, nothing fancy about it. Just does what the name mentions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "17f721kKZp2s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5c1ab180-003b-4aa9-c51e-f2178e495dae"
      },
      "source": [
        "import datetime\n",
        "\n",
        "date = datetime.datetime.now()\n",
        "\n",
        "print(date)\n",
        "print(type(date))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2021-09-23 17:10:47.660093\n",
            "<class 'datetime.datetime'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z-jk8S03aqlY"
      },
      "source": [
        "## Lists!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_9wnAlTpae_u",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "3ce74d31-1bae-4b6a-89f1-b4960be49baf"
      },
      "source": [
        "# initializing a list\n",
        "list_1 = list()\n",
        "print(list_1)\n",
        "\n",
        "# the data type of the variable\n",
        "print(type(list_1))\n",
        "\n",
        "# a numeric list\n",
        "list_num = [1, 2, 3, 4]\n",
        "print(list_num)\n",
        "\n",
        "# list with objects\n",
        "list_object = ['1', '6', 81, '%', 'Williamsburg']\n",
        "print(list_object)\n",
        "\n",
        "# The operations are automatically computed when mentioned inside the list\n",
        "list_ops = [1*3, 'apple'+'cheap', 10//2]\n",
        "print(list_ops)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n",
            "<class 'list'>\n",
            "[1, 2, 3, 4]\n",
            "['1', '6', 81, '%', 'Williamsburg']\n",
            "[3, 'applecheap', 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UM8zUVyNboCx"
      },
      "source": [
        "### Accessing the values from a list\n",
        "\n",
        "**Fun fact:** Python does allow negative indexing!"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5gwYaHT0bZPC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0df6b241-ddf1-4232-f0b3-cdda59956d67"
      },
      "source": [
        "list_object = ['1', '6', 81, '%', 'Williamsburg']\n",
        "\n",
        "list_object[4]"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'Williamsburg'"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9ipofY0Fb0U1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0074cff1-f9c7-40b4-a248-564f88b1f8cb"
      },
      "source": [
        "# executing all the values from the beginning to the end\n",
        "\n",
        "print(list_object[2:4])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[81, '%']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Rpr8D7wSg_HV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "652b3605-bafa-4375-cdf1-d212ea67fd54"
      },
      "source": [
        "print(list_object[:3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['1', '6', 81]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xKJh-xDab_Bc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "51c7e3d0-b272-43fd-9bad-c1a3b82bed54"
      },
      "source": [
        "# let's say that we want we to skip a few values in between\n",
        "\n",
        "print(list_object[0:4:2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['1', 81]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vZrPD263cJ5r",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "82920cfd-5838-450e-a630-732e2d341598"
      },
      "source": [
        "# negative ranges\n",
        "\n",
        "print(list_object[-4:])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['6', 81, '%', 'Williamsburg']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "L0V-j6SucW38"
      },
      "source": [
        "### Modifying lists"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vkWrEGdhcOaY",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "884721cc-9570-47ca-f45c-2b545e007d44"
      },
      "source": [
        "# make changes in the list\n",
        "\n",
        "list_object.extend([0,1.2])\n",
        "print(list_object)\n",
        "\n",
        "\n",
        "# make range of values changes\n",
        "\n",
        "subset_items = [1,52,798,8]\n",
        "list_object[0:4] = subset_items\n",
        "print(list_object)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['1', '6', 81, '%', 'Williamsburg', 0, 1.2]\n",
            "[1, 52, 798, 8, 'Williamsburg', 0, 1.2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gVXZXxmRc_h5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "80c4c481-5741-4360-e82d-28ff303f7f3e"
      },
      "source": [
        "# skipping changes\n",
        "\n",
        "subset = ['2','45555','12']\n",
        "list_object[0:5:2] = subset\n",
        "print(list_object)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['2', 52, '45555', 8, '12', 0, 1.2]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sV2V_Y_qdD9I",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "73c7352d-ac63-4b93-fa67-f3d5f6a1f394"
      },
      "source": [
        "# delete an element\n",
        "\n",
        "list_object = [1, 2, 12, 12, 12, 3, 4, 5, 7]\n",
        "\n",
        "# can be used as a stack and/or a queue\n",
        "\n",
        "print(list_object)\n",
        "list_object.pop()\n",
        "print(list_object)\n",
        "list_object.pop(2)\n",
        "print(list_object)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1, 2, 12, 12, 12, 3, 4, 5, 7]\n",
            "[1, 2, 12, 12, 12, 3, 4, 5]\n",
            "[1, 2, 12, 12, 3, 4, 5]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mEAUkcSHdd0b"
      },
      "source": [
        "What do we do if there is an error while removing a value from the list and the list is empty?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0RVeKOizdQqL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6c3b45f4-5579-41ee-9649-2d469abcbcbb"
      },
      "source": [
        "# we use the try except functionality\n",
        "\n",
        "try:\n",
        "  list_object.remove(10)\n",
        "\n",
        "except:\n",
        "  print('Element not in list')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Element not in list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BC8M5ZqudzqK"
      },
      "source": [
        "## The `for` loop"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eVnWXhDfdq7V",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "81b10b65-7b27-4c25-b711-ebd8cf01b385"
      },
      "source": [
        "for i in range(0,5):\n",
        "  print(i, end=' ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 1 2 3 4 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BDA6B-C9fNI7",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "70d5b9df-e887-422b-a763-5cfb898869f2"
      },
      "source": [
        "print('Adding the step parameter ')\n",
        "\n",
        "for i in range(10,2,-2):\n",
        "  print(i, end=' ')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adding the step parameter \n",
            "10 8 6 4 "
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-HopnRQRfSq8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "59cd4d7b-0c79-494a-de8b-bf11150e0978"
      },
      "source": [
        "print('Printing the values in the format of a list ')\n",
        "\n",
        "a = [1,2,3,4,5]\n",
        "for i in a:\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Printing the values in the format of a list \n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZyhGZlSufaUZ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "15ffa4e9-bb9c-4595-970a-dec15a077c6d"
      },
      "source": [
        "print('One-line for loop')\n",
        "\n",
        "sum_upto_10 = [i for i in range(11)]\n",
        "print(sum_upto_10)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "One-line for loop\n",
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U8xDb2JEfhG_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5837a8f6-a972-48f8-b1ee-14cb0428c048"
      },
      "source": [
        "print('One-linear nested for loop Matrix Multiplication')\n",
        "\n",
        "matrix_mul = [j*i for i in range(5) for j in range(5,10)]\n",
        "print('Matrix Looks like: ', matrix_mul)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "One-linear nested for loop Matrix Multiplication\n",
            "Matrix Looks like:  [0, 0, 0, 0, 0, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 15, 18, 21, 24, 27, 20, 24, 28, 32, 36]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "T3mYXwOpfuqX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1979da2b-e7d9-44a8-8ce9-75f7446ae979"
      },
      "source": [
        "a = ['Hello', 'world', '!']\n",
        "\n",
        "# iterable method 1\n",
        "print('Iterable Method 1: ')\n",
        "for i in range(len(a)):\n",
        "  print(i, a[i])\n",
        "\n",
        "# iterable method 2\n",
        "print('\\nIterable Method 2: ')\n",
        "for i in a:\n",
        "  print(i)\n",
        "\n",
        "# (iterable?) method 3\n",
        "print('\\nMethod 3: ')\n",
        "print(list(enumerate(a)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Iterable Method 1: \n",
            "0 Hello\n",
            "1 world\n",
            "2 !\n",
            "\n",
            "Iterable Method 2: \n",
            "Hello\n",
            "world\n",
            "!\n",
            "\n",
            "Method 3: \n",
            "[(0, 'Hello'), (1, 'world'), (2, '!')]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ak9F4uRrg0n4"
      },
      "source": [
        "## Functions\n",
        "\n",
        "To define a function, use the `def` keyword followed by the name of the function with attributes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "048vzN1Ggkbg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "131eb441-2128-4d36-cdde-079104d873f9"
      },
      "source": [
        "def fizzBuzz():\n",
        "  \n",
        "  '''\n",
        "  Given a range print Fizz if divisible by 3, Buzz if divisible by 5 else FizzBuzz if divisible by 3 and 5\n",
        "  '''\n",
        "\n",
        "  n = int(input('Enter a number: '))\n",
        "  count = 1\n",
        "  while (count <= n):\n",
        "    string = ''\n",
        "    if (count %3 == 0):\n",
        "      string = 'Fizz'\n",
        "    if (count % 5 == 0):\n",
        "      string += 'Buzz'\n",
        "    print(count,string)\n",
        "    count +=1\n",
        "    \n",
        "fizzBuzz()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 15\n",
            "1 \n",
            "2 \n",
            "3 Fizz\n",
            "4 \n",
            "5 Buzz\n",
            "6 Fizz\n",
            "7 \n",
            "8 \n",
            "9 Fizz\n",
            "10 Buzz\n",
            "11 \n",
            "12 Fizz\n",
            "13 \n",
            "14 \n",
            "15 FizzBuzz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xKoVLslfhIwF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "adf74657-cb1c-4bb4-d810-e7a5bb7e0e3e"
      },
      "source": [
        "def fizzBuzz():\n",
        "  \n",
        "  '''\n",
        "  Same function as above with more if else conditions.\n",
        "  '''\n",
        "  \n",
        "  n = int(input('Enter a number: '))\n",
        "  count = 1\n",
        "  while(count <= n):\n",
        "    if (count % 5 == 0 and count % 3 == 0):\n",
        "      print(count,'Fizz Buzz')\n",
        "    elif (count % 3 == 0):\n",
        "      print(count,'Fizz')\n",
        "    elif (count % 5 == 0):\n",
        "      print(count,'Buzz')\n",
        "    else:\n",
        "      print(count)\n",
        "    count +=1\n",
        "\n",
        "fizzBuzz()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 15\n",
            "1\n",
            "2\n",
            "3 Fizz\n",
            "4\n",
            "5 Buzz\n",
            "6 Fizz\n",
            "7\n",
            "8\n",
            "9 Fizz\n",
            "10 Buzz\n",
            "11\n",
            "12 Fizz\n",
            "13\n",
            "14\n",
            "15 Fizz Buzz\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hej1NI9LjM_U"
      },
      "source": [
        "## Dictionaries\n",
        "\n",
        "In the case of dictionaries, we use `key` and not indexes to refer elements in the dictionary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zuUqQDD4hVVI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e10b1823-afc9-4334-f697-45f33e538031"
      },
      "source": [
        "# creating an empty dictionary\n",
        "dict_ = {}\n",
        "\n",
        "#dict_ = {key:value,key:value} \n",
        "# keys have to be in a set i.e., they are to be unique\n",
        "\n",
        "string = 'iamdictionaryiteratemeandseethefun'\n",
        "\n",
        "for ch in string:\n",
        "  if (ch in dict_):\n",
        "    dict_[ch] +=1\n",
        "\n",
        "  else:\n",
        "    dict_[ch] = 1\n",
        "\n",
        "for k,v in dict_.items():\n",
        "  # pass\n",
        "  print(f'Character {k} and its count {v}')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Character i and its count 4\n",
            "Character a and its count 4\n",
            "Character m and its count 2\n",
            "Character d and its count 2\n",
            "Character c and its count 1\n",
            "Character t and its count 4\n",
            "Character o and its count 1\n",
            "Character n and its count 3\n",
            "Character r and its count 2\n",
            "Character y and its count 1\n",
            "Character e and its count 6\n",
            "Character s and its count 1\n",
            "Character h and its count 1\n",
            "Character f and its count 1\n",
            "Character u and its count 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6_elLpZ6kiK8"
      },
      "source": [
        "**NOTE:** If we try updating for a key that is present the original value will be overwritten"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sN67bR2IkhBg",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 196
        },
        "outputId": "c711b6d1-50f5-41d2-df56-f89590caa069"
      },
      "source": [
        "# print value for some key\n",
        "\n",
        "# Hint: use .get or check for existence before access to avoid error like below\n",
        "\n",
        "print(dict_['z'])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-89-8876ad1be63d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;31m# Hint: use .get or check for existence before access to avoid error like below\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdict_\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'z'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 'z'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gkgH5jCblKe0",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02340ea6-2111-4cd5-bb0b-a68007eafcfa"
      },
      "source": [
        "print(dict_.get('z'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "None\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WKesksqVnpSm"
      },
      "source": [
        "## Sorting\n",
        "\n",
        "For sorting a list, the data type of all the elements should be the same."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bZQltNt8lN0s",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1baa4cef-f355-4b2b-cc29-b58dfee25f54"
      },
      "source": [
        "list_ = ['a','3232','21332','bsaa','87','3231']\n",
        "print(list_)\n",
        "\n",
        "print('\\nAscending order: ')\n",
        "\n",
        "# the sorting is done only for the first character\n",
        "result = []\n",
        "for i in list_:\n",
        "  sum_ = 0\n",
        "  for j in i:\n",
        "    sum_ = ord(j)\n",
        "    break\n",
        "  result.append(sum_)\n",
        "\n",
        "# it checks the first character of the string\n",
        "# if there is a match, it proceeds further\n",
        "print('Before sorting')\n",
        "print(list_)\n",
        "print(result)\n",
        "\n",
        "print('---------------')\n",
        "print('After sorting')\n",
        "list_.sort()\n",
        "result.sort()\n",
        "print(list_)\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['a', '3232', '21332', 'bsaa', '87', '3231']\n",
            "\n",
            "Ascending order: \n",
            "Before sorting\n",
            "['a', '3232', '21332', 'bsaa', '87', '3231']\n",
            "[97, 51, 50, 98, 56, 51]\n",
            "---------------\n",
            "After sorting\n",
            "['21332', '3231', '3232', '87', 'a', 'bsaa']\n",
            "[50, 51, 51, 56, 97, 98]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RHL7DdFyobhP"
      },
      "source": [
        "### Difference between `sort()` and `sorted()`\n",
        "\n",
        "`sort()` function will modify the list it is called on. The function modifies/sorts the list in-place and has no return value.\n",
        "\n",
        "On the other hand, `sorted()` function will create a new list containing a sorted version of the list it is given."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f62xRfAAoRsc",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5573561a-842a-4e6b-c988-347c790d5f79"
      },
      "source": [
        "a = [1,3,2]\n",
        "print('a: ', a)\n",
        "b = sorted(a)\n",
        "print('a after sorted(): ',a)\n",
        "print('\\nb: ', b)\n",
        "a.sort()\n",
        "print('a after sort(): ', a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a:  [1, 3, 2]\n",
            "a after sorted():  [1, 3, 2]\n",
            "\n",
            "b:  [1, 2, 3]\n",
            "a after sort():  [1, 2, 3]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Qc_uhmN7o9wf"
      },
      "source": [
        "## `lambda` functions in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CuLsIVTpourk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6878fe9f-1cb2-4416-974d-5c546c26e41c"
      },
      "source": [
        "add = lambda a, b, c: a+b+c\n",
        "print(add(5, 6, 2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NakEwD_bpFKh",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "520fbb8c-b832-4bd2-bcd6-e6f231fe0a59"
      },
      "source": [
        "dictonary = {67:\"Ted\", 23:\"Marshall\", 12:\"Barney\", 45:\"Robin\", 11:\"Lily\", 73:\"Victoria\", 99:\"Tracy\"}\n",
        "\n",
        "# sort the tuple on values\n",
        "tuples  = sorted(dictonary.items(), key = lambda x:(x[1],x[0]), reverse=False)\n",
        "print('\\nSorted on values')\n",
        "for elements in tuples:\n",
        "    print(elements[0],\"::\",elements[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Sorted on values\n",
            "12 :: Barney\n",
            "11 :: Lily\n",
            "23 :: Marshall\n",
            "45 :: Robin\n",
            "67 :: Ted\n",
            "99 :: Tracy\n",
            "73 :: Victoria\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zuIdrS6gpve2"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}