BasicsOfPython.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/JaimanSingh/JSGBasicsOfPython/blob/main/BasicsOfPython.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NgayMd7cK3U6"
      },
      "source": [
        "---\n",
        "# **Learn Python in 2 hr**\n",
        "---\n",
        "\n",
        "### There are 16 programs to explain the various concepts in python programming such as:\n",
        "\n",
        "- Syntex, \n",
        "- Loop, \n",
        "- if-else, \n",
        "- Data Structures, \n",
        "- Strings, \n",
        "- File Handaling, \n",
        "- Exception Handaling, \n",
        "- Random Numbers, \n",
        "- Command Line Argunment\n",
        "- Use of Libraries\n",
        "\n",
        "---\n",
        "### **Self learning resource**\n",
        "Tutorial on Python (Byte of Python) **<a href=\"https://python.swaroopch.com/\"> Click Here</a>** \n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "# **1 Hello World**\n",
        "---\n",
        "**Learning:** How to print and run python program"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4JFo1WM8ZON",
        "outputId": "33f5ba9a-ed5c-4856-aa53-10149c98acbc"
      },
      "source": [
        "print (\"Hello Thapar Summer School\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello Thapar Summer School\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oBs7uRGQPn3J"
      },
      "source": [
        "**Assingment 1.1**: WAP to print your name three times"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EOp1wf9hlyC2"
      },
      "source": [
        "---\n",
        "# **2 Add numbers and Concatinate strings**\n",
        "**Learning:** How to declare variable, add, concatenate and print the result.\n",
        "\n",
        "---\n",
        "### **2.1 Add two numbers**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sk_6l4N6l-vH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "432fa533-da09-425d-c3ea-3eee91e3c824"
      },
      "source": [
        "a = 100\t\t\t\t\n",
        "b = 220\n",
        "c = a + b       # Add two numbers\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100  +  220  -->  320\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a,b,c #can see or realise the intermediate results as well "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y_0h4sSaFY-R",
        "outputId": "293bc303-cbd3-4789-8883-2bcb5ef45968"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(100, 220, 320)"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iGXiAQqI4AvC"
      },
      "source": [
        "\n",
        "---\n",
        "### **2.2 Concatinate two strings**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "o-kCSsW7lxNF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8092de8-6e05-4288-e92b-f591958ec5d7"
      },
      "source": [
        "a = \"Jaiman \"\n",
        "b = \"Singh Guliani\"\n",
        "c = a + b\t\t# Concatinate two strings\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jaiman   +  Singh Guliani  -->  Jaiman Singh Guliani\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DOZfIRp04ZvM"
      },
      "source": [
        "\n",
        "---\n",
        "### **2.3 Concatinate string with number**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BuJp15Fd4ZvS",
        "outputId": "e9333a88-a03f-42c4-c316-a70554244461"
      },
      "source": [
        "a = \"Jaiman Singh\"\n",
        "b = 100\n",
        "c = a + str(b)\t#convert the no. to string \n",
        "\t# Concatinate string with number\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Jaiman Singh  +  100  -->  Jaiman Singh100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hA7PLi-m4V8s"
      },
      "source": [
        "**Assingment 2.1**: WAP to add three numbers and print the result.\n",
        "\n",
        "**Assingment 2.2**: WAP to concatinate three strings and print the result."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z1uDaVtK5tX_"
      },
      "source": [
        "---\n",
        "# **3 Input from user**\n",
        "**Learning:** How to take input from user\n",
        "\n",
        "---\n",
        "### **3.1 Input two strings from user and concatinate them**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "aDsOjDWs5tYB",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a220dc2e-d487-492a-94d1-3a173cbb248a"
      },
      "source": [
        "a = input(\"Enter First String: \")\n",
        "b = input(\"Enter Second String: \") #NO Neeed to mention the data type, it automatically detects. \n",
        "c = a + b\t\t# concatinate two strings\n",
        "print  (a, \" + \", b, \"      --> \", c)\n",
        "#input funcn will convert everything to string therefore doesnt add the numbers.  \n",
        "# Run the program with (1) Two strings and (2) Two numbers"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter First String: 00\n",
            "Enter Second String: 01\n",
            "00  +  01       -->  0001\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4CAypM6A5Jmx"
      },
      "source": [
        "---\n",
        "### **3.2 Input two numbers from user and add them**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "EzB8G_a95d4X",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 249
        },
        "outputId": "06a284d9-d066-4ba5-97d0-9bf78ce1e16d"
      },
      "source": [
        "a = int(input(\"Enter First No: \"))\n",
        "b = int(input(\"Enter Second No: \"))\n",
        "c = a + b\n",
        "print (a, \" + \", b, \" --> \", c)\n",
        "#adds the number. due to int. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter First No: dddd\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-16-15c92e9f0bf9>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Enter First No: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Enter Second No: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\" + \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m\" --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mc\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m#adds the number. due to int.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'dddd'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VCXIhMtP-puV"
      },
      "source": [
        "---\n",
        "# **4 Loop**\n",
        "**Learning:** Learn various loops.\n",
        "\n",
        "---\n",
        "### **4.1 While Loop**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ESdyGeh9-puX",
        "outputId": "3319e08c-3c49-4364-8a46-1958c5899812"
      },
      "source": [
        "i=1\n",
        "while i <= 10:\n",
        "\tprint (2* i) #for printing the table of 2. \n",
        "\ti = i+1 #incremenet the variable after printing. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rd_F8ksi-puZ"
      },
      "source": [
        "---\n",
        "### **4.2 Range Function**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "range(10,20) #therefore in order to get the desired output of sequences, we need to convert it to list. \n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9SG-nhQaJBDf",
        "outputId": "4b3c0c7b-2a8b-4c2b-e410-efd1cb0579d3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "range(10, 20)"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_U_Of2tu-puZ",
        "outputId": "ba38a996-4414-4459-dbf7-79e6c2545063"
      },
      "source": [
        "print (\"range(10)        --> \", list(range(10))) #one less than the upper limit, so if you want till 10 then write till 11 \n",
        " #range function generates sequences. \n",
        "print (\"range(10,20)     --> \", list(range(10,20)))\n",
        "print (\"range(0,21,2)    --> \", list(range(2,21,2))) #writing 21 also included 20. \n",
        "print (\"range(-10,-20,2) --> \", list(range(-10,-20,2))) #last one is the multiplier. \n",
        "print (\"range(-10,-20,-2)--> \", list(range(-10,-20,-2)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "range(10)        -->  [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "range(10,20)     -->  [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
            "range(0,21,2)    -->  [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
            "range(-10,-20,2) -->  []\n",
            "range(-10,-20,-2)-->  [-10, -12, -14, -16, -18]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xny977qN_f_f"
      },
      "source": [
        "---\n",
        "### **4.3 For loop**\n",
        "---\n",
        "### **4.3.1 For loop - Version 1**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JXsAol2L_f_h",
        "outputId": "155bd0c9-4ae7-40f8-eb08-8711badb7459"
      },
      "source": [
        "for i in range(0,11): #i is the variable name. can even take as a,b,c,etc. \n",
        "\tprint (2*i) #range generates the sequence and through i we are taking all the values. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xk5XRRV8_gMq"
      },
      "source": [
        "---\n",
        "### **4.3.2 For loop - Version 2**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "w8scyduB_gMr",
        "outputId": "d2a8dcc2-8c6e-417b-9a35-7529325fa600"
      },
      "source": [
        "for i in range(2,21,2): #starting no. is included. \n",
        "\tprint (i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n",
            "20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_NNQrHRXAZ8a"
      },
      "source": [
        "---\n",
        "### **4.3.3 For loop - Version 3**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "18Im8yX7AZ8a",
        "outputId": "6e22d0b8-d804-4f31-fb06-779031beb51b"
      },
      "source": [
        "for i in range(0,-10,-1):\n",
        "\tprint (i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "-1\n",
            "-2\n",
            "-3\n",
            "-4\n",
            "-5\n",
            "-6\n",
            "-7\n",
            "-8\n",
            "-9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Meq_Hv4RAaHS"
      },
      "source": [
        "---\n",
        "### **4.4 Print table of 5**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EvPN2wvOAaHT",
        "outputId": "d7835956-c8db-47a2-d27a-ee15d0e15b67"
      },
      "source": [
        "for i in range(1,11):\n",
        "\t #in for loop, can use range like this or can even out list() in front of it wouldnt make a differecne. both give the same output. as for loop can access it. \n",
        " \tprint (5,\" * \", i , \" = \", i * 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5  *  1  =  5\n",
            "5  *  2  =  10\n",
            "5  *  3  =  15\n",
            "5  *  4  =  20\n",
            "5  *  5  =  25\n",
            "5  *  6  =  30\n",
            "5  *  7  =  35\n",
            "5  *  8  =  40\n",
            "5  *  9  =  45\n",
            "5  *  10  =  50\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#ask the user to input a number and print its table \n",
        "a = int(input(\"enter the no. whose table you want to print:\"))\n",
        "for i in range(1,11):\n",
        "\tprint (a,\" * \", i , \" = \", i * a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GS5D9GPzKLA3",
        "outputId": "3385640d-2f37-4cb4-fde6-c9a52b93046e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter the no. whose table you want to print:19\n",
            "19  *  1  =  19\n",
            "19  *  2  =  38\n",
            "19  *  3  =  57\n",
            "19  *  4  =  76\n",
            "19  *  5  =  95\n",
            "19  *  6  =  114\n",
            "19  *  7  =  133\n",
            "19  *  8  =  152\n",
            "19  *  9  =  171\n",
            "19  *  10  =  190\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#removing int concatnates it. \n",
        "a = input(\"enter the no. whose table you want to print:\")\n",
        "for i in range(1,11):\n",
        "\tprint (a,\" * \", i , \" = \", i * a)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TRwVhkxBLZkX",
        "outputId": "8eeb2545-4cb8-4d72-a417-2ba994fd8f9c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter the no. whose table you want to print:23\n",
            "23  *  1  =  23\n",
            "23  *  2  =  2323\n",
            "23  *  3  =  232323\n",
            "23  *  4  =  23232323\n",
            "23  *  5  =  2323232323\n",
            "23  *  6  =  232323232323\n",
            "23  *  7  =  23232323232323\n",
            "23  *  8  =  2323232323232323\n",
            "23  *  9  =  232323232323232323\n",
            "23  *  10  =  23232323232323232323\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#while loop \n",
        "a = int(input(\"enter the no. whose table you want to print:\"))\n",
        "i=1\n",
        "while i <=10:\n",
        "  print (a,\" * \", i , \" = \", i * a)\n",
        "  i=i+1"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O-QFEI-8K3-Y",
        "outputId": "873e25c5-5223-4c48-d516-6f2162b64f87"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "enter the no. whose table you want to print:12\n",
            "12  *  1  =  12\n",
            "12  *  2  =  24\n",
            "12  *  3  =  36\n",
            "12  *  4  =  48\n",
            "12  *  5  =  60\n",
            "12  *  6  =  72\n",
            "12  *  7  =  84\n",
            "12  *  8  =  96\n",
            "12  *  9  =  108\n",
            "12  *  10  =  120\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aZErlsXYAaPu"
      },
      "source": [
        "---\n",
        "### **4.5 Sum all numbers from 1 to 10**\n",
        "---\n",
        "### **4.5.1 Version 1**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ddCg6qxQAaPv",
        "outputId": "951d24b9-cf23-416e-c27a-993dcdaffce6"
      },
      "source": [
        "s=0\n",
        "for i in range(1,11):\n",
        "\ts=s+i\n",
        "print (\"Sum is --> \",s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum is -->  55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UucWFIAt_gV_"
      },
      "source": [
        "---\n",
        "### **4.5.2 Version 2**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cD3y-1lM_gWB",
        "outputId": "3d191b44-d1c4-472b-cefe-df8859189472"
      },
      "source": [
        "print (\"Sum is --> \", sum(range(1,11)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum is -->  55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "sum = 100\n",
        "print(sum)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uKDle5POMjLy",
        "outputId": "7cc00187-7eee-4b2c-9166-b8005bdccd97"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del sum\n",
        "print (\"Sum is --> \", sum(range(1,11))) #because above sum is initialised to int. therefore error. therefore delelte the variable name. "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IbPRqXXlMp_I",
        "outputId": "10ec337a-f99f-4eb8-db36-228809fd0cfa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum is -->  55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "int = 200\n",
        "print(int)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ennclb6wNQM-",
        "outputId": "492b543c-3250-4402-d705-989282c32917"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "200\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "del int \n",
        "x = int('100')\n",
        "print(x)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C5c2HXjnNUmC",
        "outputId": "35d54965-3837-461c-dd64-62e9cf003624"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DnUEH0WQ-pua"
      },
      "source": [
        "**Assingment 4.1:** WAP to print the table of 7, 9.\n",
        "\n",
        "**Assingment 4.2:** WAP to print the table of n and n is given by user.\n",
        "\n",
        "**Assingment 4.3:** WAP to add all the numbers from 1 to n and n is given by user."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6eraxEhZCJRU"
      },
      "source": [
        "---\n",
        "# **5 If-Else - Conditional Checking**\n",
        "**Learning:** if-else Condition\n",
        "\n",
        "---\n",
        "### **5.1 Input two numbers from user and compare them**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "63a8CKQ9CJRV",
        "outputId": "689d75d3-a726-44d5-e180-cd9320603ce2"
      },
      "source": [
        "a = int(input(\"Enter First No: \"))\n",
        "b = int(input(\"Enter Second No: \"))\n",
        "if  a > b: \n",
        "\tprint (a,\" > \",b)\n",
        "else:\n",
        "\tprint (a,\" < \",b)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter First No: 23\n",
            "Enter Second No: 34\n",
            "23  <  34\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "a = int(input(\"Enter First No: \"))\n",
        "b = int(input(\"Enter Second No: \"))\n",
        "if  a > b: \n",
        "\tprint (a,\" > \",b) #can even have multiple statements within a if loop\n",
        "\n",
        "else:\n",
        "\tprint (a,\" < \",b)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7-nyj0LfN6_d",
        "outputId": "603e2888-e0fe-4edd-a265-a4776a51d992"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter First No: 23\n",
            "Enter Second No: 34\n",
            "23  <  34\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zPayD7lwCJRW"
      },
      "source": [
        "---\n",
        "### **5.2 Check weather a number is odd or even**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I2ohfxlRCJRW",
        "outputId": "baf8e3a3-06ca-4004-e28f-db4c1bbe1a0b"
      },
      "source": [
        "n = int(input(\"Enter a No: \"))\n",
        "if  n % 2 == 0: \n",
        "\tprint (n,\" is even\")\n",
        "else:\n",
        "\tprint (n,\" is odd\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a No: 34\n",
            "34  is even\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "861tynfFCJRX"
      },
      "source": [
        "---\n",
        "### **5.3 Check weather a number is prime of not**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q37Sy99JCJRZ",
        "outputId": "1cdc77c2-7ab7-4a48-cfec-016812da024f"
      },
      "source": [
        "n = int(input(\"Enter a No: \"))\n",
        "f=0\n",
        "for i in range(2, n//2 + 1): #we take // and not / as we want the second parameter of the range function as an integer. with a / it becomes a real number. \n",
        "\tif  n % i == 0: \n",
        "\t\tf=1\n",
        "\t\tbreak\n",
        "\n",
        "if f==0:\n",
        "\tprint (\"Prime\")\n",
        "else:\n",
        "\tprint (\"Not Prime\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter a No: 7\n",
            "Prime\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "n = int(51.5)\n",
        "n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4w5r7xaQGKQ",
        "outputId": "f58c5a95-94c5-4899-c5bf-699d408a6b76"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "51"
            ]
          },
          "metadata": {},
          "execution_count": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YCf466JQCJRa"
      },
      "source": [
        "---\n",
        "### **5.4 Conditional Checking - Compare strings**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YSTLUkUVCJRb",
        "outputId": "134692f2-23a2-4ff9-9146-57a23b3d1d6d"
      },
      "source": [
        "a = input(\"Enter First String : \")\n",
        "b = input(\"Enter Second String: \")\n",
        "\n",
        "if a == b: \n",
        "\tprint (\"a == b\")\n",
        "elif a >= b: \n",
        "\tprint (\"a > b\")\n",
        "else:\n",
        "\tprint (\"a < b\") #this is done with comparison of ASCII values. value of d > D"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter First String : india \n",
            "Enter Second String: InDia\n",
            "a > b\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bPPQtf1ACJRg"
      },
      "source": [
        "**Assingment 5.1:** WAP to find max amoung three numbers and input from user. [Try max() function]\n",
        "\n",
        "**Assingment 5.2:** WAP to add all numbers divisible by 7 and 9 from 1 to n and n is given by the user.\n",
        "\n",
        "**Assingment 5.3:** WAP to add all prime numbers from 1 to n and n is given by the user.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_dC1CuVnDipZ"
      },
      "source": [
        "---\n",
        "# **6 Functions**\n",
        "**Learning:** How to declare and call function\n",
        "\n",
        "---\n",
        "### **6.1 Add two numbers**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Vw-ZYlDDipb",
        "outputId": "7adb0a45-6035-4592-ecf5-f9f87d03251c"
      },
      "source": [
        "def Add(a,b):\n",
        "\tc=a+b\n",
        "\treturn c\n",
        "\n",
        "print (\"Add(10,20) -->\", Add(10,20))\n",
        "print (\"Add(20,50) -->\", Add(20,50)) \n",
        "print (\"Add(80,200) -->\", Add(80,200)) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Add(10,20) --> 30\n",
            "Add(20,50) --> 70\n",
            "Add(80,200) --> 280\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ygKAg2QjDipc"
      },
      "source": [
        "---\n",
        "### **6.2 Prime number**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sg8feM_YDipc",
        "outputId": "215f69b0-58a7-45f5-ecab-72c01b189c1f"
      },
      "source": [
        "def IsPrime(n):\n",
        "\tfor i in range(2, n//2 + 1):\n",
        "\t\tif n%i==0:\n",
        "\t\t\treturn 0\n",
        "\treturn 1 #0 for not prime and 1 for prime. \n",
        "\n",
        "print (\"IsPrime(20)  --> \", IsPrime(20))\n",
        "print (\"IsPrime(23)  --> \", IsPrime(23))\n",
        "print (\"IsPrime(200) --> \", IsPrime(200))\n",
        "print (\"IsPrime(37)  --> \", IsPrime(37))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "IsPrime(20)  -->  0\n",
            "IsPrime(23)  -->  1\n",
            "IsPrime(200) -->  0\n",
            "IsPrime(37)  -->  1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Print all the prime nos. between 1 and 100\n",
        "def IsPrime(n):\n",
        "\tfor i in range(2, n//2 + 1):\n",
        "\t\tif n%i==0:\n",
        "\t\t\treturn 0\n",
        "\treturn 1 #0 for not prime and 1 for prime. \n",
        "for i in range(2,101):\n",
        "  if IsPrime(i) == 1:\n",
        "    print(i, end=' ') # end=' ' for printing in a single line. "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AIe2PLfIR9Rp",
        "outputId": "7af941bc-9d92-4641-8393-cbc64bec0e05"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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 "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cMBI2zEJDipd"
      },
      "source": [
        "---\n",
        "### **6.3 Add 1 to n**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OdcwPL2BDipe",
        "outputId": "1ce01997-16c4-4752-d68e-01108340ebc0"
      },
      "source": [
        "def AddN(n):\n",
        "\ts= sum(range(n+1))\n",
        "\treturn s\n",
        "\n",
        "print (\"AddN(10)  --> \", AddN(10))\n",
        "print (\"AddN(20)  --> \", AddN(20))\n",
        "print (\"AddN(50)  --> \", AddN(50))\n",
        "print (\"AddN(200) --> \", AddN(200))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "AddN(10)  -->  55\n",
            "AddN(20)  -->  210\n",
            "AddN(50)  -->  1275\n",
            "AddN(200) -->  20100\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bWcn3nSlDipg"
      },
      "source": [
        "\n",
        "**Assingment 6.1:** WAP using function that add all odd numbers from 1 to n, n is given by the user.\n",
        "\n",
        "**Assingment 6.2:** WAP using function that add all prime numbers from 1 to n, n given by the user."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n6nFmz3zEfuq"
      },
      "source": [
        "---\n",
        "# **7 Math library**\n",
        "**Learning:** Use math library\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qLiy6UxaEfus",
        "outputId": "f0528ab6-7e27-49f7-d218-7e25b8c098f8"
      },
      "source": [
        "import math as m\n",
        "print (\"exp(-200)    --> \", m.exp(-200))  # Exponential function\n",
        "print (\"log(100,2)   --> \", m.log(100,2)) # Log\n",
        "print (\"log(100,10)  --> \", m.log(100,10))# Log\n",
        "print (\"log10(100)   --> \", m.log10(100)) # Log 10\n",
        "print (\"m.cos(30)    --> \", m.cos(30))    # cos\n",
        "print (\"m.sin(30)    --> \", m.sin(30))    # sin\n",
        "print (\"m.tan(30)    --> \", m.tan(30))    # tan\n",
        "print (\"m.sqrt(324)  --> \", m.sqrt(324))\n",
        "print (\"m.ceil(89.9) --> \", m.ceil(89.9))\n",
        "print (\"m.floor(89.9)--> \", m.floor(89.9))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "exp(-200)    -->  1.3838965267367376e-87\n",
            "log(100,2)   -->  6.643856189774725\n",
            "log(100,10)  -->  2.0\n",
            "log10(100)   -->  2.0\n",
            "m.cos(30)    -->  0.15425144988758405\n",
            "m.sin(30)    -->  -0.9880316240928618\n",
            "m.tan(30)    -->  -6.405331196646276\n",
            "m.sqrt(324)  -->  18.0\n",
            "m.ceil(89.9) -->  90\n",
            "m.floor(89.9)-->  89\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uuGWj5Q9E7na"
      },
      "source": [
        "---\n",
        "# **8 Strings**\n",
        "**Learning:** How to handle string\n",
        "\n",
        "---\n",
        "### **8.1 Indexing in string**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1OvIOp21E7nc",
        "outputId": "4b108797-2b08-4f46-b926-7f7cd444cd88"
      },
      "source": [
        "var = 'Hello World!'\n",
        "print (\"var      --> \", var)\n",
        "print (\"var[0]   --> \", var[0])\n",
        "print (\"var[1:5] --> \", var[1:5])\n",
        "print (\"var[:-5] --> \", var[:-5])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "var      -->  Hello World!\n",
            "var[0]   -->  H\n",
            "var[1:5] -->  ello\n",
            "var[:-5] -->  Hello W\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X9V-dQU-E7nd"
      },
      "source": [
        "---\n",
        "### **8.2 String length, upper, lower**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y8HSuWkEE7ne",
        "outputId": "665122c7-2036-48f9-e93d-fb1229f9fc4a"
      },
      "source": [
        "var = 'Hello World!'\n",
        "print (\"String --> \", var)\n",
        "print (\"Length --> : \", len(var))\n",
        "print (\"Upper  --> : \", var.upper())\n",
        "print (\"Lower  --> : \", var.lower())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String -->  Hello World!\n",
            "Length --> :  12\n",
            "Upper  --> :  HELLO WORLD!\n",
            "Lower  --> :  hello world!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ySbLzf1Fpi5"
      },
      "source": [
        "---\n",
        "### **8.3 String formatting**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RDB15138Fpi6",
        "outputId": "a1997e5d-5fdc-4a9b-aade-363201e342b4"
      },
      "source": [
        "name=input(\"Enter your name: \")\n",
        "age=int(input(\"Enter your age : \"))\n",
        "price=float(input(\"Enter the book price: \"))\n",
        "s=\"\\nYour name is %s, age is %d and book price is %f\" %(name.upper(),age,price)\n",
        "print (s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter your name: Rohan\n",
            "Enter your age : 21\n",
            "Enter the book price: 45.34\n",
            "\n",
            "Your name is ROHAN, age is 21 and book price is 45.340000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "27Y8Dk7XFp1F"
      },
      "source": [
        "---\n",
        "### **8.4 String in Triple Quotes**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiOlVj37Fp1H",
        "outputId": "a0b0c066-69c4-4cf6-f3d7-ed9e7362a795"
      },
      "source": [
        "para_str = \"\"\"This is a long string that is made up of\n",
        "several lines and non-printable characters such as\n",
        "TAB ( \\t ) and they will show up that way when displayed.\n",
        "NEWLINEs within the string, whether explicitly given like\n",
        "this within the brackets [ \\n ], or just a NEWLINE within\n",
        "the variable assignment will also show up.\n",
        "\"\"\"\n",
        "print (para_str) #special charecters like /t and /n do work. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "This is a long string that is made up of\n",
            "several lines and non-printable characters such as\n",
            "TAB ( \t ) and they will show up that way when displayed.\n",
            "NEWLINEs within the string, whether explicitly given like\n",
            "this within the brackets [ \n",
            " ], or just a NEWLINE within\n",
            "the variable assignment will also show up.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WK4GTOeIFp-I"
      },
      "source": [
        "---\n",
        "### **8.5 String strip**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tXJQREI3Fp-J",
        "outputId": "3d911b3e-2d9e-4630-81cc-f6fdadb45ecc"
      },
      "source": [
        "var =\" Indian   Army    \"\n",
        "\n",
        "print(\"String    --> \", var)\n",
        "print(\"Length    --> \", len(var))\n",
        "print(\"var strip --> \", var.strip()) #removes spaces just from front and back. \n",
        "print(\"Length of var after strip --> \", len(var.strip()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String    -->   Indian   Army    \n",
            "Length    -->  18\n",
            "var strip -->  Indian   Army\n",
            "Length of var after strip -->  13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_aSibOwQFqFC"
      },
      "source": [
        "---\n",
        "### **8.6 String split**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "02uwsbaQFqFD",
        "outputId": "d13dedba-6188-476e-d0c5-4221ef0094e0"
      },
      "source": [
        "var =\" Indian,   Army    \"\n",
        "\n",
        "print(\"String    --> \", var)\n",
        "print(\"Length    --> \", len(var))\n",
        "print(\"var split --> \", var.split())\n",
        "print(\"var split --> \", var.split(' '))\n",
        "print(\"var split --> \", var.split(','))\n",
        "\n",
        "# Strip + Split\n",
        "print(\"var split --> \", var.strip().split(','))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String    -->   Indian,   Army    \n",
            "Length    -->  19\n",
            "var split -->  ['Indian,', 'Army']\n",
            "var split -->  ['', 'Indian,', '', '', 'Army', '', '', '', '']\n",
            "var split -->  [' Indian', '   Army    ']\n",
            "var split -->  ['Indian', '   Army']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TgsO9gfoFqMV"
      },
      "source": [
        "---\n",
        "### **8.7 Count in string**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lwrJzwy6FqMV",
        "outputId": "520d3e04-546c-40ec-a438-75567a4bdfcb"
      },
      "source": [
        "var=\" Indian Army    \"\n",
        "print (\"String       --> \", var)\n",
        "print (\"Count of ' ' --> \", var.count(' '))\n",
        "print (\"Count of 'a' --> \", var.count('a'))\n",
        "print (\"Count of 'n' --> \", var.count('an'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String       -->   Indian Army    \n",
            "Count of ' ' -->  6\n",
            "Count of 'a' -->  1\n",
            "Count of 'n' -->  1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYP11CU5FqUJ"
      },
      "source": [
        "---\n",
        "### **8.8 Reverse a String**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QSXd_wfOFqUK",
        "outputId": "28a3f174-2abf-4dc5-ced6-28abc43de4ab"
      },
      "source": [
        "var=\"Indian Army\"\n",
        "print (\"String    --> \", var)\n",
        "print (\"var[::1]  --> \", var[::1])\n",
        "print (\"var[::2]  --> \", var[::2]) #Leaves one one charecter. \n",
        "print (\"var[::-1] --> \", var[::-1]) #reverses a string. \n",
        "print (\"var[::-2] --> \", var[::-2]) #reverse and leave one charecter. \n",
        "\n",
        "var=var[::-1]\n",
        "print (\"var after reverse --> \", var)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "String    -->  Indian Army\n",
            "var[::1]  -->  Indian Army\n",
            "var[::2]  -->  Ida ry\n",
            "var[::-1] -->  ymrA naidnI\n",
            "var[::-2] -->  yr adI\n",
            "var after reverse -->  ymrA naidnI\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E1Ie2pJRGiNz"
      },
      "source": [
        "---\n",
        "### **8.9 Palindrome**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-t2FMiSTGiN0",
        "outputId": "a3a68a1b-cfd8-44f2-80bd-17fb6ac22bf6"
      },
      "source": [
        "s1=\"Indian Army\"\n",
        "s2=\"malayalam\"\n",
        "s3=\"madam\"\n",
        "s4=\"teacher\"\n",
        "print (\"s1 --> \", s1==s1[::-1]) #== is just for checking. ki hai ki nhi. \n",
        "print (\"s2 --> \", s2==s2[::-1])\n",
        "print (\"s3 --> \", s3==s3[::-1])\n",
        "print (\"s4 --> \", s4==s4[::-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "s1 -->  False\n",
            "s2 -->  True\n",
            "s3 -->  True\n",
            "s4 -->  False\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MpgFLAABG0Nn"
      },
      "source": [
        "---\n",
        "# **9 Random Numbers/String**\n",
        "**Learning:** Generate Random Numbers/String\n",
        "\n",
        "---\n",
        "### **9.1 Generate random number between 0 and 1**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B2jZpOnRG0Nn",
        "outputId": "2bb5aabb-d0a0-4d2c-a4a7-efad8931b541"
      },
      "source": [
        "import random as r\n",
        "print (r.random())\n",
        "print (r.random())\n",
        "print (round(r.random(),4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0.17857802561353597\n",
            "0.494655669077676\n",
            "0.9564\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wBI9otLPG0Nn"
      },
      "source": [
        "---\n",
        "### **9.2 Generate random integer number**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "72NOmyH-G0No",
        "outputId": "f7448dc9-544c-4cb2-a8cf-bc72cad82d2a"
      },
      "source": [
        "import random as r\n",
        "print (r.randint(1, 100))\n",
        "print (r.randint(1, 100))\n",
        "print (r.randint(-10, 10))\n",
        "print (r.randint(-10, 10))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "57\n",
            "74\n",
            "-5\n",
            "-9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gFTecYJvG0No"
      },
      "source": [
        "---\n",
        "### **9.3 Generate random real number**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vs3jmtqtG0No",
        "outputId": "70bd3229-ae3b-4110-89f0-03daac3d675e"
      },
      "source": [
        "import random as r\n",
        "print (r.uniform(1, 100))\n",
        "print (r.uniform(1, 100))\n",
        "print (r.uniform (-10, 10))\n",
        "print (r.uniform (-10, 10))\n",
        "print (round(r.uniform (-10, 10),2))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "16.946619541364186\n",
            "64.29131997402445\n",
            "6.147490954005299\n",
            "-8.047752908347874\n",
            "0.15\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DJ_9Kt4XG0Np"
      },
      "source": [
        "---\n",
        "### **9.4 Select sample from a list of elements**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZVDp33YQG0Np",
        "outputId": "5d3d4231-4b56-4c91-8afc-b3c3e298b3ea"
      },
      "source": [
        "import random as r\n",
        "\n",
        "A=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "print (r.sample(A, 4))\n",
        "print (r.sample(A, 2))\n",
        "print (r.sample(range(0,100), 2))\n",
        "print (r.sample(range(-100,100), 5))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[10, 5, 3, 9]\n",
            "[10, 6]\n",
            "[93, 7]\n",
            "[54, -16, 8, -19, 70]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import random as r\n",
        "\n",
        "A=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
        "\n",
        "print (r.sample(A, 40))\n",
        "print (r.sample(A, 2))\n",
        "print (r.sample(range(0,100), 2))\n",
        "print (r.sample(range(-100,100), 5))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 351
        },
        "id": "OXcD5FI9aS-o",
        "outputId": "a29df376-2e76-4bef-ee11-bee2154b4df6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-84-070f37f0db9f>\u001b[0m in \u001b[0;36m<cell line: 5>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mA\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m40\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/lib/python3.10/random.py\u001b[0m in \u001b[0;36msample\u001b[0;34m(self, population, k, counts)\u001b[0m\n\u001b[1;32m    480\u001b[0m         \u001b[0mrandbelow\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_randbelow\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    481\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;36m0\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0mk\u001b[0m \u001b[0;34m<=\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 482\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Sample larger than population or is negative\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    483\u001b[0m         \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mk\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    484\u001b[0m         \u001b[0msetsize\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m21\u001b[0m        \u001b[0;31m# size of a small set minus size of an empty list\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: Sample larger than population or is negative"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cgEXGBtsG0Np"
      },
      "source": [
        "---\n",
        "### **9.5 Generate random string**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T-FHSfgfG0Nq",
        "outputId": "ac7eacd3-32fb-4ee9-8d0d-7adbb6750ef3"
      },
      "source": [
        "import string as s\n",
        "import random as r\n",
        "print (\"String        --> \",s.ascii_letters)\n",
        "\n",
        "passwd=r.sample(s.ascii_letters, 6)\n",
        "print (\"Selected Char --> \",passwd)\n",
        "\n",
        "passwd1=\"\".join(passwd)\n",
        "print (\"passwd1       --> \",passwd1)\n",
        "\n",
        "passwd2=\"+\".join(passwd)\n",
        "print (\"passwd2       --> \",passwd2)\n",
        "\n",
        "passwd3=\"*\".join(passwd)\n",
        "print (\"passwd3       --> \",passwd3)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String        -->  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
            "Selected Char -->  ['h', 's', 'Z', 'l', 'P', 'k']\n",
            "passwd1       -->  hsZlPk\n",
            "passwd2       -->  h+s+Z+l+P+k\n",
            "passwd3       -->  h*s*Z*l*P*k\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import string as s\n",
        "import random as r\n",
        "print (\"String        --> \",s.ascii_letters)\n",
        "\n",
        "passwd=r.sample(s.ascii_letters + s.ascii_letters, 60) #26+26+26+26 = 104 therefore the password can be assigned of maximum 104 charecters. \n",
        "print (\"Selected Char --> \",passwd)\n",
        "\n",
        "passwd1=\"\".join(passwd)\n",
        "print (\"passwd1       --> \",passwd1)\n",
        "\n",
        "passwd2=\"+\".join(passwd)\n",
        "print (\"passwd2       --> \",passwd2)\n",
        "\n",
        "passwd3=\"*\".join(passwd)\n",
        "print (\"passwd3       --> \",passwd3)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1xo1GAYsbx_r",
        "outputId": "bf2db2a4-05ea-421f-b392-e5837d71f239"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "String        -->  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
            "Selected Char -->  ['x', 'u', 'I', 'w', 'G', 't', 'G', 'Y', 'D', 'c', 'Q', 'L', 'U', 'H', 'Z', 'N', 'k', 'A', 'I', 'u', 'S', 'q', 'R', 'H', 'Q', 'n', 's', 'a', 'S', 'g', 'E', 'e', 'J', 'h', 'q', 'r', 'K', 'D', 'j', 'z', 'O', 'B', 'N', 'E', 'V', 'm', 'g', 'i', 'V', 'W', 'M', 'l', 'r', 'P', 'z', 'c', 'F', 'o', 'd', 'o']\n",
            "passwd1       -->  xuIwGtGYDcQLUHZNkAIuSqRHQnsaSgEeJhqrKDjzOBNEVmgiVWMlrPzcFodo\n",
            "passwd2       -->  x+u+I+w+G+t+G+Y+D+c+Q+L+U+H+Z+N+k+A+I+u+S+q+R+H+Q+n+s+a+S+g+E+e+J+h+q+r+K+D+j+z+O+B+N+E+V+m+g+i+V+W+M+l+r+P+z+c+F+o+d+o\n",
            "passwd3       -->  x*u*I*w*G*t*G*Y*D*c*Q*L*U*H*Z*N*k*A*I*u*S*q*R*H*Q*n*s*a*S*g*E*e*J*h*q*r*K*D*j*z*O*B*N*E*V*m*g*i*V*W*M*l*r*P*z*c*F*o*d*o\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9NFexXG1G0Nq"
      },
      "source": [
        "---\n",
        "### **9.6 Generate random digits**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mH0sHuuHG0Nq",
        "outputId": "f11c56d4-2be7-4c0f-bb97-4f71dbc67772"
      },
      "source": [
        "import string as s\n",
        "import random as r\n",
        "print (\"Digits --> \",s.digits)\n",
        "\n",
        "otp=r.sample(s.digits, 5)\n",
        "print (\"Selected num1 --> \",otp)\n",
        "otp=\"\".join(otp)\n",
        "print (\"otp1          --> \",otp)\n",
        "\n",
        "otp=r.sample(s.digits, 5)\n",
        "print (\"Selected num2 --> \",otp)\n",
        "otp=\"\".join(otp)\n",
        "print (\"otp2          --> \",otp)\n",
        "\n",
        "otp=r.sample(s.digits, 5)\n",
        "print (\"Selected num2 --> \",otp)\n",
        "otp=\"\".join(otp)\n",
        "print (\"otp3          --> \",otp)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Digits -->  0123456789\n",
            "Selected num1 -->  ['9', '4', '1', '2', '5']\n",
            "otp1          -->  94125\n",
            "Selected num2 -->  ['3', '8', '6', '9', '1']\n",
            "otp2          -->  38691\n",
            "Selected num2 -->  ['3', '6', '4', '7', '5']\n",
            "otp3          -->  36475\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1bcIKPDpG0Nr"
      },
      "source": [
        "---\n",
        "### **9.7 Generate random string + digits**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BG-ACfp0G0Nr",
        "outputId": "0bd4c197-028b-4fa9-fbe6-c3d404b0e4a8"
      },
      "source": [
        "import string as s\n",
        "import random as r\n",
        "print (\"String + Digits --> \",s.ascii_letters + s.digits)\n",
        "\n",
        "mixPasswd=r.sample(s.ascii_letters + s.digits, 5)\n",
        "print (\"\\nSelected Str1 --> \",mixPasswd)\n",
        "mixPasswd=\"\".join(mixPasswd)\n",
        "print (\"mixPasswd1    --> \",mixPasswd)\n",
        "\n",
        "mixPasswd=r.sample(s.ascii_letters + s.digits, 6)\n",
        "print (\"\\nSelected Str2 --> \",mixPasswd)\n",
        "mixPasswd=\"\".join(mixPasswd)\n",
        "print (\"mixPasswd2    --> \",mixPasswd)\n",
        "\n",
        "splChar=\"#@!~%^&*()_+=-[]{}|\"\n",
        "mixPasswd=r.sample(splChar + s.ascii_letters + s.digits, 8) #if you want more digits in the password, then concatenate more digits. +s.digits+s.digits+s.digits\n",
        "print (\"\\nSelected Str3 --> \",mixPasswd)\n",
        "mixPasswd=\"\".join(mixPasswd)\n",
        "print (\"mixPasswd3    --> \",mixPasswd)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "String + Digits -->  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n",
            "\n",
            "Selected Str1 -->  ['n', 'y', 'v', 'D', '9']\n",
            "mixPasswd1    -->  nyvD9\n",
            "\n",
            "Selected Str2 -->  ['P', 'K', '6', '3', 'S', 'D']\n",
            "mixPasswd2    -->  PK63SD\n",
            "\n",
            "Selected Str3 -->  ['V', 'q', 'Q', 'B', 'r', '^', '%', '{']\n",
            "mixPasswd3    -->  VqQBr^%{\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcdyFjhzJo9j"
      },
      "source": [
        "---\n",
        "# **10 Exception Handaling**\n",
        "**Learning:** How to handle exceptions\n",
        "\n",
        "---\n",
        "### **10.1 Error Generation**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 266
        },
        "id": "vKJEy_SYJo9k",
        "outputId": "c9dcc5ba-cee4-4287-c9f1-ccac4a931b89"
      },
      "source": [
        "for i in range(-5,6):\n",
        "\tprint (\"100/\",i,\" --> \", 100/i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100/ -5  -->  -20.0\n",
            "100/ -4  -->  -25.0\n",
            "100/ -3  -->  -33.333333333333336\n",
            "100/ -2  -->  -50.0\n",
            "100/ -1  -->  -100.0\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-94-5eb017879ab5>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m         \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"100/\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\" --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ulPZfl8rJo9l"
      },
      "source": [
        "---\n",
        "### **10.2 Exception handaling for division by zero**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GY4t0EqjJo9m",
        "outputId": "e94f39e6-e2ac-4761-bd47-365d98d23b91"
      },
      "source": [
        "for i in range(-5,6):\n",
        "\ttry:\n",
        "\t\tprint (\"100/\",i,\" --> \", 100/i)\n",
        "\texcept:\n",
        "\t\tprint (\"error\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "100/ -5  -->  -20.0\n",
            "100/ -4  -->  -25.0\n",
            "100/ -3  -->  -33.333333333333336\n",
            "100/ -2  -->  -50.0\n",
            "100/ -1  -->  -100.0\n",
            "error\n",
            "100/ 1  -->  100.0\n",
            "100/ 2  -->  50.0\n",
            "100/ 3  -->  33.333333333333336\n",
            "100/ 4  -->  25.0\n",
            "100/ 5  -->  20.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1cY_zT3Jo9m"
      },
      "source": [
        "---\n",
        "### **10.3 Exception handaling for array out of index**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m1rBOUB3Jo9n",
        "outputId": "db9be391-f8f3-4e95-d25c-8a4981bc56da"
      },
      "source": [
        "L=[1,2,3,4,5]\n",
        "\n",
        "for i in range(8):\n",
        "\ttry:\n",
        "\t\tprint (i,\" --> \",L[i])\n",
        "\texcept:\n",
        "\t\tprint (\"error\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0  -->  1\n",
            "1  -->  2\n",
            "2  -->  3\n",
            "3  -->  4\n",
            "4  -->  5\n",
            "error\n",
            "error\n",
            "error\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kH8CATzbJo9o"
      },
      "source": [
        "---\n",
        "### **10.4 Exception handaling for file not found**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 232
        },
        "id": "zZ7ns4K3Jo9o",
        "outputId": "2af4a141-9063-4123-b5ec-4f33e652f88a"
      },
      "source": [
        "fileName=input(\"Enter File Name: \")\n",
        "fp=open(fileName)\t# Open the file in reading mode\n",
        "fp.close()\n",
        "print (\"Done\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Enter File Name: Sample.csv\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-97-df3155df6860>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mfileName\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Enter File Name: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileName\u001b[0m\u001b[0;34m)\u001b[0m       \u001b[0;31m# Open the file in reading mode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mfp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Done\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'Sample.csv'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D4bffbZQJo9p"
      },
      "source": [
        "---\n",
        "### **10.5 Exception handaling for file not found**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dt3X92CyJo9q",
        "outputId": "44913928-1414-48a8-c058-8208b84b7a46"
      },
      "source": [
        "fileName=input(\"Enter File Name: \")\n",
        "try:\n",
        "\tfp=open(fileName)\t# Open the file in reading mode\n",
        "\tfp.close()\n",
        "except:\n",
        "\tprint (\"Error !! \\\"%s\\\" File Not Found\"%(fileName))\n",
        "\n",
        "print (\"Done\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter File Name: Jaimanfile \n",
            "Error !! \"Jaimanfile \" File Not Found\n",
            "Done\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F5w6mKSaPcaj"
      },
      "source": [
        "---\n",
        "# **11 Data Structure 1 - List**\n",
        "**Learning:** How to use list, add, delete and search in the list.\n",
        "\n",
        "**Note:** Read more about list and try yourself\n",
        "\n",
        "---\n",
        "### **11.1 List Declaration**\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nYnqBFRzPcas",
        "outputId": "b7bb6bd8-f3f7-434c-d40f-fc860c085eb5"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ] #dataset can be heterogenous in python, not in java c++ etc. \n",
        "print (\"Original List: \", L)\n",
        "print (\"Number of elements in list: \", len(L))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Number of elements in list:  4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xyP5tZ7IPcat"
      },
      "source": [
        "---\n",
        "### **11.2 List Iteration**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TIalxne5Pcat",
        "outputId": "5674a59c-235b-4ce9-fa39-e0fddfdd5212"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List: \", L)\n",
        "i=0\n",
        "while i < len(L): \n",
        "\tprint (L[i])\n",
        "\ti+=1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fpkfQhktPcau"
      },
      "source": [
        "---\n",
        "### **11.3 List Iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p6mVPS1pPcau",
        "outputId": "2dccab82-5f6a-41e7-e4f4-d79dc96c205a"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List: \", L)\n",
        "for i in range(0, len(L)):\n",
        "\tprint (L[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CouKDMO1Pcav"
      },
      "source": [
        "---\n",
        "### **11.4 List Iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yT0MDFBJPcaw",
        "outputId": "79a9a0f2-ef79-4232-88dc-286999cd6d19"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List --> \", L)\n",
        "for s in L:\n",
        "\tprint (s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XeroS2dsPcay"
      },
      "source": [
        "---\n",
        "### **11.5 Adding and deleting from list**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rWUOXQitPcay",
        "outputId": "27c3825f-be83-4379-9d26-e0f9efb1d0bc"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List       --> \", L)\n",
        "\n",
        "L.append(\"Rahul\")\n",
        "print (\"List After Adding   --> \", L)\n",
        "\n",
        "del L[1]\n",
        "print (\"List After Deleting --> \", L)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List       -->  ['Pratham', 'Sharma', 3.14, 3]\n",
            "List After Adding   -->  ['Pratham', 'Sharma', 3.14, 3, 'Rahul']\n",
            "List After Deleting -->  ['Pratham', 3.14, 3, 'Rahul']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DxAr9ZfPcaz"
      },
      "source": [
        "---\n",
        "### **11.6 Sum/Average of List**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "taKMcEajPca1",
        "outputId": "6d953543-b1e3-4554-e28c-0f6553fbe22f"
      },
      "source": [
        "L=[3, 6, 9, 12, 5, 3, 2]\n",
        "print (\"Original List --> \", L)\n",
        "\n",
        "print (\"Sum     --> \", sum(L))\n",
        "print (\"Average --> \", sum(L)/len(L))\n",
        "print (\"Average --> \", sum(L)//len(L))\n",
        "\n",
        "print (\"L * 3   --> \", L * 3)     # Every element get tripled\n",
        "print (\"L + L   --> \", L + L)     # Every element get doubled"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "Sum     -->  40\n",
            "Average -->  5.714285714285714\n",
            "Average -->  5\n",
            "L * 3   -->  [3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2]\n",
            "L + L   -->  [3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2SIEcqKePca1"
      },
      "source": [
        "---\n",
        "### **11.7 Min/Max/Sort the list**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NUsOwblSPca1",
        "outputId": "eb8f00cd-0cdb-45c8-df00-94d8cace3534"
      },
      "source": [
        "L=[3, 6, 9, 12, 5, 3, 2]\n",
        "print (\"Original List --> \", L)\n",
        "\n",
        "print (\"max --> \", max(L))\n",
        "print (\"min --> \", min(L))\n",
        "\n",
        "print (\"\\nBefore Sort            --> \", L)\n",
        "L.sort()\n",
        "\n",
        "print (\"After Sort (Asending)  --> \", L)\n",
        "\n",
        "L.sort(reverse=True)\n",
        "print (\"After Sort (Desending) --> \", L)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "max -->  12\n",
            "min -->  2\n",
            "\n",
            "Before Sort            -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "After Sort (Asending)  -->  [2, 3, 3, 5, 6, 9, 12]\n",
            "After Sort (Desending) -->  [12, 9, 6, 5, 3, 3, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pX_P07ODQoQM"
      },
      "source": [
        "---\n",
        "### **11.8 Merge lists and select elements**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pf8csu4yQoQO",
        "outputId": "136ff95d-91e5-4770-9ce6-d74148629add"
      },
      "source": [
        "L1 = [3, 6, 9]\n",
        "L2 = [12, 5, 3, 2]\n",
        "L3 = L1 + L2\n",
        "print (\"L1 --> \",L1)\n",
        "print (\"L2 --> \",L2)\n",
        "print (\"L3 --> \",L3)\n",
        "\n",
        "print (\"\\nL3[2:]  --> \",L3[2:])\n",
        "print (\"L3[2:5] --> \",L3[2:5])\n",
        "print (\"L3[:-1] --> \",L3[:-1])\n",
        "print (\"L3[::2] --> \",L3[::2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "L1 -->  [3, 6, 9]\n",
            "L2 -->  [12, 5, 3, 2]\n",
            "L3 -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "\n",
            "L3[2:]  -->  [9, 12, 5, 3, 2]\n",
            "L3[2:5] -->  [9, 12, 5]\n",
            "L3[:-1] -->  [3, 6, 9, 12, 5, 3]\n",
            "L3[::2] -->  [3, 9, 5, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2fxU9VLhQpGB"
      },
      "source": [
        "---\n",
        "### **11.9 Multiply all elements of the list by a constant**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Karxlcp6QpGC",
        "outputId": "988e0fba-cf4c-497d-90ba-11df3d185cba"
      },
      "source": [
        "L = [12, 5, 3, 2, 7]\n",
        "print (\"Original List --> \", L)\n",
        "\n",
        "newL = [ i * 5 for i in L ]\n",
        "print (\"After Multiply with constant --> \", newL)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original List -->  [12, 5, 3, 2, 7]\n",
            "After Multiply with constant -->  [60, 25, 15, 10, 35]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9_QezrcQpQ9"
      },
      "source": [
        "---\n",
        "### **11.10 Searching in the list**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZptMehxhQpQ9",
        "outputId": "fdaf258e-90d3-4e6e-d06c-094ad056e023"
      },
      "source": [
        "L=[3, 6, 9, 12, 5, 3, 2]\n",
        "print (\"Original List --> \", 6 in L)\n",
        "print (\"Original List --> \", 10 in L)\n",
        "print (\"Original List --> \", 12 in L)\n",
        "\n",
        "if (6 in L) == True:\n",
        "\tprint (\"Present\")\n",
        "else:\n",
        "\tprint (\"Not Present\")\n",
        "\n",
        "if 10 in L == False:\n",
        "\tprint (\"Not Present\")\n",
        "else:\n",
        "\tprint (\"Present\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  True\n",
            "Original List -->  False\n",
            "Original List -->  True\n",
            "Present\n",
            "Present\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zHAa4y1BScFQ"
      },
      "source": [
        "---\n",
        "# **12 Data Structure 2 - Dictionary**\n",
        "**Learning:** How to use Dictionary, add, delete, search in Dictionary\n",
        "\n",
        "**Note:** Read more about Dictionary and try yourself\n",
        "\n",
        "---\n",
        "### **12.1 Declare Dictionary**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "T7Q4GKPaScFS",
        "outputId": "cb279f68-3e4b-45b3-8547-c226fcfc5ce8"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "print (\"Dictionary      --> \", CGPA)\n",
        "print (\"Num of elements --> \", len(CGPA))\n",
        "\n",
        "print (\"CGPA of 1       --> \", CGPA[1])\n",
        "print (\"CGPA of 4       --> \", CGPA[4])\n",
        "print (\"CGPA of 7       --> \", CGPA[7])\n",
        "print (\"CGPA of 3       --> \", CGPA[3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dictionary      -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "Num of elements -->  5\n",
            "CGPA of 1       -->  8.9\n",
            "CGPA of 4       -->  6.7\n",
            "CGPA of 7       -->  9.1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-54-598d6ecb7ab2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"CGPA of 4       --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"CGPA of 7       --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"CGPA of 3       --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 3"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BxbeipLlScFS"
      },
      "source": [
        "---\n",
        "### **12.2 Triverse dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iWXBcVNTScFT",
        "outputId": "5e82b4d3-1d6f-42de-e2fc-a622de21f788"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "for k in CGPA:\n",
        "\tprint (\"CGPA of \", k, \" --> \", CGPA[k])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CGPA of  1  -->  8.9\n",
            "CGPA of  2  -->  5.6\n",
            "CGPA of  4  -->  6.7\n",
            "CGPA of  7  -->  9.1\n",
            "CGPA of  8  -->  5.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O721iFiOScFT"
      },
      "source": [
        "---\n",
        "### **12.3 Getting Keys and Values**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dnPH-GCyScFU",
        "outputId": "6e824afc-ef7b-4b98-e6fb-4b09f7fb3430"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "print (\"Dictionary --> \", CGPA)\n",
        "print (\"Keys       --> \", list(CGPA.keys()))\n",
        "print (\"Values     --> \", list(CGPA.values()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dictionary -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "Keys       -->  [1, 2, 4, 7, 8]\n",
            "Values     -->  [8.9, 5.6, 6.7, 9.1, 5.3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v2ooUfguScFV"
      },
      "source": [
        "---\n",
        "### **12.4 Updating, Adding and Deleting from Dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "zO_QA0GNScFV",
        "outputId": "59cef6de-2f0a-43be-f64c-f54ef4369bb4"
      },
      "source": [
        "CGPA={1:8.9,2:5.6,4:6.7,7:9.1,8:5.3}\n",
        "print (\"Original Dictionary --> \", CGPA)\n",
        "\n",
        "CGPA[4] = 9.2\n",
        "print (\"After Updating (4)  --> \", CGPA)\n",
        "\n",
        "CGPA[3] = 8.6\n",
        "print (\"After Adding (3)    --> \", CGPA)\n",
        "\n",
        "del CGPA[1]\n",
        "print (\"After Deleting (1)  --> \", CGPA)\n",
        "\n",
        "CGPA.clear()\n",
        "print (\"After Clear         --> \", CGPA)\n",
        "\n",
        "del CGPA\n",
        "print (\"After Delete        --> \", CGPA)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "After Updating (4)  -->  {1: 8.9, 2: 5.6, 4: 9.2, 7: 9.1, 8: 5.3}\n",
            "After Adding (3)    -->  {1: 8.9, 2: 5.6, 4: 9.2, 7: 9.1, 8: 5.3, 3: 8.6}\n",
            "After Deleting (1)  -->  {2: 5.6, 4: 9.2, 7: 9.1, 8: 5.3, 3: 8.6}\n",
            "After Clear         -->  {}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-57-81104b3723b2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"After Delete        --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'CGPA' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8SPV0FVyScFW"
      },
      "source": [
        "---\n",
        "### **12.5 Checking for Key in Dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bwt-yAtpScFW",
        "outputId": "effceb1d-b3af-4edc-8ce2-454f1e65642f"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "print (\"Original Dictionary --> \", CGPA)\n",
        "print (\"Is Key 2 Present    --> \", 2 in CGPA)\n",
        "print (\"Is Key 9 Present    --> \", 9 in CGPA)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "Is Key 2 Present    -->  True\n",
            "Is Key 9 Present    -->  False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_KifQnHnScFX"
      },
      "source": [
        "---\n",
        "### **12.6 More example1**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tM4fQro9ScFZ",
        "outputId": "0fae7659-153f-428a-c06f-be64b001f00e"
      },
      "source": [
        "HomeTown={\"Prashant\":\"Delhi\", \"Govind\":\"Gwalior\", \"Anil\":\"Morena\", \"Pankaj\":\"Agra\"}\n",
        "print (\"Original Dictionary --> \", HomeTown)\n",
        "print (\"Home Town of Prashant is --> \", HomeTown[\"Prashant\"])\n",
        "print (\"Home Town of Govind is   --> \", HomeTown[\"Govind\"])\n",
        "print (\"Home Town of Anil is     --> \", HomeTown[\"Anil\"])\n",
        "print (\"Home Town of Pankaj is   --> \", HomeTown[\"Pankaj\"])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {'Prashant': 'Delhi', 'Govind': 'Gwalior', 'Anil': 'Morena', 'Pankaj': 'Agra'}\n",
            "Home Town of Prashant is -->  Delhi\n",
            "Home Town of Govind is   -->  Gwalior\n",
            "Home Town of Anil is     -->  Morena\n",
            "Home Town of Pankaj is   -->  Agra\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZQIFxo4GScFa"
      },
      "source": [
        "---\n",
        "### **12.7 More example2**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hOADMSpvScFa",
        "outputId": "b3418002-b0ed-410f-f6c9-55a0f3158b88"
      },
      "source": [
        "HomeTown={\"Prashant\":\"Delhi\", \"Govind\":\"Gwalior\", \"Anil\":\"Morena\", \"Pankaj\":\"Agra\"}\n",
        "print (\"Original Dictionary --> \", HomeTown)\n",
        "\n",
        "for d in HomeTown:\n",
        "\tprint (\"Home Town of \", d, \" is  --> \", HomeTown[d])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {'Prashant': 'Delhi', 'Govind': 'Gwalior', 'Anil': 'Morena', 'Pankaj': 'Agra'}\n",
            "Home Town of  Prashant  is  -->  Delhi\n",
            "Home Town of  Govind  is  -->  Gwalior\n",
            "Home Town of  Anil  is  -->  Morena\n",
            "Home Town of  Pankaj  is  -->  Agra\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hom72Xe6Z1sJ"
      },
      "source": [
        "---\n",
        "# **13 Data Structure 3 - Tuple**\n",
        "\n",
        "**Learning:** How to use Tuple, add, delete, search in Tuple\n",
        "\n",
        "**Note:** Read more about Tuple and try yourself\n",
        "\n",
        "---\n",
        "### **13.1 Declare Tuple**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "au4DzzGyFysT",
        "outputId": "0b0400d0-99ce-4161-f3ed-519f7400ffc5"
      },
      "source": [
        "# Method 1\n",
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "\n",
        "print (\"T               -->\", T)\n",
        "print (\"Num of elements -->\", len(T))\n",
        "print (\"Type of Object  -->\", type(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T               --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Num of elements --> 4\n",
            "Type of Object  --> <class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6w09RiHeF-Io",
        "outputId": "2c368a8c-c5bc-43cc-854a-fee6c8185cba"
      },
      "source": [
        "# Method 2\n",
        "T = tuple([\"Pratham\", 'Sharma', 3.14, 3])   # Convert list to tuple\n",
        "#T = tuple((\"Pratham\", 'Sharma', 3.14, 3))  # Also Works\n",
        "\n",
        "print (\"T               -->\", T)\n",
        "print (\"Num of elements -->\", len(T))\n",
        "print (\"Type of Object  -->\", type(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T               --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Num of elements --> 4\n",
            "Type of Object  --> <class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sC3XhTJtFysW"
      },
      "source": [
        "---\n",
        "### **13.2 Tuple Iteration**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pama9SlbFysX",
        "outputId": "9b100c56-ffdc-464d-bbf3-c34ba7a6a55c"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "i = 0\n",
        "while i < len(T): \n",
        "    print (T[i])\n",
        "    i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xk0P6u4BFysY"
      },
      "source": [
        "---\n",
        "### **13.3 Tuple iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N73bUXRDFysZ",
        "outputId": "af8e2b82-d097-4f31-f5ec-59ac3643e5db"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "for i in range(0, len(T)):\n",
        "    print (T[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGZWqnebFysa"
      },
      "source": [
        "---\n",
        "### **13.4 Tuple iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y6L2BeBcFysb",
        "outputId": "8855ebf5-3d7b-41e4-840f-2ac08a20074b"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "for s in T:\n",
        "    print (s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TsjuXQqfFysc"
      },
      "source": [
        "---\n",
        "### **13.5 Accessing/Selecting in Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FgB4s6OtFysc",
        "outputId": "c296adb6-134a-4226-eb46-b78aa2d559f7"
      },
      "source": [
        "# Example 1:\n",
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T     -->\", T)\n",
        "\n",
        "print (\"T[1]  -->\", T[1])\n",
        "print (\"T[2]  -->\", T[2])\n",
        "print (\"T[-1] -->\", T[-1])\n",
        "print (\"T[-2] -->\", T[-2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T     --> (3, 6, 9, 12, 5, 3, 2)\n",
            "T[1]  --> 6\n",
            "T[2]  --> 9\n",
            "T[-1] --> 2\n",
            "T[-2] --> 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ex2S0y2tGzSH",
        "outputId": "0bfaaa6d-ec22-4565-c976-21dee9073d21"
      },
      "source": [
        "# Example 2:\n",
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T        -->\", T)\n",
        "\n",
        "print (\"T[1:3]   -->\", T[1:3])\n",
        "print (\"T[2:]    -->\", T[2:])\n",
        "print (\"T[2:5]   -->\", T[2:5])\n",
        "print (\"T[:2]    -->\", T[:2])\n",
        "print (\"T[:-1]   -->\", T[:-1])\n",
        "print (\"T[-4:-1] -->\", T[-4:-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T        --> (3, 6, 9, 12, 5, 3, 2)\n",
            "T[1:3]   --> (6, 9)\n",
            "T[2:]    --> (9, 12, 5, 3, 2)\n",
            "T[2:5]   --> (9, 12, 5)\n",
            "T[:2]    --> (3, 6)\n",
            "T[:-1]   --> (3, 6, 9, 12, 5, 3)\n",
            "T[-4:-1] --> (12, 5, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IYCHgXGZFyse"
      },
      "source": [
        "---\n",
        "### **13.6 Sum/Average of Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1sSPfUTGFysf",
        "outputId": "16d17e2a-4dec-4b4b-8be3-2ad47aa56978"
      },
      "source": [
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T       -->\", T)\n",
        "print (\"Sum     -->\", sum(T))\n",
        "print (\"Average -->\", sum(T)/len(T))\n",
        "print (\"Average -->\", sum(T)//len(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T       --> (3, 6, 9, 12, 5, 3, 2)\n",
            "Sum     --> 40\n",
            "Average --> 5.714285714285714\n",
            "Average --> 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E_Je9dVxFysg"
      },
      "source": [
        "---\n",
        "### **13.7 Min/Max in Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tNsc-7xEFysi",
        "outputId": "52c79168-37c0-424c-a60a-f438f4795d1a"
      },
      "source": [
        "# Example 1\n",
        "T = (3, 6, 9, 12, 5, 3, 2)                # Integer Tuple\n",
        "print (\"T   -->\", T)\n",
        "print (\"Max -->\", max(T))\n",
        "print (\"Min -->\", min(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T   --> (3, 6, 9, 12, 5, 3, 2)\n",
            "Max --> 12\n",
            "Min --> 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwCtFSUDHL50",
        "outputId": "f19848de-93c7-4eb9-8b0d-cba7f147d56a"
      },
      "source": [
        "# Example 2\n",
        "T = (\"Ram\", \"Shyam\", \"Human\", \"Ant\")      # String Tuple\n",
        "print (\"T   -->\", T)\n",
        "print (\"Max -->\", max(T))\n",
        "print (\"Min -->\", min(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T   --> ('Ram', 'Shyam', 'Human', 'Ant')\n",
            "Max --> Shyam\n",
            "Min --> Ant\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WUNgIs62Fysi"
      },
      "source": [
        "---\n",
        "### **13.8 Merging Tuples**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zqz9Xp0tFysj",
        "outputId": "ca983a47-6fe3-4617-ca55-7fd004404371"
      },
      "source": [
        "T1 = (3, 6, 9)\n",
        "T2 = (12, 5, 3, 2)\n",
        "\n",
        "print (\"T1 -->\", T1)\n",
        "print (\"T2 -->\", T2)\n",
        "\n",
        "T3 = T1 + T2\n",
        "print (\"T3 -->\", T3)\n",
        "\n",
        "T4 = T1 + T2 + T1 + T2\n",
        "print (\"T4 -->\", T4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T1 --> (3, 6, 9)\n",
            "T2 --> (12, 5, 3, 2)\n",
            "T3 --> (3, 6, 9, 12, 5, 3, 2)\n",
            "T4 --> (3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2lF7bjeFysj"
      },
      "source": [
        "---\n",
        "### **13.9 Merging part of Tuples**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ChXppaZFysk",
        "outputId": "ef268912-4d8f-4213-b313-e47bb175d68b"
      },
      "source": [
        "T1 = (3, 6, 9)\n",
        "T2 = (12, 5, 3, 2)\n",
        "\n",
        "print (\"T1 -->\", T1)\n",
        "print (\"T2 -->\", T2)\n",
        "\n",
        "T3 = T1[1:2] + T2[1:3]\n",
        "print (\"T3 -->\", T3)\n",
        "\n",
        "T4 = T1[:-2] + T2[:-3]\n",
        "print (\"T4 -->\", T4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T1 --> (3, 6, 9)\n",
            "T2 --> (12, 5, 3, 2)\n",
            "T3 --> (6, 5, 3)\n",
            "T4 --> (3, 12)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3frpbJ4RFysl"
      },
      "source": [
        "---\n",
        "### **13.10 Searching in the tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cY6y818WFysl",
        "outputId": "abe51a3b-51b5-4af6-86c6-66388f33d1b6"
      },
      "source": [
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T       -->\", T)\n",
        "\n",
        "print (\"6  in T -->\", 6 in T)\n",
        "print (\"10 in T -->\", 10 in T)\n",
        "print (\"12 in T -->\", 12 in T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T       --> (3, 6, 9, 12, 5, 3, 2)\n",
            "6  in T --> True\n",
            "10 in T --> False\n",
            "12 in T --> True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vJg6l4N_E4IG"
      },
      "source": [
        "---\n",
        "### **13.11 Adding element to Tuple (Error)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RM0E_sSoE4IH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "c110bb1d-ef9d-4d87-dcbf-403a832536ae"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "T[2] = 900               # Error; 'tuple' object does not support item assignment\n",
        "print (\"T -->\", T)\n",
        "\n",
        "#Tuples are unchangeable. We cannot add items to it. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-74-fb1d27ae8658>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"T -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mT\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m900\u001b[0m               \u001b[0;31m# Error; 'tuple' object does not support item assignment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"T -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KocwDH8QE4IH"
      },
      "source": [
        "---\n",
        "### **13.12 Adding element to Tuple - (Jugaad)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TWSdjWFfE4II",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1e1fbcd-c3a9-47d1-8f33-5134dc46e444"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T         -->\", T)\n",
        "\n",
        "T1 = list(T)\n",
        "T1.append(9.8)\n",
        "T = tuple(T1)\n",
        "\n",
        "print (\"After Add -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T         --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Add --> ('Pratham', 'Sharma', 3.14, 3, 9.8)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D8fE_Al0E4II"
      },
      "source": [
        "---\n",
        "### **13.13 Inserting element in Tuple - (Jugaad)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bkvZ4s4yE4IJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7859f4ef-826a-4be5-bf75-0afdb64cd632"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T            -->\", T)\n",
        "\n",
        "T1 = list(T)\n",
        "T1.insert(2, \"Rahul\")\n",
        "T = tuple(T1)\n",
        "\n",
        "print (\"After Insert -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Insert --> ('Pratham', 'Sharma', 'Rahul', 3.14, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UvpIX1nsE4IK"
      },
      "source": [
        "---\n",
        "### **13.14 Deleting from Tuple (Error)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mex45HHQE4IL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "0198bcc8-c424-46b9-c902-ce46faa7a370"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T            -->\", T)\n",
        "\n",
        "del T[1]\n",
        "\n",
        "print (\"After Delete -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-77-0baff4d8a5c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"T            -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"After Delete -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\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: 'tuple' object doesn't support item deletion"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUlLkF7xK4ta"
      },
      "source": [
        "---\n",
        "### **13.15 Deleting from Tuple - (Jugaad)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ey7gyq_JK4tc",
        "outputId": "7aa8c834-9404-49cf-8a2f-7424577d08a6"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T            -->\", T)\n",
        "\n",
        "T1 = list(T)\n",
        "del T1[1]\n",
        "T = tuple(T1)\n",
        "\n",
        "print (\"After Delete -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Delete --> ('Pratham', 3.14, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nP1BXJvpaSMR"
      },
      "source": [
        "---\n",
        "# **14 Data Structure 4 - Set**\n",
        "\n",
        "**Learning:** How to use Set, add, delete, search in Set\n",
        "\n",
        "**Note:** Read more about Set and try yourself\n",
        "\n",
        "---\n",
        "### **14.1 Declare Set**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q7k_3HyiaWwa",
        "outputId": "c0986637-55e8-4440-bf43-acab6dccc960"
      },
      "source": [
        "s = set(['A', 'B', 'E', 'F','E', 'F' ])\n",
        "print (\"Original set           --> \", s)\n",
        "print (\"Num of elements in set --> \", len(s))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original set           -->  {'E', 'A', 'F', 'B'}\n",
            "Num of elements in set -->  4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ltLfKXfKardd"
      },
      "source": [
        "---\n",
        "### **14.2 Opertions on Sets**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s8KiiSKSardf",
        "outputId": "8194b701-82ec-4601-8904-87ac54a5b5d0"
      },
      "source": [
        "a = set(['A', 'B', 'E', 'F' ])\n",
        "b = set([\"A\", \"C\", \"D\", \"E\"])\n",
        "print (\"Original set a      --> \", a)\n",
        "print (\"Original set b      --> \", b)\n",
        "print (\"Union of a and b    --> \", a.union(b))\n",
        "print (\"Intersection of a,b --> \", a.intersection(b))\n",
        "print (\"Difference a - b    --> \", a - b)\n",
        "print (\"Difference a - b    --> \", a.difference(b))\n",
        "print (\"Difference b - a    --> \", b - a)\n",
        "print (\"Difference b - a    --> \", b.difference(a))\n",
        "print (\"Symetric Diff a - b --> \", a.symmetric_difference(b))\n",
        "print (\"Symetric Diff b - a --> \", b.symmetric_difference(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original set a      -->  {'E', 'A', 'F', 'B'}\n",
            "Original set b      -->  {'E', 'A', 'D', 'C'}\n",
            "Union of a and b    -->  {'B', 'D', 'F', 'E', 'A', 'C'}\n",
            "Intersection of a,b -->  {'E', 'A'}\n",
            "Difference a - b    -->  {'F', 'B'}\n",
            "Difference a - b    -->  {'F', 'B'}\n",
            "Difference b - a    -->  {'D', 'C'}\n",
            "Difference b - a    -->  {'D', 'C'}\n",
            "Symetric Diff a - b -->  {'F', 'D', 'C', 'B'}\n",
            "Symetric Diff b - a -->  {'B', 'F', 'D', 'C'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oGG-LZJhars5"
      },
      "source": [
        "---\n",
        "### **14.3 Add, delete, pop element from set**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6MfSdtaUars6",
        "outputId": "43383d15-f134-4f5c-988c-7979db09a43e"
      },
      "source": [
        "a = set(['A', 'B', 'E', 'F' ])\n",
        "print (\"Original set a       --> \", a)\n",
        "a.add(\"D\")\n",
        "print (\"Set After Adding (D) --> \", a)\n",
        "a.add(\"D\")\n",
        "print (\"Set After Adding (D) --> \", a)\n",
        "a.remove(\"D\")\n",
        "print (\"Set After Deleting(D)--> \", a)\n",
        "a.pop()\n",
        "print (\"Set After pop        --> \", a)\n",
        "a.pop()\n",
        "print (\"Set After pop        --> \", a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original set a       -->  {'E', 'A', 'F', 'B'}\n",
            "Set After Adding (D) -->  {'B', 'D', 'F', 'E', 'A'}\n",
            "Set After Adding (D) -->  {'B', 'D', 'F', 'E', 'A'}\n",
            "Set After Deleting(D)-->  {'B', 'F', 'E', 'A'}\n",
            "Set After pop        -->  {'F', 'E', 'A'}\n",
            "Set After pop        -->  {'E', 'A'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "spvefWIWbNAR"
      },
      "source": [
        "---\n",
        "# **15 Command Line Argument**\n",
        "\n",
        "**Learning:** How to Take input from command line and process it\n",
        "\n",
        "**Note:** Run the program at cmd line\n",
        "\n",
        "---\n",
        "### **15.1 Add two numbers given at cmd line**\n",
        "**Note:** To run the program at cmd line\n",
        "*     python Program.py 10 20"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "0ieaM9uebNAS",
        "outputId": "0a60acec-3db0-4696-865c-87e4daec7cc3"
      },
      "source": [
        "import sys\n",
        "print (sys.argv)\n",
        "a = int(sys.argv[1]) \t# First Number\n",
        "b = int(sys.argv[2])\t# Second Number\n",
        "c = a + b\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-82-a3d67294dc12>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# First Number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# Second Number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '-f'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jGBXdT5CbNAT"
      },
      "source": [
        "---\n",
        "### **15.2 Concatinate two strings given at cmd line**\n",
        "**Note:** To run the program at cmd line\n",
        "*   python Program.py FirstString SecondString\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dg117QSIbNAU",
        "outputId": "62d37c0b-1ea7-4ca9-da65-a6356ec70e24"
      },
      "source": [
        "import sys #not here..copy in any other compiler. \n",
        "print (sys.argv)\n",
        "s = sys.argv[1] + \" \" + sys.argv[2]\n",
        "print (sys.argv[1], \" + \", sys.argv[2], \" --> \", s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json']\n",
            "-f  +  /root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json  -->  -f /root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gtu3hMwabNAW"
      },
      "source": [
        "---\n",
        "### **15.3 Add all the numbers given at cmd line**\n",
        "**Note:** To run the program at cmd line\n",
        "*   python Program.py\n",
        "*   python Program.py 10\n",
        "*   python Program.py 10 20 30 40\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "QSHWbDHmbNAX",
        "outputId": "f054cfa3-1901-4b1d-90f2-3e59f8671c8e"
      },
      "source": [
        "import sys\n",
        "print (sys.argv)\n",
        "sum=0\n",
        "for s in sys.argv[1:]:\n",
        "\tsum += int(s)\n",
        "\n",
        "print (\"Sum is --> \", sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-84-87063e0e9afe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0msum\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Sum is --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '-f'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-wicdMoyfLoZ"
      },
      "source": [
        "---\n",
        "# **16 File Handling**\n",
        "\n",
        "**Learning:** How to open the file, read the file and write in the file\n",
        "\n",
        "---\n",
        "### **16.1 Writing 1 to 10 in file**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oX-fBKbpfLob",
        "outputId": "5757d752-1397-4f8a-f58a-d8865990a008"
      },
      "source": [
        "fp=open('result.txt','w')\t# Open the file in writing mode\n",
        "for  i in range(1,11):\n",
        "\tfp.write(str(i) + \"\\n\")\t# Writing to the file line by line\n",
        "fp.close()\n",
        "\n",
        "print (\"Writing done !! \\nOpen result.txt to view the content\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Writing done !! \n",
            "Open result.txt to view the content\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-6OU-QD_fLoc"
      },
      "source": [
        "---\n",
        "### **16.2 Read a file and print its content**\n",
        "---\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiPQizlEfLod",
        "outputId": "750019d4-ecd0-4fbe-fa5f-9a0681d1d620"
      },
      "source": [
        "fp=open('result.txt')\t\t# Open the file in reading mode\n",
        "for line in fp: \t\t    # print line by line\n",
        "\tprint (line.strip())\n",
        "fp.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sby32ykwfLof"
      },
      "source": [
        "---\n",
        "### **16.3 Read from one file, Convert it to upper case and write to other file**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rjvJZNv_fLoh",
        "outputId": "a8704164-b68e-46b9-b87a-1e14fa262b31"
      },
      "source": [
        "Readfp=open('result.txt')\t\t# Open the file in reading mode\n",
        "Writefp=open('abc.txt','w')\t# Open the file in writing mode\n",
        "for line in Readfp: \n",
        "\tWritefp.write(line.upper())\n",
        "\t\n",
        "Writefp.close()\n",
        "Readfp.close()\n",
        "\n",
        "print (\"Writing done !! \\nOpen result.txt to view the content\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Writing done !! \n",
            "Open result.txt to view the content\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}