Revise_Python.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/Sneha-GenZ/Challenge_ques/blob/main/Revise_Python.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",
        "# **Revise Python in 2 hr**\n",
        "---\n",
        "\n",
        "### There are 16 programs to explain the various concepts in python programming such as:\n",
        "\n",
        "- Syntax,\n",
        "- Loop,\n",
        "- if-else,\n",
        "- Data Structures,\n",
        "- Strings,\n",
        "- File Handling,\n",
        "- Exception Handling,\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": "d273fb9b-8bda-4c9c-c9f8-70f05f146045"
      },
      "source": [
        "print (\"Hello World\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Hello World\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": "ad8a9c94-8769-4539-fa7f-af7b7ba74a75"
      },
      "source": [
        "a = 10\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": [
            "10  +  220  -->  230\n"
          ]
        }
      ]
    },
    {
      "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": "24a5bcd7-9c0e-40cc-a40b-a7b8a8dc2a81"
      },
      "source": [
        "a = \"Bhagat\"\n",
        "b = \" Singh\"\n",
        "c = a + b\t\t# Concatinate two strings\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bhagat  +   Singh  -->  Bhagat Singh\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": "007d503e-63ca-4a93-f7c0-6af6188f3916"
      },
      "source": [
        "a = \"Bhagat\"\n",
        "b = 100\n",
        "c = a + str(b)\t\t# Concatinate string with number\n",
        "print (a, \" + \", b, \" --> \", c)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bhagat  +  100  -->  Bhagat100\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": "5b98efbd-99c5-48bf-9e0d-6cf7a07dd4ae"
      },
      "source": [
        "a = input(\"Enter First String: \")\n",
        "b = input(\"Enter Second String: \")\n",
        "c = a + b\t\t# concatinate two strings\n",
        "print  (a, \" + \", b, \"      --> \", c)\n",
        "\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: Shyam\n",
            "Enter Second String: Patiala\n",
            "Shyam  +  Patiala       -->  ShyamPatiala\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/"
        },
        "outputId": "c0898fe6-c492-41b4-add8-f3506f39cdb2"
      },
      "source": [
        "a = int(input(\"Enter First No: \"))\n",
        "b = int(input(\"Enter Second No: \"))\n",
        "c = a + b\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter First No: 45\n",
            "Enter Second No: 87\n",
            "45  +  87  -->  132\n"
          ]
        }
      ]
    },
    {
      "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": "651c84be-37a5-4f32-efdd-0fcd9d622add"
      },
      "source": [
        "i=1\n",
        "while i <= 10:\n",
        "\tprint (i)\n",
        "\ti = i+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rd_F8ksi-puZ"
      },
      "source": [
        "---\n",
        "### **4.2 Range Function**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_U_Of2tu-puZ",
        "outputId": "71ed3d34-c176-4e99-ae1c-8fb590df276e"
      },
      "source": [
        "print (\"range(10)        --> \", list(range(10)))\n",
        "print (\"range(10,20)     --> \", list(range(10,20)))\n",
        "print (\"range(0,20,2)    --> \", list(range(2,20,2)))\n",
        "print (\"range(-10,-20,2) --> \", list(range(-10,-20,2)))\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,20,2)    -->  [2, 4, 6, 8, 10, 12, 14, 16, 18]\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": "d1356079-e874-469f-e42d-161b122646ee"
      },
      "source": [
        "for i in range(0,10):\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": "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": "67c2a0bd-b5da-4fb1-ef96-f2203d355a05"
      },
      "source": [
        "for i in range(0,20,2):\n",
        "\tprint (i)"
      ],
      "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"
          ]
        }
      ]
    },
    {
      "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": "aaf4774f-0544-40f6-843b-619d00382cbd"
      },
      "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": "f7dd6db3-17e6-4be9-c5db-8a6dccc5a685"
      },
      "source": [
        "for i in range(1,11):\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": "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": "0747add6-95f0-47e9-ef94-3cfbf5bf3596"
      },
      "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": "923a950b-06f3-40ea-b0ca-c06f4c7e990e"
      },
      "source": [
        "print (\"Sum is --> \", sum(range(1,11)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum is -->  55\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": "9d304c28-608b-41f3-d342-61ab3856192b"
      },
      "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: 43\n",
            "Enter Second No: 21\n",
            "43  >  21\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zPayD7lwCJRW"
      },
      "source": [
        "---\n",
        "\n",
        "*   List item\n",
        "*   List item\n",
        "\n",
        "\n",
        "### **5.2 Check whether a number is odd or even**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I2ohfxlRCJRW",
        "outputId": "0eb1d424-269e-4fcc-94a2-be692a2fd971"
      },
      "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: 23\n",
            "23  is odd\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "861tynfFCJRX"
      },
      "source": [
        "---\n",
        "### **5.3 Check whether a number is prime of not**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q37Sy99JCJRZ",
        "outputId": "ba1dbaa4-4de1-4a39-b2cd-5494bdf06eac"
      },
      "source": [
        "n = int(input(\"Enter a No: \"))\n",
        "f=0\n",
        "for i in range(2, n//2 + 1):\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: 45\n",
            "Not Prime\n"
          ]
        }
      ]
    },
    {
      "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": "f2e0d94d-fcb3-4e56-9656-11731a1ea696"
      },
      "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\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter First String : User\n",
            "Enter Second String: Friend\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": "79091235-9b36-4bf2-f969-c9d63f28987b"
      },
      "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",
          "name": "stdout",
          "text": [
            "Add(10,20) --> 30\n",
            "Add(20,50) --> 70\n",
            "Add(80,200) --> 280\n"
          ]
        }
      ]
    },
    {
      "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": "aedb6493-e8ef-4360-f6af-f401c0861dbc"
      },
      "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\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": "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": "15ca7726-c737-4d8d-bcc4-8d041c555308"
      },
      "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": "429b9892-fc68-4232-aafa-8249d6b55d22"
      },
      "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": "cf487bb9-6d52-4a62-c7fe-fd676cbe4e85"
      },
      "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": "ee360fd3-9fe9-4358-cd10-9d6e5082e726"
      },
      "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",
          "name": "stdout",
          "text": [
            "String -->  Hello World!\n",
            "Length --> :  12\n",
            "Upper  --> :  HELLO WORLD!\n",
            "Lower  --> :  hello world!\n"
          ]
        }
      ]
    },
    {
      "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": "0b06a86a-6a3d-428c-880d-818449b0c27b"
      },
      "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",
          "name": "stdout",
          "text": [
            "Enter your name: Suresh\n",
            "Enter your age : 43\n",
            "Enter the book price: 39.90\n",
            "\n",
            "Your name is SURESH, age is 43 and book price is 39.900000\n"
          ]
        }
      ]
    },
    {
      "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": "b60ce422-8520-43f0-99bc-8ec6ba6c2f86"
      },
      "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)"
      ],
      "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": "9dac494c-98e8-45be-b1a4-bf881401b1da"
      },
      "source": [
        "var =\" Indian   Army    \"\n",
        "\n",
        "print(\"String    --> \", var)\n",
        "print(\"Length    --> \", len(var))\n",
        "print(\"var strip --> \", var.strip())\n",
        "print(\"Length of var after strip --> \", len(var.strip()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "String    -->   Indian   Army    \n",
            "Length    -->  18\n",
            "var strip -->  Indian   Army\n",
            "Length of var after strip -->  13\n"
          ]
        }
      ]
    },
    {
      "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": "8ec20ab9-042a-45a0-f367-238a0ec93f47"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "793a7051-3e1b-4778-8a16-9cb392a5501d"
      },
      "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",
          "name": "stdout",
          "text": [
            "String       -->   Indian Army    \n",
            "Count of ' ' -->  6\n",
            "Count of 'a' -->  1\n",
            "Count of 'n' -->  1\n"
          ]
        }
      ]
    },
    {
      "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": "186e72a0-999d-45f6-8614-1950b6cf6546"
      },
      "source": [
        "var=\"Indian Army\"\n",
        "print (\"String    --> \", var)\n",
        "print (\"var[::1]  --> \", var[::1])\n",
        "print (\"var[::2]  --> \", var[::2])\n",
        "print (\"var[::-1] --> \", var[::-1])\n",
        "print (\"var[::-2] --> \", var[::-2])\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": "1b7f3d89-4785-4e9a-e867-dea20969eedb"
      },
      "source": [
        "s1=\"Indian Army\"\n",
        "s2=\"malayalam\"\n",
        "s3=\"madam\"\n",
        "s4=\"teacher\"\n",
        "print (\"s1 --> \", s1==s1[::-1])\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": "c2620dd4-10c7-4a88-a925-315e0108880c"
      },
      "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.0836581959930992\n",
            "0.5332908563946105\n",
            "0.7008\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": "e8d51f6b-666b-4f46-95ae-d1f217efba95"
      },
      "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": [
            "58\n",
            "1\n",
            "5\n",
            "1\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": "534b24b5-e497-423c-803a-85aece872d51"
      },
      "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": [
            "47.44499207264831\n",
            "83.6664852763471\n",
            "1.430478777556715\n",
            "-4.218801688238902\n",
            "7.84\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": "f28cb676-dbf6-499c-9b2e-bcc195caeaf7"
      },
      "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": [
            "[5, 1, 7, 3]\n",
            "[10, 3]\n",
            "[20, 9]\n",
            "[-16, -45, 62, -68, -91]\n"
          ]
        }
      ]
    },
    {
      "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": "ca72fdc5-69ff-489e-f7c3-4be9cd62bb9c"
      },
      "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",
          "name": "stdout",
          "text": [
            "String        -->  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
            "Selected Char -->  ['U', 'P', 'v', 'n', 'I', 'h']\n",
            "passwd1       -->  UPvnIh\n",
            "passwd2       -->  U+P+v+n+I+h\n",
            "passwd3       -->  U*P*v*n*I*h\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": "03939f6d-7e09-44e2-d498-db1e6a6c14de"
      },
      "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', '3', '1', '4', '5']\n",
            "otp1          -->  93145\n",
            "Selected num2 -->  ['3', '5', '7', '2', '8']\n",
            "otp2          -->  35728\n",
            "Selected num2 -->  ['4', '1', '9', '5', '8']\n",
            "otp3          -->  41958\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": "791215e2-2f14-4bb3-b04f-25137b64bfae"
      },
      "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)\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 -->  ['O', 'k', 'A', 'N', 'i']\n",
            "mixPasswd1    -->  OkANi\n",
            "\n",
            "Selected Str2 -->  ['t', 'Q', 'b', 'N', 'm', 'i']\n",
            "mixPasswd2    -->  tQbNmi\n",
            "\n",
            "Selected Str3 -->  ['_', '~', 'j', 'B', '*', 'J', 'x', 'r']\n",
            "mixPasswd3    -->  _~jB*Jxr\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcdyFjhzJo9j"
      },
      "source": [
        "---\n",
        "# **10 Exception Handling**\n",
        "**Learning:** How to handle exceptions\n",
        "\n",
        "---\n",
        "### **10.1 Error Generation**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 283
        },
        "id": "vKJEy_SYJo9k",
        "outputId": "c5a3832b-867e-419f-c1c0-67ac72796c8d"
      },
      "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": "division by zero",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-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 handling for division by zero**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GY4t0EqjJo9m",
        "outputId": "62cf8737-2081-4ad1-8228-4aeed8b62fde"
      },
      "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 handling for array out of index**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m1rBOUB3Jo9n",
        "outputId": "939c4604-242b-42f3-d943-d58ca87cf9a6"
      },
      "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 handling for file not found**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zZ7ns4K3Jo9o",
        "outputId": "d40d00a6-7de9-4b56-f406-4f6a7cb7aea9"
      },
      "source": [
        "fileName=input(\"Enter File Name: \")\n",
        "fp=open(\"fileName.txt\",'w')\t# creating the file using writing mode\n",
        "fp=open(\"fileName.txt\") # Opening file in reading mode\n",
        "fp.close()\n",
        "print (\"Done\")"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Enter File Name: fileName.txt\n",
            "Done\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D4bffbZQJo9p"
      },
      "source": [
        "---\n",
        "### **10.5 Exception handling for file not found**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dt3X92CyJo9q",
        "outputId": "c5afd7eb-8c83-4e02-e8e5-b45c4487cc5f"
      },
      "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: test.txt\n",
            "Error !! \"test.txt\" 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": "26028d7f-41d4-4edb-b8f9-77dba6f69b18"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\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": "e1e42691-581b-49a3-ce69-f8cbb1cb22ee"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "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": "90db2e6f-3152-4fbf-c2c3-dd5bd7fd6beb"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "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": "c0a798a5-4d7c-468f-b597-6363e1135987"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original List -->  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "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": "620362e0-c20e-41d8-952d-f6825d4a2e6b"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "397e67a7-1fec-4b7c-f703-41973b37e6eb"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "7faf4863-1f44-4d33-952f-e305e65196ee"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "7b458b47-dd7e-4276-f811-f24c7b9bb79c"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "24d19176-713a-4578-db87-4dd10363bbb2"
      },
      "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": "3c122b95-2181-497f-df7f-4b384b1ebcda"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original List -->  True\n",
            "Original List -->  False\n",
            "Original List -->  True\n",
            "Present\n",
            "Present\n"
          ]
        }
      ]
    },
    {
      "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/"
        },
        "id": "T7Q4GKPaScFS",
        "outputId": "91c39ecd-316a-4df6-ddbf-f28b5e4d0d5f"
      },
      "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])"
      ],
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BxbeipLlScFS"
      },
      "source": [
        "---\n",
        "### **12.2 Traverse dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iWXBcVNTScFT",
        "outputId": "20ecfbb0-5481-4f77-e3b3-7ede153b0cf6"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "73defcba-0cd7-4230-809c-273a55ea2e47"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": 301
        },
        "id": "zO_QA0GNScFV",
        "outputId": "66e5feb1-782a-401d-f926-78d22b790cd9"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "name 'CGPA' is not defined",
          "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<cell line: 17>\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": "97f058de-9302-42b5-cf81-e18c9e3818f8"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "0196f56f-82e1-4060-b72b-ea240b7bc625"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "b6b0c285-eeb3-4954-ea37-554599f0f852"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "260f9e1c-961e-4c2a-b106-2a5bcb0efaa1"
      },
      "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",
          "name": "stdout",
          "text": [
            "T               --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Num of elements --> 4\n",
            "Type of Object  --> <class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6w09RiHeF-Io",
        "outputId": "2e1e55ef-cc60-413c-c008-71f70ffddf11"
      },
      "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",
          "name": "stdout",
          "text": [
            "T               --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Num of elements --> 4\n",
            "Type of Object  --> <class 'tuple'>\n"
          ]
        }
      ]
    },
    {
      "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": "7369d42f-1f4f-4ee9-a6c7-6ab75e36a151"
      },
      "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",
          "name": "stdout",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "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": "80bac8c3-8c97-4c51-d151-814abf38637e"
      },
      "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",
          "name": "stdout",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "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": "5dfd0fa0-0644-43e8-c032-f905e56a17a5"
      },
      "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",
          "name": "stdout",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "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": "6affd56f-1b52-4e24-c1d3-5507ae509605"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ex2S0y2tGzSH",
        "outputId": "e76adfbc-97c7-476d-fe3d-4fcbeb43dc82"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "e2072c8d-2a37-4197-da72-5bedbcf087d2"
      },
      "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",
          "name": "stdout",
          "text": [
            "T       --> (3, 6, 9, 12, 5, 3, 2)\n",
            "Sum     --> 40\n",
            "Average --> 5.714285714285714\n",
            "Average --> 5\n"
          ]
        }
      ]
    },
    {
      "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": "16783cc5-1839-4de8-ef68-6a613f3427ae"
      },
      "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",
          "name": "stdout",
          "text": [
            "T   --> (3, 6, 9, 12, 5, 3, 2)\n",
            "Max --> 12\n",
            "Min --> 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwCtFSUDHL50",
        "outputId": "9e3ce257-05c8-4908-859a-350321f925e7"
      },
      "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",
          "name": "stdout",
          "text": [
            "T   --> ('Ram', 'Shyam', 'Human', 'Ant')\n",
            "Max --> Shyam\n",
            "Min --> Ant\n"
          ]
        }
      ]
    },
    {
      "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": "c8c38f50-f212-43ba-a251-e46ab471341b"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": "08dcbe12-e275-408f-e41e-05607b9b92dd"
      },
      "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",
          "name": "stdout",
          "text": [
            "T1 --> (3, 6, 9)\n",
            "T2 --> (12, 5, 3, 2)\n",
            "T3 --> (6, 5, 3)\n",
            "T4 --> (3, 12)\n"
          ]
        }
      ]
    },
    {
      "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": "928a6f2c-644e-4722-f547-503103189a00"
      },
      "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",
          "name": "stdout",
          "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"
          ]
        }
      ]
    },
    {
      "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": 266
        },
        "outputId": "ed125c83-37c3-446f-ed12-355982d6c4d8"
      },
      "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",
          "name": "stdout",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'tuple' object does not support item assignment",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-79-fb1d27ae8658>\u001b[0m in \u001b[0;36m<cell line: 4>\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**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TWSdjWFfE4II",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d66b8590-e033-42f6-d6a7-5b55c3e16d93"
      },
      "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",
          "name": "stdout",
          "text": [
            "T         --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Add --> ('Pratham', 'Sharma', 3.14, 3, 9.8)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D8fE_Al0E4II"
      },
      "source": [
        "---\n",
        "### **13.13 Inserting element in Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bkvZ4s4yE4IJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c830181-8551-4e4c-f443-af3b52efa202"
      },
      "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",
          "name": "stdout",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Insert --> ('Pratham', 'Sharma', 'Rahul', 3.14, 3)\n"
          ]
        }
      ]
    },
    {
      "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": 266
        },
        "outputId": "f18734ef-42fc-45eb-f44f-07dd5f9bae18"
      },
      "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",
          "name": "stdout",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "'tuple' object doesn't support item deletion",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-82-0baff4d8a5c8>\u001b[0m in \u001b[0;36m<cell line: 4>\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": "0f8b9a23-4964-40e4-fadd-33b3dfd3a8f3"
      },
      "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",
          "name": "stdout",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Delete --> ('Pratham', 3.14, 3)\n"
          ]
        }
      ]
    },
    {
      "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": "88fe0b5f-7a77-4d73-eb67-b242be3ae8a8"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original set           -->  {'F', 'E', 'A', 'B'}\n",
            "Num of elements in set -->  4\n"
          ]
        }
      ]
    },
    {
      "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": "82b6aa99-fcc3-42ba-df47-5e5cf31e1ec4"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original set a      -->  {'F', 'E', 'A', 'B'}\n",
            "Original set b      -->  {'E', 'D', 'A', 'C'}\n",
            "Union of a and b    -->  {'F', 'E', 'D', 'A', 'C', 'B'}\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', 'B', 'D', 'C'}\n",
            "Symetric Diff b - a -->  {'F', 'D', 'C', 'B'}\n"
          ]
        }
      ]
    },
    {
      "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": "7bfd5c10-b400-48d7-976f-1e4e13342cf3"
      },
      "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",
          "name": "stdout",
          "text": [
            "Original set a       -->  {'F', 'E', 'A', 'B'}\n",
            "Set After Adding (D) -->  {'F', 'E', 'D', 'A', 'B'}\n",
            "Set After Adding (D) -->  {'F', 'E', 'D', 'A', 'B'}\n",
            "Set After Deleting(D)-->  {'F', 'E', 'A', 'B'}\n",
            "Set After pop        -->  {'E', 'A', 'B'}\n",
            "Set After pop        -->  {'A', 'B'}\n"
          ]
        }
      ]
    },
    {
      "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": 286
        },
        "id": "0ieaM9uebNAS",
        "outputId": "6e92856d-f29a-4ee7-c243-0ef1007636c8"
      },
      "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",
          "name": "stdout",
          "text": [
            "['/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-ec77039d-b3a9-4c52-a78e-ae484bab0b4b.json']\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "invalid literal for int() with base 10: '-f'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-87-a3d67294dc12>\u001b[0m in \u001b[0;36m<cell line: 3>\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": "4a6f2509-c246-4ad8-8091-865b5a080990"
      },
      "source": [
        "import sys\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",
          "name": "stdout",
          "text": [
            "['/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-ec77039d-b3a9-4c52-a78e-ae484bab0b4b.json']\n",
            "-f  +  /root/.local/share/jupyter/runtime/kernel-ec77039d-b3a9-4c52-a78e-ae484bab0b4b.json  -->  -f /root/.local/share/jupyter/runtime/kernel-ec77039d-b3a9-4c52-a78e-ae484bab0b4b.json\n"
          ]
        }
      ]
    },
    {
      "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": 286
        },
        "id": "QSHWbDHmbNAX",
        "outputId": "eba914e4-c7bf-4182-f34a-942c5a8d0722"
      },
      "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",
          "name": "stdout",
          "text": [
            "['/usr/local/lib/python3.10/dist-packages/colab_kernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-ec77039d-b3a9-4c52-a78e-ae484bab0b4b.json']\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "invalid literal for int() with base 10: '-f'",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-89-87063e0e9afe>\u001b[0m in \u001b[0;36m<cell line: 4>\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": "f86790db-5563-4e0b-fdda-4103e36d9688"
      },
      "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",
          "name": "stdout",
          "text": [
            "Writing done !! \n",
            "Open result.txt to view the content\n"
          ]
        }
      ]
    },
    {
      "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": "55440594-62bf-463a-ad37-80f26494e765"
      },
      "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",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ]
        }
      ]
    },
    {
      "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": "82e27035-cee3-4651-bf7e-94073a155e33"
      },
      "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",
        "\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",
          "name": "stdout",
          "text": [
            "Writing done !! \n",
            "Open result.txt to view the content\n"
          ]
        }
      ]
    }
  ]
}