Notebooks/PYTHON_CRASH_COURSE_DAY_3.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "kernelspec": {
      "language": "python",
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.7.10",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    },
    "colab": {
      "name": "PYTHON-CRASH-COURSE-DAY-3.ipynb",
      "provenance": [],
      "include_colab_link": true
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Amey-Thakur/PYTHON-CRASH-COURSE/blob/main/PYTHON_CRASH_COURSE_DAY_3.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i9TV4Cm-BmnY"
      },
      "source": [
        "# **Day 3**\n",
        "\n",
        "**Python Keywords**\n",
        "\n",
        "Keywords are reserved words in Python.They are built into core language. They cannot be used as a variable name, class name, function name, or any other identifier. These keywords are used to define the syntax and semantics of the Python."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.634050Z",
          "iopub.execute_input": "2021-08-08T18:26:50.634468Z",
          "iopub.status.idle": "2021-08-08T18:26:50.646629Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.634363Z",
          "shell.execute_reply": "2021-08-08T18:26:50.645970Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TdVc5I4SBmna",
        "outputId": "725656a0-b6fd-43bf-be49-0aa9e1cb8b19"
      },
      "source": [
        "#and: This is a logical operator used to combine conditional statements and returns true \n",
        "#if both statements are true, else false otherwise\n",
        " \n",
        "(5>3) and (4>2)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 1
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.647683Z",
          "iopub.execute_input": "2021-08-08T18:26:50.648093Z",
          "iopub.status.idle": "2021-08-08T18:26:50.660011Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.648054Z",
          "shell.execute_reply": "2021-08-08T18:26:50.658984Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VJ2ehhhkBmnc",
        "outputId": "5147c56e-db6a-4fa9-c011-33c1d6b62648"
      },
      "source": [
        "(5<3) and (4>2)"
      ],
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.661571Z",
          "iopub.execute_input": "2021-08-08T18:26:50.662077Z",
          "iopub.status.idle": "2021-08-08T18:26:50.671991Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.662018Z",
          "shell.execute_reply": "2021-08-08T18:26:50.670982Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wm8Tfx-CBmnc",
        "outputId": "675a3bd7-2d7a-47d6-b0bf-427004df17c4"
      },
      "source": [
        "#as: This is used to create an alias\n",
        "import calendar as cal\n",
        "\n",
        "cal.isleap(2021)"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.673364Z",
          "iopub.execute_input": "2021-08-08T18:26:50.673632Z",
          "iopub.status.idle": "2021-08-08T18:26:50.683714Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.673605Z",
          "shell.execute_reply": "2021-08-08T18:26:50.682844Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hMAUhohJBmnd",
        "outputId": "a69d6b35-5825-4527-803e-5856dd705b86"
      },
      "source": [
        "cal.isleap(2020)"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.685411Z",
          "iopub.execute_input": "2021-08-08T18:26:50.686045Z",
          "iopub.status.idle": "2021-08-08T18:26:50.694433Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.686004Z",
          "shell.execute_reply": "2021-08-08T18:26:50.693454Z"
        },
        "trusted": true,
        "id": "RnPKg4-4Bmnd"
      },
      "source": [
        "#assert: It is used while debugging code. It allows us to check if a condition in code returns \n",
        "#True, if not Python will raise an assertion error.\n",
        "\n",
        "stock = 'GOOG'"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.696598Z",
          "iopub.execute_input": "2021-08-08T18:26:50.697067Z",
          "iopub.status.idle": "2021-08-08T18:26:50.706114Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.697022Z",
          "shell.execute_reply": "2021-08-08T18:26:50.705145Z"
        },
        "trusted": true,
        "id": "SA3mR4JwBmne"
      },
      "source": [
        "assert stock == 'GOOG'"
      ],
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zUVHS9eOBmne"
      },
      "source": [
        "**Operators in Python**\n",
        "\n",
        "Operators are used to perform operations on variables and values.\n",
        "\n",
        "\n",
        "**List of Operators**\n",
        "\n",
        "1. **Arithmetic Operators** These operators are used with numerical values to perform common mathematical operations"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.707505Z",
          "iopub.execute_input": "2021-08-08T18:26:50.707957Z",
          "iopub.status.idle": "2021-08-08T18:26:50.718675Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.707925Z",
          "shell.execute_reply": "2021-08-08T18:26:50.717818Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TsG95T0xBmne",
        "outputId": "16f7f99f-0cea-422f-a33f-a6a236b9d3e3"
      },
      "source": [
        "#+: This is an addition operator used to perform the addition between the values.\n",
        "5+3"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "8"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.720148Z",
          "iopub.execute_input": "2021-08-08T18:26:50.720663Z",
          "iopub.status.idle": "2021-08-08T18:26:50.728740Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.720624Z",
          "shell.execute_reply": "2021-08-08T18:26:50.727933Z"
        },
        "trusted": true,
        "id": "R5HVRXbPBmnf"
      },
      "source": [
        "#task: perform -,*,/,%,**"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.730008Z",
          "iopub.execute_input": "2021-08-08T18:26:50.730271Z",
          "iopub.status.idle": "2021-08-08T18:26:50.741666Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.730245Z",
          "shell.execute_reply": "2021-08-08T18:26:50.740894Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hkNI3X1ZBmnf",
        "outputId": "b5dc3560-e8b3-4f0d-fb6d-a7c15df310f4"
      },
      "source": [
        "#floor division\n",
        "27//4"
      ],
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "6"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Jvu54QRwBmng"
      },
      "source": [
        "**2. Comparison Operator**\n",
        "\n",
        "Comparison Operators are used to compare two or more values or operands. It works well with almost all the data types in Python and returns either True or False"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.745547Z",
          "iopub.execute_input": "2021-08-08T18:26:50.745852Z",
          "iopub.status.idle": "2021-08-08T18:26:50.752393Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.745823Z",
          "shell.execute_reply": "2021-08-08T18:26:50.751426Z"
        },
        "trusted": true,
        "id": "ruT-rJVkBmng"
      },
      "source": [
        "#lets define some variables\n",
        "a = 5\n",
        "b = 3\n",
        "x = 5\n",
        "y = 8"
      ],
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.753770Z",
          "iopub.execute_input": "2021-08-08T18:26:50.754044Z",
          "iopub.status.idle": "2021-08-08T18:26:50.764661Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.754021Z",
          "shell.execute_reply": "2021-08-08T18:26:50.763628Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NwwhVfIqBmng",
        "outputId": "3f3d3662-4ef3-48ae-b93d-54c4e61370a9"
      },
      "source": [
        "#==: This will check whether the two operands are equal or not\n",
        "a == x"
      ],
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.765935Z",
          "iopub.execute_input": "2021-08-08T18:26:50.766188Z",
          "iopub.status.idle": "2021-08-08T18:26:50.775779Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.766162Z",
          "shell.execute_reply": "2021-08-08T18:26:50.774836Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7kIkL8inBmnh",
        "outputId": "c5735724-3687-4879-867a-0339e0cb2225"
      },
      "source": [
        "b == y"
      ],
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.777253Z",
          "iopub.execute_input": "2021-08-08T18:26:50.777950Z",
          "iopub.status.idle": "2021-08-08T18:26:50.785493Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.777853Z",
          "shell.execute_reply": "2021-08-08T18:26:50.784790Z"
        },
        "trusted": true,
        "id": "0BQCxg0UBmnh"
      },
      "source": [
        "#task: perform !=, <, >, <=, >="
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LjaiIsrHBmni"
      },
      "source": [
        "**3. Logical Operators**\n",
        "\n",
        "Logical Operators are used to compare two or more conditional statements or expressions and returns the boolean reult."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.796363Z",
          "iopub.execute_input": "2021-08-08T18:26:50.796649Z",
          "iopub.status.idle": "2021-08-08T18:26:50.802998Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.796624Z",
          "shell.execute_reply": "2021-08-08T18:26:50.801884Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O8GLXOX7Bmni",
        "outputId": "f71d0f93-bbf5-4cb5-8055-9e66ea666b2f"
      },
      "source": [
        "#and: This operator compares multiple conditional statements and returns\n",
        "#True, if all the statements are true, else false\n",
        "\n",
        "5 == 5 and 3 < 5"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.818794Z",
          "iopub.execute_input": "2021-08-08T18:26:50.819327Z",
          "iopub.status.idle": "2021-08-08T18:26:50.825792Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.819272Z",
          "shell.execute_reply": "2021-08-08T18:26:50.824700Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TQVlWrikBmnj",
        "outputId": "bc21da25-1002-443a-a1f6-891c3dd8165e"
      },
      "source": [
        "#task: or, not\n",
        "3 > 5 or 5 < 8"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.827218Z",
          "iopub.execute_input": "2021-08-08T18:26:50.827495Z",
          "iopub.status.idle": "2021-08-08T18:26:50.837646Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.827471Z",
          "shell.execute_reply": "2021-08-08T18:26:50.836721Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UsqK_cUUBmnj",
        "outputId": "03e0843a-54c4-4c26-e67a-52348cc43c5b"
      },
      "source": [
        "not 3 == 3"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 16
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kRSHt3O6Bmnk"
      },
      "source": [
        "**4. Assignment Operator**\n",
        "\n",
        "These operators are used to assign values to the operands or variables"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.855236Z",
          "iopub.execute_input": "2021-08-08T18:26:50.855555Z",
          "iopub.status.idle": "2021-08-08T18:26:50.859786Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.855527Z",
          "shell.execute_reply": "2021-08-08T18:26:50.858747Z"
        },
        "trusted": true,
        "id": "10FxNd7-Bmnk"
      },
      "source": [
        "#=: This will assign the value on its right side to the operand on its left\n",
        "a = 5\n",
        "b = 3"
      ],
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.861673Z",
          "iopub.execute_input": "2021-08-08T18:26:50.862093Z",
          "iopub.status.idle": "2021-08-08T18:26:50.874323Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.862054Z",
          "shell.execute_reply": "2021-08-08T18:26:50.873351Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-9h2HmJhBmnl",
        "outputId": "e8996596-bb20-4189-e3e4-20ee8561f90b"
      },
      "source": [
        "#+=: This operator adds to the operand on the right side with the operand on the left\n",
        "#and assigns the result back to same operand on the left side\n",
        "a += 2\n",
        "a"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "7"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.875938Z",
          "iopub.execute_input": "2021-08-08T18:26:50.876198Z",
          "iopub.status.idle": "2021-08-08T18:26:50.882020Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.876174Z",
          "shell.execute_reply": "2021-08-08T18:26:50.881041Z"
        },
        "trusted": true,
        "id": "QWeROgObBmnl"
      },
      "source": [
        "#task: -=, *=, /+, %=, **=, //="
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CiMF4ZMRBmnm"
      },
      "source": [
        "**5. Membership Operator**\n",
        "\n",
        "This operator is used to check whether the value/variable exists in the sequence/data structure or not"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.884497Z",
          "iopub.execute_input": "2021-08-08T18:26:50.884821Z",
          "iopub.status.idle": "2021-08-08T18:26:50.893569Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.884792Z",
          "shell.execute_reply": "2021-08-08T18:26:50.892694Z"
        },
        "trusted": true,
        "id": "rJm_wy0IBmnm"
      },
      "source": [
        "#in: This operator return True if a value exists in the sequence else False\n",
        "stock_list = ['YHOO','NVDA','NFLX','MSFT','MNTRA']"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.895026Z",
          "iopub.execute_input": "2021-08-08T18:26:50.895273Z",
          "iopub.status.idle": "2021-08-08T18:26:50.905047Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.895250Z",
          "shell.execute_reply": "2021-08-08T18:26:50.904152Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Hs_wK6itBmnm",
        "outputId": "0e9b0142-0761-43a6-bdd3-53a4aafcdf25"
      },
      "source": [
        "'MSFT' in stock_list"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:50.906983Z",
          "iopub.execute_input": "2021-08-08T18:26:50.907379Z",
          "iopub.status.idle": "2021-08-08T18:26:50.916045Z",
          "shell.execute_reply.started": "2021-08-08T18:26:50.907339Z",
          "shell.execute_reply": "2021-08-08T18:26:50.915214Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hBNbm0zlBmnn",
        "outputId": "d20d85de-d540-4328-e8ce-48ef45a9f4aa"
      },
      "source": [
        "'GOOG' in stock_list"
      ],
      "execution_count": 22,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:51.001660Z",
          "iopub.execute_input": "2021-08-08T18:26:51.001991Z",
          "iopub.status.idle": "2021-08-08T18:26:51.008058Z",
          "shell.execute_reply.started": "2021-08-08T18:26:51.001963Z",
          "shell.execute_reply": "2021-08-08T18:26:51.007031Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bh1D5-kdBmnn",
        "outputId": "a6c6f6ea-4707-4f92-cc7e-074b7f7149bd"
      },
      "source": [
        "#not in: This is the negation of in operator\n",
        "'HP' not in stock_list"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "afeClMUoBmnn"
      },
      "source": [
        "**Control Flow Statement**\n",
        "\n",
        "A program's control flow is the order in which the program's code get executed.\n",
        "\n",
        "1. Conditional Statement\n",
        "2. Loops\n",
        "\n",
        "\n",
        "1. **Conditional Statement**\n",
        "\n",
        "THe code which gets executed only when a given condition is met or True\n",
        "\n",
        "1. if statement\n",
        "2. elif statement\n",
        "3. else statement\n",
        "\n",
        "**if statement**  The if statement is used when we want a code to be executed under certain conditions. It can be either a single or multiple conditions."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z3TfMGnFBmno"
      },
      "source": [
        "x = int(input('Enter the first number \\n'))\n",
        "y = int(input('Enter the second number \\n'))\n",
        "\n",
        "if(x > y):\n",
        "  print('X is greater')\n",
        "\n",
        "print('Y is greater')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4BcsXwU6Bmno"
      },
      "source": [
        "**elif**  This statement checks for new condition and executes the code if they are held true after the conditions evaluated by previous if statements weren't true"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:26:51.009513Z",
          "iopub.execute_input": "2021-08-08T18:26:51.009823Z",
          "iopub.status.idle": "2021-08-08T18:27:29.678219Z",
          "shell.execute_reply.started": "2021-08-08T18:26:51.009795Z",
          "shell.execute_reply": "2021-08-08T18:27:29.677477Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "g6zmt2L4Bmno",
        "outputId": "05f0ad42-5be7-402c-a64f-05828ac8469b"
      },
      "source": [
        "x = int(input('Enter the first number \\n'))\n",
        "y = int(input('Enter the second number \\n'))\n",
        "z = int(input('Enter the third number \\n'))\n",
        "\n",
        "if(x > y and x > z):\n",
        "  print('X is greater')\n",
        "elif(y>z):\n",
        "  print('Y is greater')\n",
        "\n",
        "print('I am printing from oustide the conditions')"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the first number \n",
            "12\n",
            "Enter the second number \n",
            "20\n",
            "Enter the third number \n",
            "32\n",
            "I am printing from oustide the conditions\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qZdVJfD9Bmnp"
      },
      "source": [
        "**else statement**\n",
        "\n",
        "This statement can be considered as the final part of the conditional statements. It doesn't evaluate any conditons. When defined it just executes the code within its block if all the conditions defined by the if and elif statements were false."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:29.679485Z",
          "iopub.execute_input": "2021-08-08T18:27:29.680072Z",
          "iopub.status.idle": "2021-08-08T18:27:53.039133Z",
          "shell.execute_reply.started": "2021-08-08T18:27:29.680026Z",
          "shell.execute_reply": "2021-08-08T18:27:53.038127Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9mnYp0aUBmnp",
        "outputId": "e82e19e1-5f1b-4877-e858-b24b6131d01e"
      },
      "source": [
        "x = int(input('Enter the first number \\n'))\n",
        "y = int(input('Enter the second number \\n'))\n",
        "z = int(input('Enter the third number \\n'))\n",
        "\n",
        "if(x > y and x > z):\n",
        "  print('X is greater')\n",
        "elif(y>z):\n",
        "  print('Y is greater')\n",
        "else:\n",
        "  print('Z is greater')"
      ],
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the first number \n",
            "12\n",
            "Enter the second number \n",
            "20\n",
            "Enter the third number \n",
            "32\n",
            "Z is greater\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JljFsyGoBmnp"
      },
      "source": [
        "**Loops**\n",
        "\n",
        "Statements that keep executing within a given a range or until a condition is met\n",
        "\n",
        "**1. while statement**\n",
        "\n",
        "The while statement in python is used to repeat execution of code or block of code that is controlled by an conditional expression\n",
        "\n",
        "syn: while(condn expr):\n",
        "\n",
        "st1,\n",
        "\n",
        "st2,\n",
        "\n",
        "..,\n",
        "...,\n",
        "...,\n",
        "stn"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.040263Z",
          "iopub.execute_input": "2021-08-08T18:27:53.040536Z",
          "iopub.status.idle": "2021-08-08T18:27:53.047800Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.040509Z",
          "shell.execute_reply": "2021-08-08T18:27:53.046790Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b-c6tl_UBmnq",
        "outputId": "0f765d07-aa40-432a-92af-211dda02e173"
      },
      "source": [
        "dp = 6\n",
        "count = 0\n",
        "\n",
        "while(count != dp):\n",
        "  print(\"Count = \",count)\n",
        "  count += 1"
      ],
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Count =  0\n",
            "Count =  1\n",
            "Count =  2\n",
            "Count =  3\n",
            "Count =  4\n",
            "Count =  5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.049861Z",
          "iopub.execute_input": "2021-08-08T18:27:53.050154Z",
          "iopub.status.idle": "2021-08-08T18:27:53.060040Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.050127Z",
          "shell.execute_reply": "2021-08-08T18:27:53.058995Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "plzADHpABmnq",
        "outputId": "03882b03-2ca2-460f-a831-af534e217f00"
      },
      "source": [
        "#using while with else\n",
        "dp = 6\n",
        "count = 0\n",
        "\n",
        "while(count != dp):\n",
        "  print(\"Count = \",count)\n",
        "  count += 1\n",
        "else:\n",
        "  print('Loop is over') "
      ],
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Count =  0\n",
            "Count =  1\n",
            "Count =  2\n",
            "Count =  3\n",
            "Count =  4\n",
            "Count =  5\n",
            "Loop is over\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.061505Z",
          "iopub.execute_input": "2021-08-08T18:27:53.061798Z",
          "iopub.status.idle": "2021-08-08T18:27:53.073111Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.061762Z",
          "shell.execute_reply": "2021-08-08T18:27:53.071365Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ovzhezYXBmnr",
        "outputId": "ef3bfd96-b555-457e-83a8-7e5d81d0d654"
      },
      "source": [
        "#Task: print all prime numbers between 0-100 using while loop\n",
        "num = 1\n",
        "while(num <= 100):\n",
        "  count = 0\n",
        "  i = 2\n",
        "\n",
        "  while(i <= num//2):\n",
        "    if(num % i == 0):\n",
        "      count += 1\n",
        "      break\n",
        "    i += 1\n",
        "\n",
        "  if(count == 0 and num != 1):\n",
        "    print(\"%d\" %num, end = ' ')\n",
        "  num = num + 1"
      ],
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hllT4YDkBmnr"
      },
      "source": [
        "**for statement**\n",
        "\n",
        "The for statement in python is another looping technique which iterates over a sequence of objects"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.074366Z",
          "iopub.execute_input": "2021-08-08T18:27:53.074618Z",
          "iopub.status.idle": "2021-08-08T18:27:53.083574Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.074594Z",
          "shell.execute_reply": "2021-08-08T18:27:53.082573Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T35ZTYLbBmnr",
        "outputId": "58fa0c3d-9ff6-42c7-b9bd-4d69cc2aef4a"
      },
      "source": [
        "ds = 'Data Science'\n",
        "for d in ds:\n",
        "  print('The word is :', d)"
      ],
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The word is : D\n",
            "The word is : a\n",
            "The word is : t\n",
            "The word is : a\n",
            "The word is :  \n",
            "The word is : S\n",
            "The word is : c\n",
            "The word is : i\n",
            "The word is : e\n",
            "The word is : n\n",
            "The word is : c\n",
            "The word is : e\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.084905Z",
          "iopub.execute_input": "2021-08-08T18:27:53.085186Z",
          "iopub.status.idle": "2021-08-08T18:27:53.094336Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.085158Z",
          "shell.execute_reply": "2021-08-08T18:27:53.093749Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PiTXBos4Bmns",
        "outputId": "7d7c54ff-ffad-467e-838d-90bbdf86e982"
      },
      "source": [
        "players = ['Dhoni','Sachin Tendulkar','Virat Kohli','Watson','Hitman','Shikhar dhawan', 'Chahal','Warner']\n",
        "for player in players:\n",
        "  print('Favourite Player is :', player)"
      ],
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Favourite Player is : Dhoni\n",
            "Favourite Player is : Sachin Tendulkar\n",
            "Favourite Player is : Virat Kohli\n",
            "Favourite Player is : Watson\n",
            "Favourite Player is : Hitman\n",
            "Favourite Player is : Shikhar dhawan\n",
            "Favourite Player is : Chahal\n",
            "Favourite Player is : Warner\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.095295Z",
          "iopub.execute_input": "2021-08-08T18:27:53.095559Z",
          "iopub.status.idle": "2021-08-08T18:27:53.102230Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.095535Z",
          "shell.execute_reply": "2021-08-08T18:27:53.101633Z"
        },
        "trusted": true,
        "id": "Oz8C36V0Bmns"
      },
      "source": [
        "#iterating over dictionaries\n",
        "d = {\n",
        "    'AAPL': 193.53,\n",
        "     'HP': 24.16,\n",
        "     'MSFT': 1164.94,\n",
        "     'GOOG':1061.49\n",
        "}"
      ],
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.103211Z",
          "iopub.execute_input": "2021-08-08T18:27:53.103586Z",
          "iopub.status.idle": "2021-08-08T18:27:53.115847Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.103547Z",
          "shell.execute_reply": "2021-08-08T18:27:53.114806Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B___nu_ZBmns",
        "outputId": "cb45fc37-54bb-4ee3-f2ae-b8ae38d09526"
      },
      "source": [
        "for key, val in d.items():\n",
        "  print('Price of {0} is {1}!'.format(key, val))"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Price of AAPL is 193.53!\n",
            "Price of HP is 24.16!\n",
            "Price of MSFT is 1164.94!\n",
            "Price of GOOG is 1061.49!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m90tsTA8Bmnt"
      },
      "source": [
        "**range function**\n",
        "\n",
        "Range function is used to generate sequences or arithmetic progression which can be combined with for loop to repeat the code\n",
        "\n",
        "the default starting is 0, default increment is 1 and ends with specified number\n",
        "\n",
        "syn: range([start], stop-1,[step])"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.117104Z",
          "iopub.execute_input": "2021-08-08T18:27:53.117457Z",
          "iopub.status.idle": "2021-08-08T18:27:53.127988Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.117428Z",
          "shell.execute_reply": "2021-08-08T18:27:53.126849Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yCqYYzqQBmnt",
        "outputId": "438d0fa5-b437-441e-ce97-17d6f20d12ed"
      },
      "source": [
        "for i in range(5):\n",
        "  print(i)"
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.129242Z",
          "iopub.execute_input": "2021-08-08T18:27:53.129618Z",
          "iopub.status.idle": "2021-08-08T18:27:53.141017Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.129579Z",
          "shell.execute_reply": "2021-08-08T18:27:53.140364Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8mocU6UpBmnt",
        "outputId": "32343b52-b6c5-4471-aaa0-e2d7216a2099"
      },
      "source": [
        "for i in range(1,50,3):\n",
        "  print(i)"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "4\n",
            "7\n",
            "10\n",
            "13\n",
            "16\n",
            "19\n",
            "22\n",
            "25\n",
            "28\n",
            "31\n",
            "34\n",
            "37\n",
            "40\n",
            "43\n",
            "46\n",
            "49\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.142090Z",
          "iopub.execute_input": "2021-08-08T18:27:53.142430Z",
          "iopub.status.idle": "2021-08-08T18:27:53.163430Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.142402Z",
          "shell.execute_reply": "2021-08-08T18:27:53.161970Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tfAUd8pcBmnu",
        "outputId": "038bf26e-c6f8-45cb-db31-b33d86663075"
      },
      "source": [
        "#printing multiplication table from 1 to 10\n",
        "for i in range (1,11):\n",
        "  print(\"Table of {0}\".format(i))\n",
        "  for j in range (1,11):\n",
        "    print(i*j)"
      ],
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Table of 1\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n",
            "Table of 2\n",
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n",
            "Table of 3\n",
            "3\n",
            "6\n",
            "9\n",
            "12\n",
            "15\n",
            "18\n",
            "21\n",
            "24\n",
            "27\n",
            "30\n",
            "Table of 4\n",
            "4\n",
            "8\n",
            "12\n",
            "16\n",
            "20\n",
            "24\n",
            "28\n",
            "32\n",
            "36\n",
            "40\n",
            "Table of 5\n",
            "5\n",
            "10\n",
            "15\n",
            "20\n",
            "25\n",
            "30\n",
            "35\n",
            "40\n",
            "45\n",
            "50\n",
            "Table of 6\n",
            "6\n",
            "12\n",
            "18\n",
            "24\n",
            "30\n",
            "36\n",
            "42\n",
            "48\n",
            "54\n",
            "60\n",
            "Table of 7\n",
            "7\n",
            "14\n",
            "21\n",
            "28\n",
            "35\n",
            "42\n",
            "49\n",
            "56\n",
            "63\n",
            "70\n",
            "Table of 8\n",
            "8\n",
            "16\n",
            "24\n",
            "32\n",
            "40\n",
            "48\n",
            "56\n",
            "64\n",
            "72\n",
            "80\n",
            "Table of 9\n",
            "9\n",
            "18\n",
            "27\n",
            "36\n",
            "45\n",
            "54\n",
            "63\n",
            "72\n",
            "81\n",
            "90\n",
            "Table of 10\n",
            "10\n",
            "20\n",
            "30\n",
            "40\n",
            "50\n",
            "60\n",
            "70\n",
            "80\n",
            "90\n",
            "100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.164570Z",
          "iopub.execute_input": "2021-08-08T18:27:53.164959Z",
          "iopub.status.idle": "2021-08-08T18:27:53.224501Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.164928Z",
          "shell.execute_reply": "2021-08-08T18:27:53.223502Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GyMVP1EUBmnu",
        "outputId": "0246d584-7c47-4c19-a74b-1d8a37502034"
      },
      "source": [
        "for i in range(1,11):\n",
        "  print(\"Table of :\",i)\n",
        "  for j in range(1,11):\n",
        "    print(i,'X',j,'=',i*j)"
      ],
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Table of : 1\n",
            "1 X 1 = 1\n",
            "1 X 2 = 2\n",
            "1 X 3 = 3\n",
            "1 X 4 = 4\n",
            "1 X 5 = 5\n",
            "1 X 6 = 6\n",
            "1 X 7 = 7\n",
            "1 X 8 = 8\n",
            "1 X 9 = 9\n",
            "1 X 10 = 10\n",
            "Table of : 2\n",
            "2 X 1 = 2\n",
            "2 X 2 = 4\n",
            "2 X 3 = 6\n",
            "2 X 4 = 8\n",
            "2 X 5 = 10\n",
            "2 X 6 = 12\n",
            "2 X 7 = 14\n",
            "2 X 8 = 16\n",
            "2 X 9 = 18\n",
            "2 X 10 = 20\n",
            "Table of : 3\n",
            "3 X 1 = 3\n",
            "3 X 2 = 6\n",
            "3 X 3 = 9\n",
            "3 X 4 = 12\n",
            "3 X 5 = 15\n",
            "3 X 6 = 18\n",
            "3 X 7 = 21\n",
            "3 X 8 = 24\n",
            "3 X 9 = 27\n",
            "3 X 10 = 30\n",
            "Table of : 4\n",
            "4 X 1 = 4\n",
            "4 X 2 = 8\n",
            "4 X 3 = 12\n",
            "4 X 4 = 16\n",
            "4 X 5 = 20\n",
            "4 X 6 = 24\n",
            "4 X 7 = 28\n",
            "4 X 8 = 32\n",
            "4 X 9 = 36\n",
            "4 X 10 = 40\n",
            "Table of : 5\n",
            "5 X 1 = 5\n",
            "5 X 2 = 10\n",
            "5 X 3 = 15\n",
            "5 X 4 = 20\n",
            "5 X 5 = 25\n",
            "5 X 6 = 30\n",
            "5 X 7 = 35\n",
            "5 X 8 = 40\n",
            "5 X 9 = 45\n",
            "5 X 10 = 50\n",
            "Table of : 6\n",
            "6 X 1 = 6\n",
            "6 X 2 = 12\n",
            "6 X 3 = 18\n",
            "6 X 4 = 24\n",
            "6 X 5 = 30\n",
            "6 X 6 = 36\n",
            "6 X 7 = 42\n",
            "6 X 8 = 48\n",
            "6 X 9 = 54\n",
            "6 X 10 = 60\n",
            "Table of : 7\n",
            "7 X 1 = 7\n",
            "7 X 2 = 14\n",
            "7 X 3 = 21\n",
            "7 X 4 = 28\n",
            "7 X 5 = 35\n",
            "7 X 6 = 42\n",
            "7 X 7 = 49\n",
            "7 X 8 = 56\n",
            "7 X 9 = 63\n",
            "7 X 10 = 70\n",
            "Table of : 8\n",
            "8 X 1 = 8\n",
            "8 X 2 = 16\n",
            "8 X 3 = 24\n",
            "8 X 4 = 32\n",
            "8 X 5 = 40\n",
            "8 X 6 = 48\n",
            "8 X 7 = 56\n",
            "8 X 8 = 64\n",
            "8 X 9 = 72\n",
            "8 X 10 = 80\n",
            "Table of : 9\n",
            "9 X 1 = 9\n",
            "9 X 2 = 18\n",
            "9 X 3 = 27\n",
            "9 X 4 = 36\n",
            "9 X 5 = 45\n",
            "9 X 6 = 54\n",
            "9 X 7 = 63\n",
            "9 X 8 = 72\n",
            "9 X 9 = 81\n",
            "9 X 10 = 90\n",
            "Table of : 10\n",
            "10 X 1 = 10\n",
            "10 X 2 = 20\n",
            "10 X 3 = 30\n",
            "10 X 4 = 40\n",
            "10 X 5 = 50\n",
            "10 X 6 = 60\n",
            "10 X 7 = 70\n",
            "10 X 8 = 80\n",
            "10 X 9 = 90\n",
            "10 X 10 = 100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "execution": {
          "iopub.status.busy": "2021-08-08T18:27:53.226280Z",
          "iopub.execute_input": "2021-08-08T18:27:53.226679Z",
          "iopub.status.idle": "2021-08-08T18:27:53.239286Z",
          "shell.execute_reply.started": "2021-08-08T18:27:53.226638Z",
          "shell.execute_reply": "2021-08-08T18:27:53.238666Z"
        },
        "trusted": true,
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b8kqRC0BBmnv",
        "outputId": "aecccb58-bcdd-40f7-cb3b-431863dcf125"
      },
      "source": [
        "for table_val in range(1, 11):\n",
        "  for multiplier in range(1,11):\n",
        "    ans = table_val * multiplier\n",
        "    print('{0} X {1} = {2}'.format(multiplier,table_val, ans), end= '\\t')\n",
        "  print()"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 X 1 = 1\t2 X 1 = 2\t3 X 1 = 3\t4 X 1 = 4\t5 X 1 = 5\t6 X 1 = 6\t7 X 1 = 7\t8 X 1 = 8\t9 X 1 = 9\t10 X 1 = 10\t\n",
            "1 X 2 = 2\t2 X 2 = 4\t3 X 2 = 6\t4 X 2 = 8\t5 X 2 = 10\t6 X 2 = 12\t7 X 2 = 14\t8 X 2 = 16\t9 X 2 = 18\t10 X 2 = 20\t\n",
            "1 X 3 = 3\t2 X 3 = 6\t3 X 3 = 9\t4 X 3 = 12\t5 X 3 = 15\t6 X 3 = 18\t7 X 3 = 21\t8 X 3 = 24\t9 X 3 = 27\t10 X 3 = 30\t\n",
            "1 X 4 = 4\t2 X 4 = 8\t3 X 4 = 12\t4 X 4 = 16\t5 X 4 = 20\t6 X 4 = 24\t7 X 4 = 28\t8 X 4 = 32\t9 X 4 = 36\t10 X 4 = 40\t\n",
            "1 X 5 = 5\t2 X 5 = 10\t3 X 5 = 15\t4 X 5 = 20\t5 X 5 = 25\t6 X 5 = 30\t7 X 5 = 35\t8 X 5 = 40\t9 X 5 = 45\t10 X 5 = 50\t\n",
            "1 X 6 = 6\t2 X 6 = 12\t3 X 6 = 18\t4 X 6 = 24\t5 X 6 = 30\t6 X 6 = 36\t7 X 6 = 42\t8 X 6 = 48\t9 X 6 = 54\t10 X 6 = 60\t\n",
            "1 X 7 = 7\t2 X 7 = 14\t3 X 7 = 21\t4 X 7 = 28\t5 X 7 = 35\t6 X 7 = 42\t7 X 7 = 49\t8 X 7 = 56\t9 X 7 = 63\t10 X 7 = 70\t\n",
            "1 X 8 = 8\t2 X 8 = 16\t3 X 8 = 24\t4 X 8 = 32\t5 X 8 = 40\t6 X 8 = 48\t7 X 8 = 56\t8 X 8 = 64\t9 X 8 = 72\t10 X 8 = 80\t\n",
            "1 X 9 = 9\t2 X 9 = 18\t3 X 9 = 27\t4 X 9 = 36\t5 X 9 = 45\t6 X 9 = 54\t7 X 9 = 63\t8 X 9 = 72\t9 X 9 = 81\t10 X 9 = 90\t\n",
            "1 X 10 = 10\t2 X 10 = 20\t3 X 10 = 30\t4 X 10 = 40\t5 X 10 = 50\t6 X 10 = 60\t7 X 10 = 70\t8 X 10 = 80\t9 X 10 = 90\t10 X 10 = 100\t\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}