1.1 Python_Introduction.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNFKAEyNqbKufRsgT1JgcxY",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/drsahilsartaj/RoadMapforAI/blob/main/1.1%20Python_Introduction.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I54vlDkMtKoH",
        "outputId": "15d95488-0991-4e85-cc9b-628e6b15ac22"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n",
            "Total number of keyword in python 3.7 is 35\n"
          ]
        }
      ],
      "source": [
        "# Get all keywords in python 3.7\n",
        "\n",
        "import keyword\n",
        "print(keyword.kwlist)\n",
        "print(f\"Total number of keyword in python 3.7 is {len(keyword.kwlist)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Python Multiline statement"
      ],
      "metadata": {
        "id": "O_3n5E6eEEze"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 1 + 2 + 3 + \\\n",
        "    4 + 5 + 6 + \\\n",
        "    7 + 8"
      ],
      "metadata": {
        "id": "OjJ9Y8-ytlsr"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5OCRtflBFS2p",
        "outputId": "19b0de98-306d-4670-b251-d1c1e65c90f5"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#another way is\n",
        "a = (1 + 2 + 3 +\n",
        "    4 + 5 + 6 +\n",
        "    7 + 8)\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TefDDeJ1FUqo",
        "outputId": "fbc879ea-fd14-4c81-d0a5-b1c600769265"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "36\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10; b = 20; c = 30   #put multiple statements in a single line using ;"
      ],
      "metadata": {
        "id": "zpS2_lYmFc1T"
      },
      "execution_count": 21,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Multiple Assignments\n",
        "\n",
        "a, b, c = 10, 5.5, \"ML\""
      ],
      "metadata": {
        "id": "xEKPdKgJIXvo"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "a = b = c = \"AI\" #assign the same value to multiple variables at once"
      ],
      "metadata": {
        "id": "aWHK3nnOIdWE"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Number"
      ],
      "metadata": {
        "id": "mc5XFhyaT6RO"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5                               #data type is implicitly set to integer\n",
        "print(a, \" is of type\", type(a))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "F7OZDbdaIfQf",
        "outputId": "dc9bb538-cb34-47b0-ba14-2078442fb236"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5  is of type <class 'int'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 2.5                            #data type is changed to float\n",
        "print(a, \" is of type\", type(a))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "22pXgDbXUAah",
        "outputId": "db9eaa77-a5af-4eb5-ea08-19a9ce5bf0a4"
      },
      "execution_count": 25,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.5  is of type <class 'float'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 1 + 2j                          #data type is changed to complex number\n",
        "print(a, \" is complex number?\")\n",
        "print(isinstance(a, int))\n",
        "print(isinstance(1+2j, complex))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8GfDHTpQUCN7",
        "outputId": "4122e3e1-9e7c-472b-b1d5-4346dbe223f5"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1+2j)  is complex number?\n",
            "False\n",
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a=\"AAA\"\n",
        "b=\"AAA\"\n",
        "print(a is not b)"
      ],
      "metadata": {
        "id": "iGRmcgyxUD2g",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "df45102f-487d-4e96-8fee-5c4d84570a4c"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Python Input and Output**"
      ],
      "metadata": {
        "id": "mMtqtAtDHVle"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python Output**"
      ],
      "metadata": {
        "id": "LmdwZLydH2Le"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(\"Hello Coder\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HmUPA6rIE-9u",
        "outputId": "dba22c1e-448a-40b6-dde0-6879be24aef2"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Coder\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "print(\"The value of a is:\", a) #python 3\n",
        "print(\"The value of a is: \" + str(a)) #we concatenate two str using +\n",
        "print(f\"The value of a is: {a}\") #using f\n",
        "print(\"The value of a is: {}\".format(a)) #output formatting"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hJlDDLB3IBXU",
        "outputId": "646ec6ca-dc68-41b5-8b28-d711139b3960"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The value of a is: 10\n",
            "The value of a is: 10\n",
            "The value of a is: 10\n",
            "The value of a is: 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Output Formatting**"
      ],
      "metadata": {
        "id": "avjEXNb_I5k7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10; b = 20\n",
        "print(\"The value of a is {} and b is {}\".format(a, b)) #default output formatting\n",
        "\n",
        "print(\"The value of b is {1} and a is {0}\".format(a, b)) #specify position\n",
        "\n",
        "print(\"Hello {name}, {greetings}\".format(name=\"Samir\", greetings=\"Good Morning!\")) #use keyword arguments"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ejNfHt2TIs1A",
        "outputId": "a26c2938-8721-449e-dfb0-5ce88470964b"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "The value of a is 10 and b is 20\n",
            "The value of b is 20 and a is 10\n",
            "Hello Samir, Good Morning!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print('greetings from iNeuron')\n",
        "\n",
        "print(\"Good Evening\")\n",
        "\n",
        "print(\"\"\"Good\n",
        "Evening\"\"\")\n",
        "\n",
        "print(\"\"\"Good\n",
        "Evening\n",
        "from\n",
        "India\"\"\")"
      ],
      "metadata": {
        "id": "PQZ-mKtjGxtV",
        "outputId": "cac5c323-45c1-4e1b-9c7c-9d4ea94e3459",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "greetings from iNeuron\n",
            "Good Evening\n",
            "Good\n",
            "Evening\n",
            "Good\n",
            "Evening\n",
            "from\n",
            "India\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python Input**\n",
        "\n",
        "use **input()** function"
      ],
      "metadata": {
        "id": "WCKN0iCyKItT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number = input(\"Enter the value \")\n",
        "print(number)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H8ZZXrdAJOwJ",
        "outputId": "a8a89156-b0c5-42f3-8ea1-17a60dcfd654"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the value 10\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Question: What will be the output of this?"
      ],
      "metadata": {
        "id": "J5nOaV8J5iZZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = input(\"Enter the first number: \")\n",
        "b = input(\"Enter the second number: \")\n",
        "\n",
        "print(f\"The sum of a and b is {a+b}\")"
      ],
      "metadata": {
        "id": "xcDXPl6IK3G2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "bb25f259-632e-40a8-867a-8136d1b3d15a"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the first number: 11\n",
            "Enter the second number: 10\n",
            "The sum of a and b is 1110\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "This happpens bcz **input()** always take string. So to make the changes into integer we need to **type cast**2"
      ],
      "metadata": {
        "id": "NBgAqfAz5tdh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#type casting or type conversion"
      ],
      "metadata": {
        "id": "Xx6BkTNP5_rW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input(\"Enter the first number: \"))\n",
        "b = int(input(\"Enter the second number: \"))\n",
        "\n",
        "print(f\"The sum of a and b is {a+b}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VQerdyUa6EtP",
        "outputId": "5a1a00a1-352c-4e49-dc91-13671929ab04"
      },
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter the first number: 10\n",
            "Enter the second number: 11\n",
            "The sum of a and b is 21\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "fB4XOwhT6Eed"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Comments"
      ],
      "metadata": {
        "id": "vsTp5NutHJIl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# say hello to the students\n",
        "print(\"Hi Students\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hf18BeRmHO2o",
        "outputId": "c05545f7-a856-4edc-ca24-94fa31c1260b"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hi Students\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Multi line comments"
      ],
      "metadata": {
        "id": "o18UTSJZHUX1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"\n",
        "Say Hi\n",
        "To the students\n",
        "\"\"\"\n",
        "print('Hi Students')"
      ],
      "metadata": {
        "id": "TdSKtJZHHP4V",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d14566c8-789e-400b-fff9-22cec11a8d94"
      },
      "execution_count": 36,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hi Students\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Variables in python\n",
        "\n",
        "1. Variable names should start with alphabets\n",
        "\n",
        "2. Variable names should not contain any special characters like ^ % $ ! @ # ^ & * ( )\n",
        "\n",
        "3. Variable names can contain numbers but you can't start with numbers\n",
        "\n",
        "4. Its not a strict rule that you should not use variable names with a Captial letter. But its recommended to use small letters for the variables"
      ],
      "metadata": {
        "id": "5MjRzy82IDH4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "ten = 10\n",
        "ten_number = 10\n",
        "tenNumber = 10"
      ],
      "metadata": {
        "id": "tspd-j0RIETF"
      },
      "execution_count": 37,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "ten* = 10 # syntax error\n",
        "\n",
        "ten%number = 10 #syntax error"
      ],
      "metadata": {
        "id": "DP8P8OWAIYHE",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        },
        "outputId": "19b0bae3-435f-44f5-ccce-dae71b150c7f"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "invalid syntax (<ipython-input-39-5d701c5f1651>, line 1)",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-39-5d701c5f1651>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    ten* = 10 # syntax error\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ten10 = 10 #correct\n",
        "\n",
        "10ten = 10 #syntax error"
      ],
      "metadata": {
        "id": "XXwFQIxeIrrN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 108
        },
        "outputId": "09a9429b-7e09-4ac5-a6fb-1f504a2194e2"
      },
      "execution_count": 40,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "invalid decimal literal (<ipython-input-40-d31ddf0211f1>, line 3)",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-40-d31ddf0211f1>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m    10ten = 10 #syntax error\u001b[0m\n\u001b[0m     ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# NOTE\n",
        "__num = 10 # hidden variable\n",
        "\n",
        "_ = 10 # dummy variable"
      ],
      "metadata": {
        "id": "bQsVyhosI4u8"
      },
      "execution_count": 41,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Multi assignment of variables"
      ],
      "metadata": {
        "id": "D7KqOqSm3Sm4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b, c = 21, \"Radha\", True"
      ],
      "metadata": {
        "id": "a26K_KvE3dyN"
      },
      "execution_count": 42,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(type(a),type(b),type(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FSsCzaxO3w_w",
        "outputId": "0280bf8f-b0e3-492a-daa7-516c7987b338"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'> <class 'str'> <class 'bool'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x,y,z=10 # TypeError: cannot unpack non-iterable int object\n",
        "print(x,y,z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 162
        },
        "id": "AVaKUCfn4jVN",
        "outputId": "e68abc47-7f6c-4867-bd9a-4088a8d6f619"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "cannot unpack non-iterable int object",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-44-59065d6e46c5>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m10\u001b[0m \u001b[0;31m# TypeError: cannot unpack non-iterable int object\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0my\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: cannot unpack non-iterable int object"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x=y=z=10\n",
        "print(x,y,z)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r-aHtUuW46th",
        "outputId": "e0cde08d-df9f-47ab-dd02-bb0b4f28b037"
      },
      "execution_count": 45,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10 10 10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Operators**\n",
        "\n",
        "## **Operator Types**\n",
        "\n",
        "\n",
        "\n",
        "1.   Arithmetic operators [**+, -, \\*, /, %, //, \\****]\n",
        "2.   Comparision (Relational) operators [**>, <, ==, !=, >=, <=**]\n",
        "3.   Logical (Boolean) operators [**and, or, not**]\n",
        "4.   Bitwise operators [**&, |, ~, ^, >>, <<**]\n",
        "5.   Assignment operators [**=, +=, -=, \\*=, /=, //=, &=, |=, ^=, >>=, <<=, %=, **=**]\n",
        "6.   Special operators [**is, is not, in, not in**]\n",
        "\n"
      ],
      "metadata": {
        "id": "66p3zXbqLAb9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Arithmetic operators**\n",
        "\n",
        "+, -, \\*, /, %, //, \\** are arithmetic operators\n",
        "\n",
        "\n",
        "|Operation|Meaning|\n",
        "|:-:|:-:|\n",
        "| **+** |addition|\n",
        "| **-** |subtraction|\n",
        "| **\\*** |multiplication|\n",
        "| **/** |true division|\n",
        "| **//** |integer division|\n",
        "| **%** |the modulo operator|"
      ],
      "metadata": {
        "id": "g7-ubpQAMphQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "x, y, a, b = 10, 20, 21, 5\n",
        "print(x+y) #addition\n",
        "print(x-y) #subtraction\n",
        "print(x*y) #multiplication\n",
        "print(y/x) #division\n",
        "print(a%b) #modulo division\n",
        "print(a//x) #floor division\n",
        "print(x**b) #exponent like 10 to the power 5"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5PZcyBaoK_h1",
        "outputId": "93989e38-e5b1-4cb9-e66b-90305142411d"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "30\n",
            "-10\n",
            "200\n",
            "2.0\n",
            "1\n",
            "2\n",
            "100000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Comparision Operators**\n",
        "\n",
        "Used to **compare values** and it returns only **True or False** according to the condition\n",
        "\n",
        "\\>, <, ==, !=, >=, <= are comparision operators\n",
        "\n",
        "\n",
        "|Operation|Meaning|\n",
        "|:-:|:-:|\n",
        "| **>** |greater than|\n",
        "| **<** |less than|\n",
        "| **==** |equal equal|\n",
        "| **!=** |not equal|\n",
        "| **>=** |greater than equal|\n",
        "| **<=** |less than equal|"
      ],
      "metadata": {
        "id": "DfbuEr_LOK11"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = 10, 20\n",
        "print(a==b) # check with different operators"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wOX0uCV9OAaE",
        "outputId": "7a7a1c11-c12f-4f7e-cfac-63c587928283"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Logical Operators**\n",
        "\n",
        "Keywords | Meaning\n",
        "- | -\n",
        "not | unary negation\n",
        "and | conditional AND\n",
        "or | conditional OR"
      ],
      "metadata": {
        "id": "KDfv30kfPg5C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = True, False\n",
        "print(a and b) #check with or and not"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4f5GJ2eyPYLm",
        "outputId": "c8d76234-2a4d-42d2-efe8-05af2067a98f"
      },
      "execution_count": 48,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Bitwise Operators**\n",
        "\n",
        "Bitwise operators act on operands as if they were **string** or **binary digits**. It operates bit by bit.\n",
        "\n",
        "&, |, ~, ^, >>, <<\n",
        "\n",
        "\n",
        "|Operation|Meaning|\n",
        "|:-:|:-:|\n",
        "| **&** |bitwise add|\n",
        "| **|** |bitwise or|\n",
        "| **~*** |bitwise not|\n",
        "| **^** |bitwise XOR|\n",
        "| **>>** |bitwise rightshift|\n",
        "| **<<** |bitwise leftshift|\n",
        "\n",
        "[Notice Notes]"
      ],
      "metadata": {
        "id": "IpxRS4CGQQT1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a, b = 10, 4\n",
        "print(a & b) # Bitwise AND\n",
        "print(a | b) # Bitwise OR\n",
        "print(~a) # Bitwise NOT\n",
        "print(a ^ b) #Bitwise XOR\n",
        "print(a>>b) #Bitwise rightshift\n",
        "print(a<<b) #Bitwise leftshift"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yDDwqm3wP4Ms",
        "outputId": "9809afd3-6557-48d6-f668-b5f791a6ad93"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "14\n",
            "-11\n",
            "14\n",
            "0\n",
            "160\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Assignment Operators**\n",
        "\n",
        "=, +=, -=, \\*=, /=, //=, &=, |=, ^=, >>=, <<=, %=, **="
      ],
      "metadata": {
        "id": "vFNhMu8qVutd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 10\n",
        "a += 10 #check for other operators\n",
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "U1TxGSO9R8cI",
        "outputId": "2e47599c-8771-45b7-ca57-b27f39fe0c1a"
      },
      "execution_count": 50,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Special Operators**\n",
        "\n",
        "\n",
        "*   **Identity Operators**\n",
        "*   **Membership Operators**\n",
        "\n"
      ],
      "metadata": {
        "id": "Ff3P5-_CWyPX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Identity Operators**\n",
        "\n",
        "**is** and **is not** are the identity operators.\n",
        "\n",
        "They are used to check if two objects (or variables) are located on the same memory location/address\n",
        "\n",
        "\n",
        "Operator | uses | Meaning\n",
        "- | - | -\n",
        "is | A is B=> | return True if A and B points to the same object   \n",
        "is not | A is not B | returns True if A and B do not points to the same object\n",
        "== | A == B | A is equal to B\n",
        "!= | A != B | A is not equal to B\n",
        "\n",
        "When using `is` then we are also comparing memory location\n",
        "When using `is not` then we are also comparing memory location\n",
        "\n",
        "== and != is only checking value of the variables [Used more offently or frequently]"
      ],
      "metadata": {
        "id": "UVoKzScFXBim"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 5\n",
        "b = 5\n",
        "print(a is b) #same object so True\n",
        "print(a is not b) #same object but is not so False\n",
        "\n",
        "l1 = [1, 2, 3]\n",
        "l2 = [1, 2, 3]\n",
        "print(l1 is l2) #not same address of the objects"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MXgFJCRkWhOV",
        "outputId": "61c8e21b-0655-4179-b741-4e80b3a807af"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "s1 = \"AA\"\n",
        "s2 = \"AA\"\n",
        "print(s1 is s2)\n",
        "print(s1 is not s2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V2ZE8fM6X1YJ",
        "outputId": "aaf29e25-4439-44b2-a6ce-38a508a2c15b"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Membership Operators**\n",
        "\n",
        "**in** and **not in** are the membership operators.\n",
        "\n",
        "They are used to test whether a value or variable is found in sequence (string, list, tuple, set and dictionary)"
      ],
      "metadata": {
        "id": "bx72jX_3YrY7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [1, 2, 3, 4]\n",
        "print(1 in lst) #check 1 is present in the list or not\n",
        "print(7 in lst)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ibxQP28yYPf8",
        "outputId": "cc9579d3-114b-4524-bfc3-f59442100943"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dic = {1: \"a\", 2: \"b\"} #we can only check key of the key-value pairs in dictionary\n",
        "print(1 in dic)\n",
        "print(\"a\" in dic)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "obc62YXyZqOf",
        "outputId": "0a72bfbb-f2ec-440a-9c6e-c26ad29d5fe1"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n",
            "False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Fundamental data types"
      ],
      "metadata": {
        "id": "HhbS5rOyJla2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## integers"
      ],
      "metadata": {
        "id": "sDxkSYIRQTGk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 7"
      ],
      "metadata": {
        "id": "0UGwN43gQJyo"
      },
      "execution_count": 55,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rb2hmXqaLEVV",
        "outputId": "84d43458-d00b-4573-b158-6d2c312601d5"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## floats - numbers containing decimal numbers"
      ],
      "metadata": {
        "id": "moDdE9RKQvJh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pi = 3.14"
      ],
      "metadata": {
        "id": "fjrPWQWaQtGR"
      },
      "execution_count": 57,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(pi)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QnRM62G1Q5qH",
        "outputId": "84011a82-ee0c-46ad-994a-a685f75bd24e"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2.0\n",
        "type(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8YkR2N34RFZA",
        "outputId": "4955696d-1e99-410f-a8dc-f920059fdfbe"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x = 2\n",
        "type(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lEcy6lIrKFQz",
        "outputId": "4febaf80-b37a-40df-f760-42eebcac4362"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "int"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Complex numbers"
      ],
      "metadata": {
        "id": "djQ1C4UqRV2w"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 2+3j\n",
        "a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b8x5LehaRVou",
        "outputId": "175f95dc-36a7-4511-bafe-095076accee4"
      },
      "execution_count": 61,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(2+3j)"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zvWgfhAQRDN3",
        "outputId": "af8bb3d0-8f65-42fa-b8eb-b01c06533d44"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "complex"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a.real"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DcnVBA3JSJ3-",
        "outputId": "f6f1b3cc-e8fd-4e7b-faa1-d750985b22f9"
      },
      "execution_count": 63,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2.0"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a.imag"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6lIOZ_97SQjG",
        "outputId": "314fbb66-e001-4ca7-dae3-c2951f8cd246"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "3.0"
            ]
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Dynamic typing"
      ],
      "metadata": {
        "id": "Rr_cLPPjSa1g"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 22\n",
        "type(a)\n",
        "a = 22.2\n",
        "type(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kZyFgLlHTXo5",
        "outputId": "671955c4-5e8b-42a3-b4e6-7b40775b5959"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "float"
            ]
          },
          "metadata": {},
          "execution_count": 65
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 22\n",
        "print(type(a))\n",
        "a = 22.2\n",
        "print(type(a))\n",
        "a = \"Sunny\"\n",
        "print(type(a))\n",
        "a = 'Sunny'\n",
        "print(type(a))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AGSSVBi2SUWO",
        "outputId": "a3c1a1d7-f550-43c3-cce6-bfa1285ba2d7"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<class 'int'>\n",
            "<class 'float'>\n",
            "<class 'str'>\n",
            "<class 'str'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-VTqRrGzSyvG",
        "outputId": "34607284-ea22-47e1-f25e-9fab3c2454fb"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sunny\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Strong typing"
      ],
      "metadata": {
        "id": "K_ptvOIJTp1c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\"Day \" + 1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 144
        },
        "id": "eXPeDDfeTpX8",
        "outputId": "8170d8ae-d7b5-4cfa-bf34-bfe2a7e34ce2"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "can only concatenate str (not \"int\") to str",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-68-f9dbf96c2523>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"Day \"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "22.2 + 1"
      ],
      "metadata": {
        "id": "WwpsAL-aUmtV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "\"Day \" + \"1\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "twRVQPK2TAe-",
        "outputId": "022cfa08-b9a9-4317-c1c2-823ce8e7cd18"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Day 1'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "22 + 22"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mFfI3DenUTK9",
        "outputId": "41c3f8bc-9634-44e1-bfbf-5cabd9487b32"
      },
      "execution_count": 70,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "44"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"22\" + \"22\""
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 37
        },
        "id": "IdkzDzGwUVqU",
        "outputId": "0cd6f693-0fe0-46a7-e538-22eeb96b806a"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2222'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"22\" + 22"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 144
        },
        "id": "-mvi-tKRT-eM",
        "outputId": "26346b5e-4dc1-4344-bb26-1c95cb45aacf"
      },
      "execution_count": 72,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "can only concatenate str (not \"int\") to str",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-72-2e2b19d89d15>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;34m\"22\"\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m22\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "'22' + \"22\""
      ],
      "metadata": {
        "id": "rTOAn0yJUf_h"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Control Flow**\n",
        "\n",
        "The **if**.....**elif**.....**else** statement is used in Python for decision making.\n",
        "\n",
        "**0, None and False** is considered as False\n",
        "\n",
        "Except these three all are True\n",
        "\n",
        "Eg: -1, 11, \"AA\", etc"
      ],
      "metadata": {
        "id": "ZCryJoVpN2gX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = 10\n",
        "if num == 10:\n",
        "  print(\"Hi\")\n",
        "else:\n",
        "  print(\"Hoo\")"
      ],
      "metadata": {
        "id": "OyhJnQ-WaBZr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# None used\n",
        "num = 10\n",
        "if None:\n",
        "  print(\"Hi\")\n",
        "else:\n",
        "  print(\"Hoo\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1RkYNRkmQiE-",
        "outputId": "bc782f40-dcbc-4dbc-a591-1428cf29a518"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hoo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# 0 used\n",
        "num = 10\n",
        "if num - 10:\n",
        "  print(\"Hi\")\n",
        "else:\n",
        "  print(\"Hoo\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UhFsKnBvQm_Y",
        "outputId": "dcc44c75-6ecf-4fe2-de9c-3178a42685c3"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hoo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# False used\n",
        "num = 10\n",
        "if num != 10:\n",
        "  print(\"Hi\")\n",
        "else:\n",
        "  print(\"Hoo\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M74m94zpQrQd",
        "outputId": "182687ba-467f-432d-f478-9fbf94ce3a86"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hoo\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## if-elif-else Example"
      ],
      "metadata": {
        "id": "NyskEKPbRBoG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = 10\n",
        "if num >= 10:\n",
        "  print(\"Hi\")\n",
        "elif num == 0:\n",
        "  print(\"Hey\")\n",
        "else:\n",
        "  print(\"Hoo\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "P_9HObBEQ415",
        "outputId": "503aef80-fb22-4dbf-85fe-a9d61e70abf5"
      },
      "execution_count": 76,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hi\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "attendance = 70\n",
        "assignment_submitted = 40\n",
        "sports_player = True\n",
        "\n",
        "print(f\"attendence criteria met? : {attendance >= 75}\")\n",
        "print(f\"assignment criteria met? : {assignment_submitted >= 70}\")\n",
        "print(f\"sports criteria met? : {sports_player}\")\n",
        "\n",
        "if attendance >= 75 and assignment_submitted >= 70:\n",
        "    if sports_player:\n",
        "        print(\"The student is eligible to appear in final exam\")\n",
        "    else:\n",
        "        print(\"The student is eligible to appear in final exam\")\n",
        "else:\n",
        "    print(\"The student is not eligible\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V8TxkKT5GWeY",
        "outputId": "b2b39f02-de63-4369-8772-96c6f3534a36"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "attendence criteria met? : False\n",
            "assignment criteria met? : False\n",
            "sports criteria met? : True\n",
            "The student is not eligible\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Single line if else"
      ],
      "metadata": {
        "id": "3OmCgwZGFiXN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Recommended approach\n",
        "# Its more readable and clean\n",
        "\n",
        "val = float(input(\"Enter a number\"))\n",
        "\n",
        "if val > 99:\n",
        "  print(\"YES\")\n",
        "else:\n",
        "  print(\"NO\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kOH2_jhBPw9K",
        "outputId": "ce190ecf-e171-42cf-fe18-e70b79e4b967"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number1\n",
            "NO\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# only good for competitive programming\n",
        "val = float(input(\"Enter a number: \"))\n",
        "\n",
        "print(\"YES\" if val > 99 else \"NO\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yp3gjIkaQk0B",
        "outputId": "9ecb5a4f-d963-45fe-9001-3fcb8a53336b"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a number: 100\n",
            "YES\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **while loop with else**\n",
        "\n",
        "Same as that of *for loop*, we can have an optional else block with while loop as well.\n",
        "\n",
        "The else part is executed if the condition in the while loop evaluates to False. The while loop can be terminated with a **break** statement.\n",
        "\n",
        "In such case, the else part is ignored. Hence, a while loop's else part runs if no break occurs and the condition is False."
      ],
      "metadata": {
        "id": "Fpy_gD02STT1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "num = [1,2,3]\n",
        "index = 0\n",
        "\n",
        "while index < len(num):\n",
        "  print(num[index])\n",
        "  index +=1 #pre-increment or post-increment is not there in Python\n",
        "else:\n",
        "  print(\"No item left in the list\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6rTy4_fGRUWb",
        "outputId": "83228510-2f39-437e-92d1-8e90f6c88fa7"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "No item left in the list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python for Loop**\n",
        "\n",
        "The for loop in Python is used to iterate over a sequence (list, tuple, string) or other iterable objects.\n",
        "\n",
        "Iterating over a sequence is called **traversal**."
      ],
      "metadata": {
        "id": "576BDcftVo64"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Syntax**\n",
        "\n",
        "```\n",
        "for element in sequence:\n",
        "    body of for\n",
        "```\n",
        "\n",
        "Here, element is the variable that makes the value of the item inside the sequence on each iteration.\n",
        "\n",
        "Loop continues until we reach the last item in the sequence.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "qht5gonHxqkL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [10, 20, 30, 40, 50]\n",
        "\n",
        "product = 1\n",
        "\n",
        "for item in lst:\n",
        "  product *= item\n",
        "\n",
        "print(f\"Product is: {product}\")"
      ],
      "metadata": {
        "id": "xnc4a7rzTyp6",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b45fc6d6-8d07-4091-b24f-c089f0fcdfa6"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Product is: 12000000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **range(function)**\n",
        "\n",
        "We can generate a sequence of numbers using range() function.\n",
        "\n",
        "eg. range(10) will generate numbers from 0 to 9 (10 numbers)\n",
        "\n",
        "range() function has the **start, stop,** and **step size** as **range(start, stop, step size)**. By default step size is 1 if not provided.\n",
        "\n",
        "This function does not store all the values in memory, it would be inefficient. So it remembers the start, stop, step size and generates the next number on the go."
      ],
      "metadata": {
        "id": "DmEdbDjRzh7u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for i in range(1, 20, 2): #exactly same as for(i=1; i<20; i+=2) in C language\n",
        "  print(i)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e_deFhOdzfOV",
        "outputId": "f6b1b15b-f52b-49b8-8073-c0d8cf1cd42c"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "7\n",
            "9\n",
            "11\n",
            "13\n",
            "15\n",
            "17\n",
            "19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "lst = [\"Samir\", \"Samar\", \"Safar\", \"Sahil\"]\n",
        "\n",
        "for item in range(len(lst)):\n",
        "  print(lst[item])\n",
        "#both give same output 1st using range() func and 2nd using simple way\n",
        "for item in lst:\n",
        "  print(item)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XebXxrwkGy0J",
        "outputId": "9af524af-1550-4566-b20f-f407f3bb292b"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Samir\n",
            "Samar\n",
            "Safar\n",
            "Sahil\n",
            "Samir\n",
            "Samar\n",
            "Safar\n",
            "Sahil\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **for loop with else**\n",
        "\n",
        "A for loop can have an optional else block as well. The else part is executed if the items in the sequence used in for loop exhausts.\n",
        "\n",
        "break statement can be used to stop a for loop.\n",
        "\n",
        "Hence, a for loop's else part runs if no break occurs."
      ],
      "metadata": {
        "id": "WZqA5G4IIXuX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number = [1, 2, 3]\n",
        "\n",
        "for item in number:\n",
        "  print(item)\n",
        "else:\n",
        "  print(\"No item left in the list\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MtAjVNTfICt4",
        "outputId": "00f72e7b-2b58-45ee-d150-d86a856dae7a"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "No item left in the list\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Python *break* and *continue* Statements**\n",
        "\n"
      ],
      "metadata": {
        "id": "LzphQr80J9Vs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "number = [1, 2, 3, 4]\n",
        "\n",
        "for num in number:\n",
        "  if num == 4:\n",
        "    break\n",
        "  print(num)\n",
        "else:\n",
        "    print(\"in the else-block\")\n",
        "print(\"Outside of for loop\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6R0-71ybJa-B",
        "outputId": "abac8646-d0c3-48ea-be96-480cfee794cf"
      },
      "execution_count": 87,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "Outside of for loop\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "number = [1, 2, 3, 4, 5]\n",
        "\n",
        "for num in number:\n",
        "  if num % 2 == 0:\n",
        "    continue\n",
        "  print(num)\n",
        "else:\n",
        "    print(\"in the else-block\")"
      ],
      "metadata": {
        "id": "tHU9argNLcGg",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "79856262-98dc-450b-97bf-17bbad3f8e74"
      },
      "execution_count": 88,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "3\n",
            "5\n",
            "in the else-block\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Memory block"
      ],
      "metadata": {
        "id": "SDkFgwh1Ln0W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 22\n",
        "b = 34\n",
        "c = 22"
      ],
      "metadata": {
        "id": "zovkAE5uUX7C"
      },
      "execution_count": 89,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "id(a) # memory address"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iB_Yf-XwfskJ",
        "outputId": "e205dc56-e957-4ea0-e041-ed7da3fde507"
      },
      "execution_count": 90,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "135442644648848"
            ]
          },
          "metadata": {},
          "execution_count": 90
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id(b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2QhbJnLbfvWp",
        "outputId": "35afdc90-a205-4ba2-fa81-8e55ea302c6b"
      },
      "execution_count": 91,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "135442644649232"
            ]
          },
          "metadata": {},
          "execution_count": 91
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id(c)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mLxiOUf_fyAa",
        "outputId": "82e5480d-b6f6-48dc-e937-9583b1622b33"
      },
      "execution_count": 92,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "135442644648848"
            ]
          },
          "metadata": {},
          "execution_count": 92
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "c = 12 + a\n"
      ],
      "metadata": {
        "id": "V_ebhqVQf02g"
      },
      "execution_count": 93,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "id(c) #address got change"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FRDxDQ7GgIfR",
        "outputId": "7e1c0e57-3ec4-4e21-8e0f-c6a2489568d9"
      },
      "execution_count": 94,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "135442644649232"
            ]
          },
          "metadata": {},
          "execution_count": 94
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 22\n",
        "id(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fNd2dcHmgJtQ",
        "outputId": "6eddc659-4063-4925-e78d-0be2d6ace7c5"
      },
      "execution_count": 95,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "135442644648848"
            ]
          },
          "metadata": {},
          "execution_count": 95
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 99\n",
        "id(a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FWStSij2gSep",
        "outputId": "a8aa10c3-cf6b-4948-8fad-0f494103f6b9"
      },
      "execution_count": 96,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "135442644651312"
            ]
          },
          "metadata": {},
          "execution_count": 96
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NOTE**: Memory is assigned to the value of the variable passed not the variable name."
      ],
      "metadata": {
        "id": "2JUt0VhygXaE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = 22\n",
        "b = 34\n",
        "c = 22\n",
        "\n",
        "print(id(a), id(b), id(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M8M8grQHgU_R",
        "outputId": "390f44fa-4b79-4f2e-9cb5-23fdbacb46c5"
      },
      "execution_count": 97,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "135442644648848 135442644649232 135442644648848\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = \"Sunny\"\n",
        "b = 34\n",
        "c = \"Sunny\"\n",
        "\n",
        "print(id(a), id(b), id(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "h2Oo_lIGgiZZ",
        "outputId": "2dd45020-02ec-44e0-d5e1-3e5826cd4b61"
      },
      "execution_count": 98,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "135441315933296 135442644649232 135441315933296\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = \"S\"\n",
        "b = 34\n",
        "c = \"S\"\n",
        "\n",
        "print(id(a), id(b), id(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dudmdbuAg9kh",
        "outputId": "0300182c-4393-43fb-96b1-1acad389af74"
      },
      "execution_count": 99,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "135442643524080 135442644649232 135442643524080\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = 22\n",
        "b = 34\n",
        "c = 22.0\n",
        "\n",
        "print(id(a), id(b), id(c))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JQKAen5UhROg",
        "outputId": "f2483379-fd17-410f-9a19-150e124054e3"
      },
      "execution_count": 100,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "135442644648848 135442644649232 135441320282096\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# iNeuron Assignment\n",
        "\n",
        "https://colab.research.google.com/drive/1MeY4jyYte81PTIcfy3MRg6pEQ8dEjzjS"
      ],
      "metadata": {
        "id": "0cGj6BElMbvZ"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "A_ufBbdvMmqI"
      },
      "execution_count": 100,
      "outputs": []
    }
  ]
}