Learn_Python_in_2_hr.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Learn Python in 2 hr.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "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/gurtaransingh01/gurtaransingh01/blob/main/Learn_Python_in_2_hr.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NgayMd7cK3U6"
      },
      "source": [
        "---\n",
        "# **Learn Python in 2 hr**\n",
        "---\n",
        "\n",
        "### There are 16 programs to explain the various concepts in python programming such as:\n",
        "\n",
        "- Syntex, \n",
        "- Loop, \n",
        "- if-else, \n",
        "- Data Structures, \n",
        "- Strings, \n",
        "- File Handaling, \n",
        "- Exception Handaling, \n",
        "- Random Numbers, \n",
        "- Command Line Argunment\n",
        "- Use of Libraries\n",
        "\n",
        "---\n",
        "### **Self learning resource**\n",
        "Tutorial on Python (Byte of Python) **<a href=\"https://python.swaroopch.com/\"> Click Here</a>** \n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "```\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "---\n",
        "# **1 Hello World**\n",
        "---\n",
        "**Learning:** How to print and run python program"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4JFo1WM8ZON",
        "outputId": "9c3125ad-fa32-4e64-a9ec-1aebef73f48b"
      },
      "source": [
        "print (\"Hello World\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello World\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "f9b98f75-2e72-496e-b725-ae0dd62774be"
      },
      "source": [
        "a = 10\t\t\t\t\n",
        "b = 220\n",
        "c = a + b       # Add two numbers\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "10  +  220  -->  230\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "140528c2-aac3-48c5-92fd-a516c1712084"
      },
      "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",
          "text": [
            "Bhagat  +   Singh  -->  Bhagat Singh\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "40b6dfa4-43ac-495e-f7e1-707acd41d177"
      },
      "source": [
        "a = \"Bhagat\"\n",
        "b = 100\n",
        "c = a + str(b)\t\t# Concatinate string with number\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Bhagat  +  100  -->  Bhagat100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "67ff1f56-a125-40e9-91fc-789406c22a55"
      },
      "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",
          "text": [
            "Enter First String: First\n",
            "Enter Second String: Second\n",
            "First  +  Second       -->  FirstSecond\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "2026019e-1148-4878-ace6-229f58b5bc73"
      },
      "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",
          "text": [
            "Enter First No: 34\n",
            "Enter Second No: 32\n",
            "34  +  32  -->  66\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "788a0402-f105-4f0a-f5b5-d8a305f39443"
      },
      "source": [
        "i=1\n",
        "while i <= 10:\n",
        "\tprint (i)\n",
        "\ti = i+1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "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": "8b8068a5-6dc5-458c-c906-31d7e1e276e8"
      },
      "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",
          "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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "e43f30d4-9d57-446f-c835-a9a75fe32fe9"
      },
      "source": [
        "for i in range(0,10):\n",
        "\tprint (i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "6085889a-1303-474a-bff9-156d5d121671"
      },
      "source": [
        "for i in range(0,20,2):\n",
        "\tprint (i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "2\n",
            "4\n",
            "6\n",
            "8\n",
            "10\n",
            "12\n",
            "14\n",
            "16\n",
            "18\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "986a1a88-49e3-4c4e-abfc-ce7548ac40fa"
      },
      "source": [
        "for i in range(0,-10,-1):\n",
        "\tprint (i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "0\n",
            "-1\n",
            "-2\n",
            "-3\n",
            "-4\n",
            "-5\n",
            "-6\n",
            "-7\n",
            "-8\n",
            "-9\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "a0dfa6a2-7bfc-4a6e-c08a-6881efb93958"
      },
      "source": [
        "for i in range(1,11):\n",
        "\tprint (5,\" * \", i , \" = \", i * 5)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "d0a479f7-0214-4234-f9e6-8a03af1f21e2"
      },
      "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",
          "text": [
            "Sum is -->  55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "86ed854d-7fca-4d0e-ddd2-f69df8d43630"
      },
      "source": [
        "print (\"Sum is --> \", sum(range(1,11)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Sum is -->  55\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "4a790304-49ac-4575-fc47-cb291ff76aad"
      },
      "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",
          "text": [
            "Enter First No: 49\n",
            "Enter Second No: 54\n",
            "49  <  54\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zPayD7lwCJRW"
      },
      "source": [
        "---\n",
        "### **5.2 Check weather a number is odd or even**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I2ohfxlRCJRW",
        "outputId": "61a95fd4-5ada-4757-96e3-e2720584d318"
      },
      "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",
          "text": [
            "Enter a No: 54\n",
            "54  is even\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "861tynfFCJRX"
      },
      "source": [
        "---\n",
        "### **5.3 Check weather a number is prime of not**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q37Sy99JCJRZ",
        "outputId": "6b895ee6-7188-4989-e6a0-f37da120d798"
      },
      "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",
          "text": [
            "Enter a No: 56\n",
            "Not Prime\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "f8da10e9-ca73-4cdb-cdeb-a1d62ce9bf07"
      },
      "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",
          "text": [
            "Enter First String : Number\n",
            "Enter Second String: Prime\n",
            "a < b\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bPPQtf1ACJRg"
      },
      "source": [
        "**Assingment 5.1:** WAP to find max amoung three numbers and input from user. [Try max() function]\n",
        "\n",
        "**Assingment 5.2:** WAP to add all numbers divisible by 7 and 9 from 1 to n and n is given by the user.\n",
        "\n",
        "**Assingment 5.3:** WAP to add all prime numbers from 1 to n and n is given by the user.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_dC1CuVnDipZ"
      },
      "source": [
        "---\n",
        "# **6 Functions**\n",
        "**Learning:** How to declare and call function\n",
        "\n",
        "---\n",
        "### **6.1 Add two numbers**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Vw-ZYlDDipb",
        "outputId": "7adb0a45-6035-4592-ecf5-f9f87d03251c"
      },
      "source": [
        "def Add(a,b):\n",
        "\tc=a+b\n",
        "\treturn c\n",
        "\n",
        "print (\"Add(10,20) -->\", Add(10,20))\n",
        "print (\"Add(20,50) -->\", Add(20,50)) \n",
        "print (\"Add(80,200) -->\", Add(80,200)) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Add(10,20) --> 30\n",
            "Add(20,50) --> 70\n",
            "Add(80,200) --> 280\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ygKAg2QjDipc"
      },
      "source": [
        "---\n",
        "### **6.2 Prime number**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sg8feM_YDipc",
        "outputId": "ec4a8a27-a227-4bd7-ec70-fbf3afd93960"
      },
      "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",
          "text": [
            "IsPrime(20)  -->  0\n",
            "IsPrime(23)  -->  1\n",
            "IsPrime(200) -->  0\n",
            "IsPrime(37)  -->  1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "b7f89113-8a94-469f-b85f-99829095a78f"
      },
      "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",
          "text": [
            "AddN(10)  -->  55\n",
            "AddN(20)  -->  210\n",
            "AddN(50)  -->  1275\n",
            "AddN(200) -->  20100\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "3f49f051-2d38-4c0c-83c3-faeee56a782b"
      },
      "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",
          "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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "20653a54-1770-495c-81ba-c65929f56b37"
      },
      "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",
          "text": [
            "var      -->  Hello World!\n",
            "var[0]   -->  H\n",
            "var[1:5] -->  ello\n",
            "var[:-5] -->  Hello W\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X9V-dQU-E7nd"
      },
      "source": [
        "---\n",
        "### **8.2 String length, upper, lower**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "y8HSuWkEE7ne",
        "outputId": "665122c7-2036-48f9-e93d-fb1229f9fc4a"
      },
      "source": [
        "var = 'Hello World!'\n",
        "print (\"String --> \", var)\n",
        "print (\"Length --> : \", len(var))\n",
        "print (\"Upper  --> : \", var.upper())\n",
        "print (\"Lower  --> : \", var.lower())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String -->  Hello World!\n",
            "Length --> :  12\n",
            "Upper  --> :  HELLO WORLD!\n",
            "Lower  --> :  hello world!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4ySbLzf1Fpi5"
      },
      "source": [
        "---\n",
        "### **8.3 String formatting**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RDB15138Fpi6",
        "outputId": "a1997e5d-5fdc-4a9b-aade-363201e342b4"
      },
      "source": [
        "name=input(\"Enter your name: \")\n",
        "age=int(input(\"Enter your age : \"))\n",
        "price=float(input(\"Enter the book price: \"))\n",
        "s=\"\\nYour name is %s, age is %d and book price is %f\" %(name.upper(),age,price)\n",
        "print (s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter your name: Rohan\n",
            "Enter your age : 21\n",
            "Enter the book price: 45.34\n",
            "\n",
            "Your name is ROHAN, age is 21 and book price is 45.340000\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "27Y8Dk7XFp1F"
      },
      "source": [
        "---\n",
        "### **8.4 String in Triple Quotes**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiOlVj37Fp1H",
        "outputId": "ebac4b97-1a7f-4854-9bcd-873fa7d7a682"
      },
      "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",
          "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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WK4GTOeIFp-I"
      },
      "source": [
        "---\n",
        "### **8.5 String strip**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tXJQREI3Fp-J",
        "outputId": "3d911b3e-2d9e-4630-81cc-f6fdadb45ecc"
      },
      "source": [
        "var =\" Indian   Army    \"\n",
        "\n",
        "print(\"String    --> \", var)\n",
        "print(\"Length    --> \", len(var))\n",
        "print(\"var strip --> \", var.strip())\n",
        "print(\"Length of var after strip --> \", len(var.strip()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String    -->   Indian   Army    \n",
            "Length    -->  18\n",
            "var strip -->  Indian   Army\n",
            "Length of var after strip -->  13\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_aSibOwQFqFC"
      },
      "source": [
        "---\n",
        "### **8.6 String split**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "02uwsbaQFqFD",
        "outputId": "d13dedba-6188-476e-d0c5-4221ef0094e0"
      },
      "source": [
        "var =\" Indian,   Army    \"\n",
        "\n",
        "print(\"String    --> \", var)\n",
        "print(\"Length    --> \", len(var))\n",
        "print(\"var split --> \", var.split())\n",
        "print(\"var split --> \", var.split(' '))\n",
        "print(\"var split --> \", var.split(','))\n",
        "\n",
        "# Strip + Split\n",
        "print(\"var split --> \", var.strip().split(','))\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String    -->   Indian,   Army    \n",
            "Length    -->  19\n",
            "var split -->  ['Indian,', 'Army']\n",
            "var split -->  ['', 'Indian,', '', '', 'Army', '', '', '', '']\n",
            "var split -->  [' Indian', '   Army    ']\n",
            "var split -->  ['Indian', '   Army']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TgsO9gfoFqMV"
      },
      "source": [
        "---\n",
        "### **8.7 Count in string**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lwrJzwy6FqMV",
        "outputId": "520d3e04-546c-40ec-a438-75567a4bdfcb"
      },
      "source": [
        "var=\" Indian Army    \"\n",
        "print (\"String       --> \", var)\n",
        "print (\"Count of ' ' --> \", var.count(' '))\n",
        "print (\"Count of 'a' --> \", var.count('a'))\n",
        "print (\"Count of 'n' --> \", var.count('an'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String       -->   Indian Army    \n",
            "Count of ' ' -->  6\n",
            "Count of 'a' -->  1\n",
            "Count of 'n' -->  1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RYP11CU5FqUJ"
      },
      "source": [
        "---\n",
        "### **8.8 Reverse a String**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QSXd_wfOFqUK",
        "outputId": "594924ca-0e60-44dc-957d-406535e88449"
      },
      "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",
          "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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "bc08d6a1-24f0-488f-fa00-ed44a2865233"
      },
      "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",
          "text": [
            "s1 -->  False\n",
            "s2 -->  True\n",
            "s3 -->  True\n",
            "s4 -->  False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "7aa3c575-96b4-4c5b-8659-88a061679754"
      },
      "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",
          "text": [
            "0.7512486175763348\n",
            "0.5015832763034391\n",
            "0.7335\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "d069e11a-9070-44c7-96cc-f6d0b6255002"
      },
      "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",
          "text": [
            "88\n",
            "47\n",
            "-5\n",
            "4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "3b15eac5-363d-4def-c3c1-a06409ed9bca"
      },
      "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",
          "text": [
            "97.39127815370512\n",
            "99.35262788984427\n",
            "1.5886268848088747\n",
            "-4.72371568384482\n",
            "3.54\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "64fe4ee7-df56-4420-fc2c-4a5dd1f2c66e"
      },
      "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",
          "text": [
            "[1, 8, 10, 3]\n",
            "[3, 8]\n",
            "[60, 70]\n",
            "[12, -55, 54, -86, 30]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cgEXGBtsG0Np"
      },
      "source": [
        "---\n",
        "### **9.5 Generate random string**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "T-FHSfgfG0Nq",
        "outputId": "ac7eacd3-32fb-4ee9-8d0d-7adbb6750ef3"
      },
      "source": [
        "import string as s\n",
        "import random as r\n",
        "print (\"String        --> \",s.ascii_letters)\n",
        "\n",
        "passwd=r.sample(s.ascii_letters, 6)\n",
        "print (\"Selected Char --> \",passwd)\n",
        "\n",
        "passwd1=\"\".join(passwd)\n",
        "print (\"passwd1       --> \",passwd1)\n",
        "\n",
        "passwd2=\"+\".join(passwd)\n",
        "print (\"passwd2       --> \",passwd2)\n",
        "\n",
        "passwd3=\"*\".join(passwd)\n",
        "print (\"passwd3       --> \",passwd3)\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "String        -->  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\n",
            "Selected Char -->  ['h', 's', 'Z', 'l', 'P', 'k']\n",
            "passwd1       -->  hsZlPk\n",
            "passwd2       -->  h+s+Z+l+P+k\n",
            "passwd3       -->  h*s*Z*l*P*k\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "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": "d8897de6-3ff1-4b1e-e0bc-9f9e96aa4af5"
      },
      "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",
          "text": [
            "Digits -->  0123456789\n",
            "Selected num1 -->  ['1', '7', '8', '2', '9']\n",
            "otp1          -->  17829\n",
            "Selected num2 -->  ['1', '3', '9', '5', '2']\n",
            "otp2          -->  13952\n",
            "Selected num2 -->  ['0', '2', '1', '6', '3']\n",
            "otp3          -->  02163\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "476a595c-72d8-4e1c-dec6-d86255cc7891"
      },
      "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",
          "text": [
            "String + Digits -->  abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n",
            "\n",
            "Selected Str1 -->  ['e', 'K', 't', 'o', 'R']\n",
            "mixPasswd1    -->  eKtoR\n",
            "\n",
            "Selected Str2 -->  ['D', 'u', 'J', '5', 'T', 'M']\n",
            "mixPasswd2    -->  DuJ5TM\n",
            "\n",
            "Selected Str3 -->  ['p', 'W', '{', 'b', '_', '+', '6', '#']\n",
            "mixPasswd3    -->  pW{b_+6#\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WcdyFjhzJo9j"
      },
      "source": [
        "---\n",
        "# **10 Exception Handaling**\n",
        "**Learning:** How to handle exceptions\n",
        "\n",
        "---\n",
        "### **10.1 Error Generation**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 284
        },
        "id": "vKJEy_SYJo9k",
        "outputId": "799263a1-1890-448e-d38a-a063b1882da7"
      },
      "source": [
        "for i in range(-5,6):\n",
        "\tprint (\"100/\",i,\" --> \", 100/i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "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"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-39-5eb017879ab5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m         \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"100/\"\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\" --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ulPZfl8rJo9l"
      },
      "source": [
        "---\n",
        "### **10.2 Exception handaling for division by zero**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GY4t0EqjJo9m",
        "outputId": "9a324274-253f-47b6-b2a2-a83701d26e4e"
      },
      "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",
          "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"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g1cY_zT3Jo9m"
      },
      "source": [
        "---\n",
        "### **10.3 Exception handaling for array out of index**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m1rBOUB3Jo9n",
        "outputId": "2fec1232-4f5a-4ced-e0e9-531222be5bd7"
      },
      "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",
          "text": [
            "0  -->  1\n",
            "1  -->  2\n",
            "2  -->  3\n",
            "3  -->  4\n",
            "4  -->  5\n",
            "error\n",
            "error\n",
            "error\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kH8CATzbJo9o"
      },
      "source": [
        "---\n",
        "### **10.4 Exception handaling for file not found**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 247
        },
        "id": "zZ7ns4K3Jo9o",
        "outputId": "f9528caa-006f-4fca-8ec3-52ef62c15496"
      },
      "source": [
        "fileName=input(\"Enter File Name: \")\n",
        "fp=open(fileName)\t# Open the file in reading mode\n",
        "fp.close()\n",
        "print (\"Done\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter File Name: SampleFile.csv\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "FileNotFoundError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-42-df3155df6860>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mfileName\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minput\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Enter File Name: \"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mopen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfileName\u001b[0m\u001b[0;34m)\u001b[0m       \u001b[0;31m# Open the file in reading mode\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0mfp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclose\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Done\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'SampleFile.csv'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D4bffbZQJo9p"
      },
      "source": [
        "---\n",
        "### **10.5 Exception handaling for file not found**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dt3X92CyJo9q",
        "outputId": "c8fabf60-befe-4a7b-d824-8beb1a4d0519"
      },
      "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",
          "text": [
            "Enter File Name: test.csv\n",
            "Error !! \"test.csv\" File Not Found\n",
            "Done\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "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": "75896dff-cfc4-4082-9381-12597364642b"
      },
      "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",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Number of elements in list:  4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xyP5tZ7IPcat"
      },
      "source": [
        "---\n",
        "### **11.2 List Iteration**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TIalxne5Pcat",
        "outputId": "5674a59c-235b-4ce9-fa39-e0fddfdd5212"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List: \", L)\n",
        "i=0\n",
        "while i < len(L): \n",
        "\tprint (L[i])\n",
        "\ti+=1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fpkfQhktPcau"
      },
      "source": [
        "---\n",
        "### **11.3 List Iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "p6mVPS1pPcau",
        "outputId": "2dccab82-5f6a-41e7-e4f4-d79dc96c205a"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List: \", L)\n",
        "for i in range(0, len(L)):\n",
        "\tprint (L[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List:  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CouKDMO1Pcav"
      },
      "source": [
        "---\n",
        "### **11.4 List Iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yT0MDFBJPcaw",
        "outputId": "79a9a0f2-ef79-4232-88dc-286999cd6d19"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List --> \", L)\n",
        "for s in L:\n",
        "\tprint (s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  ['Pratham', 'Sharma', 3.14, 3]\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XeroS2dsPcay"
      },
      "source": [
        "---\n",
        "### **11.5 Adding and deleting from list**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rWUOXQitPcay",
        "outputId": "27c3825f-be83-4379-9d26-e0f9efb1d0bc"
      },
      "source": [
        "L = [\"Pratham\",  'Sharma', 3.14,  3 ]\n",
        "print (\"Original List       --> \", L)\n",
        "\n",
        "L.append(\"Rahul\")\n",
        "print (\"List After Adding   --> \", L)\n",
        "\n",
        "del L[1]\n",
        "print (\"List After Deleting --> \", L)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List       -->  ['Pratham', 'Sharma', 3.14, 3]\n",
            "List After Adding   -->  ['Pratham', 'Sharma', 3.14, 3, 'Rahul']\n",
            "List After Deleting -->  ['Pratham', 3.14, 3, 'Rahul']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_DxAr9ZfPcaz"
      },
      "source": [
        "---\n",
        "### **11.6 Sum/Average of List**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "taKMcEajPca1",
        "outputId": "6d953543-b1e3-4554-e28c-0f6553fbe22f"
      },
      "source": [
        "L=[3, 6, 9, 12, 5, 3, 2]\n",
        "print (\"Original List --> \", L)\n",
        "\n",
        "print (\"Sum     --> \", sum(L))\n",
        "print (\"Average --> \", sum(L)/len(L))\n",
        "print (\"Average --> \", sum(L)//len(L))\n",
        "\n",
        "print (\"L * 3   --> \", L * 3)     # Every element get tripled\n",
        "print (\"L + L   --> \", L + L)     # Every element get doubled"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "Sum     -->  40\n",
            "Average -->  5.714285714285714\n",
            "Average -->  5\n",
            "L * 3   -->  [3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2]\n",
            "L + L   -->  [3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2SIEcqKePca1"
      },
      "source": [
        "---\n",
        "### **11.7 Min/Max/Sort the list**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NUsOwblSPca1",
        "outputId": "eb8f00cd-0cdb-45c8-df00-94d8cace3534"
      },
      "source": [
        "L=[3, 6, 9, 12, 5, 3, 2]\n",
        "print (\"Original List --> \", L)\n",
        "\n",
        "print (\"max --> \", max(L))\n",
        "print (\"min --> \", min(L))\n",
        "\n",
        "print (\"\\nBefore Sort            --> \", L)\n",
        "L.sort()\n",
        "\n",
        "print (\"After Sort (Asending)  --> \", L)\n",
        "\n",
        "L.sort(reverse=True)\n",
        "print (\"After Sort (Desending) --> \", L)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "max -->  12\n",
            "min -->  2\n",
            "\n",
            "Before Sort            -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "After Sort (Asending)  -->  [2, 3, 3, 5, 6, 9, 12]\n",
            "After Sort (Desending) -->  [12, 9, 6, 5, 3, 3, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pX_P07ODQoQM"
      },
      "source": [
        "---\n",
        "### **11.8 Merge lists and select elements**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pf8csu4yQoQO",
        "outputId": "136ff95d-91e5-4770-9ce6-d74148629add"
      },
      "source": [
        "L1 = [3, 6, 9]\n",
        "L2 = [12, 5, 3, 2]\n",
        "L3 = L1 + L2\n",
        "print (\"L1 --> \",L1)\n",
        "print (\"L2 --> \",L2)\n",
        "print (\"L3 --> \",L3)\n",
        "\n",
        "print (\"\\nL3[2:]  --> \",L3[2:])\n",
        "print (\"L3[2:5] --> \",L3[2:5])\n",
        "print (\"L3[:-1] --> \",L3[:-1])\n",
        "print (\"L3[::2] --> \",L3[::2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "L1 -->  [3, 6, 9]\n",
            "L2 -->  [12, 5, 3, 2]\n",
            "L3 -->  [3, 6, 9, 12, 5, 3, 2]\n",
            "\n",
            "L3[2:]  -->  [9, 12, 5, 3, 2]\n",
            "L3[2:5] -->  [9, 12, 5]\n",
            "L3[:-1] -->  [3, 6, 9, 12, 5, 3]\n",
            "L3[::2] -->  [3, 9, 5, 2]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2fxU9VLhQpGB"
      },
      "source": [
        "---\n",
        "### **11.9 Multiply all elements of the list by a constant**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Karxlcp6QpGC",
        "outputId": "27cd26f2-cf28-4328-a088-8f6ed75f3d53"
      },
      "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",
          "text": [
            "Original List -->  [12, 5, 3, 2, 7]\n",
            "After Multiply with constant -->  [60, 25, 15, 10, 35]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S9_QezrcQpQ9"
      },
      "source": [
        "---\n",
        "### **11.10 Searching in the list**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZptMehxhQpQ9",
        "outputId": "fdaf258e-90d3-4e6e-d06c-094ad056e023"
      },
      "source": [
        "L=[3, 6, 9, 12, 5, 3, 2]\n",
        "print (\"Original List --> \", 6 in L)\n",
        "print (\"Original List --> \", 10 in L)\n",
        "print (\"Original List --> \", 12 in L)\n",
        "\n",
        "if (6 in L) == True:\n",
        "\tprint (\"Present\")\n",
        "else:\n",
        "\tprint (\"Not Present\")\n",
        "\n",
        "if 10 in L == False:\n",
        "\tprint (\"Not Present\")\n",
        "else:\n",
        "\tprint (\"Present\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original List -->  True\n",
            "Original List -->  False\n",
            "Original List -->  True\n",
            "Present\n",
            "Present\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zHAa4y1BScFQ"
      },
      "source": [
        "---\n",
        "# **12 Data Structure 2 - Dictionary**\n",
        "**Learning:** How to use Dictionary, add, delete, search in Dictionary\n",
        "\n",
        "**Note:** Read more about Dictionary and try yourself\n",
        "\n",
        "---\n",
        "### **12.1 Declare Dictionary**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "T7Q4GKPaScFS",
        "outputId": "cb279f68-3e4b-45b3-8547-c226fcfc5ce8"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "print (\"Dictionary      --> \", CGPA)\n",
        "print (\"Num of elements --> \", len(CGPA))\n",
        "\n",
        "print (\"CGPA of 1       --> \", CGPA[1])\n",
        "print (\"CGPA of 4       --> \", CGPA[4])\n",
        "print (\"CGPA of 7       --> \", CGPA[7])\n",
        "print (\"CGPA of 3       --> \", CGPA[3])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dictionary      -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "Num of elements -->  5\n",
            "CGPA of 1       -->  8.9\n",
            "CGPA of 4       -->  6.7\n",
            "CGPA of 7       -->  9.1\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "KeyError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-54-598d6ecb7ab2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"CGPA of 4       --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"CGPA of 7       --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m7\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"CGPA of 3       --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mKeyError\u001b[0m: 3"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BxbeipLlScFS"
      },
      "source": [
        "---\n",
        "### **12.2 Triverse dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iWXBcVNTScFT",
        "outputId": "5e82b4d3-1d6f-42de-e2fc-a622de21f788"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "for k in CGPA:\n",
        "\tprint (\"CGPA of \", k, \" --> \", CGPA[k])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "CGPA of  1  -->  8.9\n",
            "CGPA of  2  -->  5.6\n",
            "CGPA of  4  -->  6.7\n",
            "CGPA of  7  -->  9.1\n",
            "CGPA of  8  -->  5.3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O721iFiOScFT"
      },
      "source": [
        "---\n",
        "### **12.3 Getting Keys and Values**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dnPH-GCyScFU",
        "outputId": "6e824afc-ef7b-4b98-e6fb-4b09f7fb3430"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "print (\"Dictionary --> \", CGPA)\n",
        "print (\"Keys       --> \", list(CGPA.keys()))\n",
        "print (\"Values     --> \", list(CGPA.values()))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Dictionary -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "Keys       -->  [1, 2, 4, 7, 8]\n",
            "Values     -->  [8.9, 5.6, 6.7, 9.1, 5.3]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v2ooUfguScFV"
      },
      "source": [
        "---\n",
        "### **12.4 Updating, Adding and Deleting from Dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 303
        },
        "id": "zO_QA0GNScFV",
        "outputId": "59cef6de-2f0a-43be-f64c-f54ef4369bb4"
      },
      "source": [
        "CGPA={1:8.9,2:5.6,4:6.7,7:9.1,8:5.3}\n",
        "print (\"Original Dictionary --> \", CGPA)\n",
        "\n",
        "CGPA[4] = 9.2\n",
        "print (\"After Updating (4)  --> \", CGPA)\n",
        "\n",
        "CGPA[3] = 8.6\n",
        "print (\"After Adding (3)    --> \", CGPA)\n",
        "\n",
        "del CGPA[1]\n",
        "print (\"After Deleting (1)  --> \", CGPA)\n",
        "\n",
        "CGPA.clear()\n",
        "print (\"After Clear         --> \", CGPA)\n",
        "\n",
        "del CGPA\n",
        "print (\"After Delete        --> \", CGPA)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "After Updating (4)  -->  {1: 8.9, 2: 5.6, 4: 9.2, 7: 9.1, 8: 5.3}\n",
            "After Adding (3)    -->  {1: 8.9, 2: 5.6, 4: 9.2, 7: 9.1, 8: 5.3, 3: 8.6}\n",
            "After Deleting (1)  -->  {2: 5.6, 4: 9.2, 7: 9.1, 8: 5.3, 3: 8.6}\n",
            "After Clear         -->  {}\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "NameError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-57-81104b3723b2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m     15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     16\u001b[0m \u001b[0;32mdel\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 17\u001b[0;31m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"After Delete        --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mCGPA\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNameError\u001b[0m: name 'CGPA' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8SPV0FVyScFW"
      },
      "source": [
        "---\n",
        "### **12.5 Checking for Key in Dictionary**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bwt-yAtpScFW",
        "outputId": "effceb1d-b3af-4edc-8ce2-454f1e65642f"
      },
      "source": [
        "CGPA={1:8.9, 2:5.6, 4:6.7, 7:9.1, 8:5.3}\n",
        "print (\"Original Dictionary --> \", CGPA)\n",
        "print (\"Is Key 2 Present    --> \", 2 in CGPA)\n",
        "print (\"Is Key 9 Present    --> \", 9 in CGPA)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {1: 8.9, 2: 5.6, 4: 6.7, 7: 9.1, 8: 5.3}\n",
            "Is Key 2 Present    -->  True\n",
            "Is Key 9 Present    -->  False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_KifQnHnScFX"
      },
      "source": [
        "---\n",
        "### **12.6 More example1**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tM4fQro9ScFZ",
        "outputId": "0fae7659-153f-428a-c06f-be64b001f00e"
      },
      "source": [
        "HomeTown={\"Prashant\":\"Delhi\", \"Govind\":\"Gwalior\", \"Anil\":\"Morena\", \"Pankaj\":\"Agra\"}\n",
        "print (\"Original Dictionary --> \", HomeTown)\n",
        "print (\"Home Town of Prashant is --> \", HomeTown[\"Prashant\"])\n",
        "print (\"Home Town of Govind is   --> \", HomeTown[\"Govind\"])\n",
        "print (\"Home Town of Anil is     --> \", HomeTown[\"Anil\"])\n",
        "print (\"Home Town of Pankaj is   --> \", HomeTown[\"Pankaj\"])\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {'Prashant': 'Delhi', 'Govind': 'Gwalior', 'Anil': 'Morena', 'Pankaj': 'Agra'}\n",
            "Home Town of Prashant is -->  Delhi\n",
            "Home Town of Govind is   -->  Gwalior\n",
            "Home Town of Anil is     -->  Morena\n",
            "Home Town of Pankaj is   -->  Agra\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZQIFxo4GScFa"
      },
      "source": [
        "---\n",
        "### **12.7 More example2**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hOADMSpvScFa",
        "outputId": "b3418002-b0ed-410f-f6c9-55a0f3158b88"
      },
      "source": [
        "HomeTown={\"Prashant\":\"Delhi\", \"Govind\":\"Gwalior\", \"Anil\":\"Morena\", \"Pankaj\":\"Agra\"}\n",
        "print (\"Original Dictionary --> \", HomeTown)\n",
        "\n",
        "for d in HomeTown:\n",
        "\tprint (\"Home Town of \", d, \" is  --> \", HomeTown[d])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original Dictionary -->  {'Prashant': 'Delhi', 'Govind': 'Gwalior', 'Anil': 'Morena', 'Pankaj': 'Agra'}\n",
            "Home Town of  Prashant  is  -->  Delhi\n",
            "Home Town of  Govind  is  -->  Gwalior\n",
            "Home Town of  Anil  is  -->  Morena\n",
            "Home Town of  Pankaj  is  -->  Agra\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hom72Xe6Z1sJ"
      },
      "source": [
        "---\n",
        "# **13 Data Structure 3 - Tuple**\n",
        "\n",
        "**Learning:** How to use Tuple, add, delete, search in Tuple\n",
        "\n",
        "**Note:** Read more about Tuple and try yourself\n",
        "\n",
        "---\n",
        "### **13.1 Declare Tuple**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "au4DzzGyFysT",
        "outputId": "0b0400d0-99ce-4161-f3ed-519f7400ffc5"
      },
      "source": [
        "# Method 1\n",
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "\n",
        "print (\"T               -->\", T)\n",
        "print (\"Num of elements -->\", len(T))\n",
        "print (\"Type of Object  -->\", type(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T               --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Num of elements --> 4\n",
            "Type of Object  --> <class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6w09RiHeF-Io",
        "outputId": "2c368a8c-c5bc-43cc-854a-fee6c8185cba"
      },
      "source": [
        "# Method 2\n",
        "T = tuple([\"Pratham\", 'Sharma', 3.14, 3])   # Convert list to tuple\n",
        "#T = tuple((\"Pratham\", 'Sharma', 3.14, 3))  # Also Works\n",
        "\n",
        "print (\"T               -->\", T)\n",
        "print (\"Num of elements -->\", len(T))\n",
        "print (\"Type of Object  -->\", type(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T               --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Num of elements --> 4\n",
            "Type of Object  --> <class 'tuple'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sC3XhTJtFysW"
      },
      "source": [
        "---\n",
        "### **13.2 Tuple Iteration**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pama9SlbFysX",
        "outputId": "9b100c56-ffdc-464d-bbf3-c34ba7a6a55c"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "i = 0\n",
        "while i < len(T): \n",
        "    print (T[i])\n",
        "    i += 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xk0P6u4BFysY"
      },
      "source": [
        "---\n",
        "### **13.3 Tuple iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "N73bUXRDFysZ",
        "outputId": "af8e2b82-d097-4f31-f5ec-59ac3643e5db"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "for i in range(0, len(T)):\n",
        "    print (T[i])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGZWqnebFysa"
      },
      "source": [
        "---\n",
        "### **13.4 Tuple iteration using for loop**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y6L2BeBcFysb",
        "outputId": "8855ebf5-3d7b-41e4-840f-2ac08a20074b"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "for s in T:\n",
        "    print (s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "Pratham\n",
            "Sharma\n",
            "3.14\n",
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "TsjuXQqfFysc"
      },
      "source": [
        "---\n",
        "### **13.5 Accessing/Selecting in Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FgB4s6OtFysc",
        "outputId": "c296adb6-134a-4226-eb46-b78aa2d559f7"
      },
      "source": [
        "# Example 1:\n",
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T     -->\", T)\n",
        "\n",
        "print (\"T[1]  -->\", T[1])\n",
        "print (\"T[2]  -->\", T[2])\n",
        "print (\"T[-1] -->\", T[-1])\n",
        "print (\"T[-2] -->\", T[-2])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T     --> (3, 6, 9, 12, 5, 3, 2)\n",
            "T[1]  --> 6\n",
            "T[2]  --> 9\n",
            "T[-1] --> 2\n",
            "T[-2] --> 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ex2S0y2tGzSH",
        "outputId": "0bfaaa6d-ec22-4565-c976-21dee9073d21"
      },
      "source": [
        "# Example 2:\n",
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T        -->\", T)\n",
        "\n",
        "print (\"T[1:3]   -->\", T[1:3])\n",
        "print (\"T[2:]    -->\", T[2:])\n",
        "print (\"T[2:5]   -->\", T[2:5])\n",
        "print (\"T[:2]    -->\", T[:2])\n",
        "print (\"T[:-1]   -->\", T[:-1])\n",
        "print (\"T[-4:-1] -->\", T[-4:-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T        --> (3, 6, 9, 12, 5, 3, 2)\n",
            "T[1:3]   --> (6, 9)\n",
            "T[2:]    --> (9, 12, 5, 3, 2)\n",
            "T[2:5]   --> (9, 12, 5)\n",
            "T[:2]    --> (3, 6)\n",
            "T[:-1]   --> (3, 6, 9, 12, 5, 3)\n",
            "T[-4:-1] --> (12, 5, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IYCHgXGZFyse"
      },
      "source": [
        "---\n",
        "### **13.6 Sum/Average of Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1sSPfUTGFysf",
        "outputId": "16d17e2a-4dec-4b4b-8be3-2ad47aa56978"
      },
      "source": [
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T       -->\", T)\n",
        "print (\"Sum     -->\", sum(T))\n",
        "print (\"Average -->\", sum(T)/len(T))\n",
        "print (\"Average -->\", sum(T)//len(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T       --> (3, 6, 9, 12, 5, 3, 2)\n",
            "Sum     --> 40\n",
            "Average --> 5.714285714285714\n",
            "Average --> 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E_Je9dVxFysg"
      },
      "source": [
        "---\n",
        "### **13.7 Min/Max in Tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tNsc-7xEFysi",
        "outputId": "52c79168-37c0-424c-a60a-f438f4795d1a"
      },
      "source": [
        "# Example 1\n",
        "T = (3, 6, 9, 12, 5, 3, 2)                # Integer Tuple\n",
        "print (\"T   -->\", T)\n",
        "print (\"Max -->\", max(T))\n",
        "print (\"Min -->\", min(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T   --> (3, 6, 9, 12, 5, 3, 2)\n",
            "Max --> 12\n",
            "Min --> 2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mwCtFSUDHL50",
        "outputId": "f19848de-93c7-4eb9-8b0d-cba7f147d56a"
      },
      "source": [
        "# Example 2\n",
        "T = (\"Ram\", \"Shyam\", \"Human\", \"Ant\")      # String Tuple\n",
        "print (\"T   -->\", T)\n",
        "print (\"Max -->\", max(T))\n",
        "print (\"Min -->\", min(T))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T   --> ('Ram', 'Shyam', 'Human', 'Ant')\n",
            "Max --> Shyam\n",
            "Min --> Ant\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WUNgIs62Fysi"
      },
      "source": [
        "---\n",
        "### **13.8 Merging Tuples**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zqz9Xp0tFysj",
        "outputId": "ca983a47-6fe3-4617-ca55-7fd004404371"
      },
      "source": [
        "T1 = (3, 6, 9)\n",
        "T2 = (12, 5, 3, 2)\n",
        "\n",
        "print (\"T1 -->\", T1)\n",
        "print (\"T2 -->\", T2)\n",
        "\n",
        "T3 = T1 + T2\n",
        "print (\"T3 -->\", T3)\n",
        "\n",
        "T4 = T1 + T2 + T1 + T2\n",
        "print (\"T4 -->\", T4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T1 --> (3, 6, 9)\n",
            "T2 --> (12, 5, 3, 2)\n",
            "T3 --> (3, 6, 9, 12, 5, 3, 2)\n",
            "T4 --> (3, 6, 9, 12, 5, 3, 2, 3, 6, 9, 12, 5, 3, 2)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K2lF7bjeFysj"
      },
      "source": [
        "---\n",
        "### **13.9 Merging part of Tuples**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1ChXppaZFysk",
        "outputId": "ef268912-4d8f-4213-b313-e47bb175d68b"
      },
      "source": [
        "T1 = (3, 6, 9)\n",
        "T2 = (12, 5, 3, 2)\n",
        "\n",
        "print (\"T1 -->\", T1)\n",
        "print (\"T2 -->\", T2)\n",
        "\n",
        "T3 = T1[1:2] + T2[1:3]\n",
        "print (\"T3 -->\", T3)\n",
        "\n",
        "T4 = T1[:-2] + T2[:-3]\n",
        "print (\"T4 -->\", T4)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T1 --> (3, 6, 9)\n",
            "T2 --> (12, 5, 3, 2)\n",
            "T3 --> (6, 5, 3)\n",
            "T4 --> (3, 12)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3frpbJ4RFysl"
      },
      "source": [
        "---\n",
        "### **13.10 Searching in the tuple**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cY6y818WFysl",
        "outputId": "abe51a3b-51b5-4af6-86c6-66388f33d1b6"
      },
      "source": [
        "T = (3, 6, 9, 12, 5, 3, 2)\n",
        "print (\"T       -->\", T)\n",
        "\n",
        "print (\"6  in T -->\", 6 in T)\n",
        "print (\"10 in T -->\", 10 in T)\n",
        "print (\"12 in T -->\", 12 in T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T       --> (3, 6, 9, 12, 5, 3, 2)\n",
            "6  in T --> True\n",
            "10 in T --> False\n",
            "12 in T --> True\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vJg6l4N_E4IG"
      },
      "source": [
        "---\n",
        "### **13.11 Adding element to Tuple (Error)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RM0E_sSoE4IH",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "c110bb1d-ef9d-4d87-dcbf-403a832536ae"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T -->\", T)\n",
        "\n",
        "T[2] = 900               # Error; 'tuple' object does not support item assignment\n",
        "print (\"T -->\", T)\n",
        "\n",
        "#Tuples are unchangeable. We cannot add items to it. "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T --> ('Pratham', 'Sharma', 3.14, 3)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-74-fb1d27ae8658>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"T -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0mT\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m900\u001b[0m               \u001b[0;31m# Error; 'tuple' object does not support item assignment\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"T -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KocwDH8QE4IH"
      },
      "source": [
        "---\n",
        "### **13.12 Adding element to Tuple - (Jugaad)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TWSdjWFfE4II",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c1e1fbcd-c3a9-47d1-8f33-5134dc46e444"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T         -->\", T)\n",
        "\n",
        "T1 = list(T)\n",
        "T1.append(9.8)\n",
        "T = tuple(T1)\n",
        "\n",
        "print (\"After Add -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T         --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Add --> ('Pratham', 'Sharma', 3.14, 3, 9.8)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D8fE_Al0E4II"
      },
      "source": [
        "---\n",
        "### **13.13 Inserting element in Tuple - (Jugaad)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bkvZ4s4yE4IJ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7859f4ef-826a-4be5-bf75-0afdb64cd632"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T            -->\", T)\n",
        "\n",
        "T1 = list(T)\n",
        "T1.insert(2, \"Rahul\")\n",
        "T = tuple(T1)\n",
        "\n",
        "print (\"After Insert -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Insert --> ('Pratham', 'Sharma', 'Rahul', 3.14, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UvpIX1nsE4IK"
      },
      "source": [
        "---\n",
        "### **13.14 Deleting from Tuple (Error)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mex45HHQE4IL",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "outputId": "0198bcc8-c424-46b9-c902-ce46faa7a370"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T            -->\", T)\n",
        "\n",
        "del T[1]\n",
        "\n",
        "print (\"After Delete -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-77-0baff4d8a5c8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"T            -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 4\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"After Delete -->\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mT\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mTypeError\u001b[0m: 'tuple' object doesn't support item deletion"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mUlLkF7xK4ta"
      },
      "source": [
        "---\n",
        "### **13.15 Deleting from Tuple - (Jugaad)**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ey7gyq_JK4tc",
        "outputId": "7aa8c834-9404-49cf-8a2f-7424577d08a6"
      },
      "source": [
        "T = (\"Pratham\", 'Sharma', 3.14, 3)\n",
        "print (\"T            -->\", T)\n",
        "\n",
        "T1 = list(T)\n",
        "del T1[1]\n",
        "T = tuple(T1)\n",
        "\n",
        "print (\"After Delete -->\", T)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "T            --> ('Pratham', 'Sharma', 3.14, 3)\n",
            "After Delete --> ('Pratham', 3.14, 3)\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nP1BXJvpaSMR"
      },
      "source": [
        "---\n",
        "# **14 Data Structure 4 - Set**\n",
        "\n",
        "**Learning:** How to use Set, add, delete, search in Set\n",
        "\n",
        "**Note:** Read more about Set and try yourself\n",
        "\n",
        "---\n",
        "### **14.1 Declare Set**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q7k_3HyiaWwa",
        "outputId": "c0986637-55e8-4440-bf43-acab6dccc960"
      },
      "source": [
        "s = set(['A', 'B', 'E', 'F','E', 'F' ])\n",
        "print (\"Original set           --> \", s)\n",
        "print (\"Num of elements in set --> \", len(s))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original set           -->  {'E', 'A', 'F', 'B'}\n",
            "Num of elements in set -->  4\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ltLfKXfKardd"
      },
      "source": [
        "---\n",
        "### **14.2 Opertions on Sets**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s8KiiSKSardf",
        "outputId": "8194b701-82ec-4601-8904-87ac54a5b5d0"
      },
      "source": [
        "a = set(['A', 'B', 'E', 'F' ])\n",
        "b = set([\"A\", \"C\", \"D\", \"E\"])\n",
        "print (\"Original set a      --> \", a)\n",
        "print (\"Original set b      --> \", b)\n",
        "print (\"Union of a and b    --> \", a.union(b))\n",
        "print (\"Intersection of a,b --> \", a.intersection(b))\n",
        "print (\"Difference a - b    --> \", a - b)\n",
        "print (\"Difference a - b    --> \", a.difference(b))\n",
        "print (\"Difference b - a    --> \", b - a)\n",
        "print (\"Difference b - a    --> \", b.difference(a))\n",
        "print (\"Symetric Diff a - b --> \", a.symmetric_difference(b))\n",
        "print (\"Symetric Diff b - a --> \", b.symmetric_difference(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original set a      -->  {'E', 'A', 'F', 'B'}\n",
            "Original set b      -->  {'E', 'A', 'D', 'C'}\n",
            "Union of a and b    -->  {'B', 'D', 'F', 'E', 'A', 'C'}\n",
            "Intersection of a,b -->  {'E', 'A'}\n",
            "Difference a - b    -->  {'F', 'B'}\n",
            "Difference a - b    -->  {'F', 'B'}\n",
            "Difference b - a    -->  {'D', 'C'}\n",
            "Difference b - a    -->  {'D', 'C'}\n",
            "Symetric Diff a - b -->  {'F', 'D', 'C', 'B'}\n",
            "Symetric Diff b - a -->  {'B', 'F', 'D', 'C'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oGG-LZJhars5"
      },
      "source": [
        "---\n",
        "### **14.3 Add, delete, pop element from set**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6MfSdtaUars6",
        "outputId": "43383d15-f134-4f5c-988c-7979db09a43e"
      },
      "source": [
        "a = set(['A', 'B', 'E', 'F' ])\n",
        "print (\"Original set a       --> \", a)\n",
        "a.add(\"D\")\n",
        "print (\"Set After Adding (D) --> \", a)\n",
        "a.add(\"D\")\n",
        "print (\"Set After Adding (D) --> \", a)\n",
        "a.remove(\"D\")\n",
        "print (\"Set After Deleting(D)--> \", a)\n",
        "a.pop()\n",
        "print (\"Set After pop        --> \", a)\n",
        "a.pop()\n",
        "print (\"Set After pop        --> \", a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original set a       -->  {'E', 'A', 'F', 'B'}\n",
            "Set After Adding (D) -->  {'B', 'D', 'F', 'E', 'A'}\n",
            "Set After Adding (D) -->  {'B', 'D', 'F', 'E', 'A'}\n",
            "Set After Deleting(D)-->  {'B', 'F', 'E', 'A'}\n",
            "Set After pop        -->  {'F', 'E', 'A'}\n",
            "Set After pop        -->  {'E', 'A'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "spvefWIWbNAR"
      },
      "source": [
        "---\n",
        "# **15 Command Line Argument**\n",
        "\n",
        "**Learning:** How to Take input from command line and process it\n",
        "\n",
        "**Note:** Run the program at cmd line\n",
        "\n",
        "---\n",
        "### **15.1 Add two numbers given at cmd line**\n",
        "**Note:** To run the program at cmd line\n",
        "*     python Program.py 10 20"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "0ieaM9uebNAS",
        "outputId": "0a60acec-3db0-4696-865c-87e4daec7cc3"
      },
      "source": [
        "import sys\n",
        "print (sys.argv)\n",
        "a = int(sys.argv[1]) \t# First Number\n",
        "b = int(sys.argv[2])\t# Second Number\n",
        "c = a + b\n",
        "print (a, \" + \", b, \" --> \", c)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-82-a3d67294dc12>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mimport\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# First Number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      4\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m    \u001b[0;31m# Second Number\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0ma\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mb\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '-f'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jGBXdT5CbNAT"
      },
      "source": [
        "---\n",
        "### **15.2 Concatinate two strings given at cmd line**\n",
        "**Note:** To run the program at cmd line\n",
        "*   python Program.py FirstString SecondString\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dg117QSIbNAU",
        "outputId": "62d37c0b-1ea7-4ca9-da65-a6356ec70e24"
      },
      "source": [
        "import sys\n",
        "print (sys.argv)\n",
        "s = sys.argv[1] + \" \" + sys.argv[2]\n",
        "print (sys.argv[1], \" + \", sys.argv[2], \" --> \", s)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json']\n",
            "-f  +  /root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json  -->  -f /root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Gtu3hMwabNAW"
      },
      "source": [
        "---\n",
        "### **15.3 Add all the numbers given at cmd line**\n",
        "**Note:** To run the program at cmd line\n",
        "*   python Program.py\n",
        "*   python Program.py 10\n",
        "*   python Program.py 10 20 30 40\n",
        "\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 285
        },
        "id": "QSHWbDHmbNAX",
        "outputId": "f054cfa3-1901-4b1d-90f2-3e59f8671c8e"
      },
      "source": [
        "import sys\n",
        "print (sys.argv)\n",
        "sum=0\n",
        "for s in sys.argv[1:]:\n",
        "\tsum += int(s)\n",
        "\n",
        "print (\"Sum is --> \", sum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['/usr/local/lib/python3.7/dist-packages/ipykernel_launcher.py', '-f', '/root/.local/share/jupyter/runtime/kernel-2c370b3f-04bb-4872-8f9b-8559cbd8132b.json']\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-84-87063e0e9afe>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msys\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0margv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m         \u001b[0msum\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mprint\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;34m\"Sum is --> \"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: '-f'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-wicdMoyfLoZ"
      },
      "source": [
        "---\n",
        "# **16 File Handling**\n",
        "\n",
        "**Learning:** How to open the file, read the file and write in the file\n",
        "\n",
        "---\n",
        "### **16.1 Writing 1 to 10 in file**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oX-fBKbpfLob",
        "outputId": "5757d752-1397-4f8a-f58a-d8865990a008"
      },
      "source": [
        "fp=open('result.txt','w')\t# Open the file in writing mode\n",
        "for  i in range(1,11):\n",
        "\tfp.write(str(i) + \"\\n\")\t# Writing to the file line by line\n",
        "fp.close()\n",
        "\n",
        "print (\"Writing done !! \\nOpen result.txt to view the content\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Writing done !! \n",
            "Open result.txt to view the content\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-6OU-QD_fLoc"
      },
      "source": [
        "---\n",
        "### **16.2 Read a file and print its content**\n",
        "---\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jiPQizlEfLod",
        "outputId": "750019d4-ecd0-4fbe-fa5f-9a0681d1d620"
      },
      "source": [
        "fp=open('result.txt')\t\t# Open the file in reading mode\n",
        "for line in fp: \t\t    # print line by line\n",
        "\tprint (line.strip())\n",
        "fp.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n",
            "5\n",
            "6\n",
            "7\n",
            "8\n",
            "9\n",
            "10\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Sby32ykwfLof"
      },
      "source": [
        "---\n",
        "### **16.3 Read from one file, Convert it to upper case and write to other file**\n",
        "---"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rjvJZNv_fLoh",
        "outputId": "a8704164-b68e-46b9-b87a-1e14fa262b31"
      },
      "source": [
        "Readfp=open('result.txt')\t\t# Open the file in reading mode\n",
        "Writefp=open('abc.txt','w')\t# Open the file in writing mode\n",
        "for line in Readfp: \n",
        "\tWritefp.write(line.upper())\n",
        "\t\n",
        "Writefp.close()\n",
        "Readfp.close()\n",
        "\n",
        "print (\"Writing done !! \\nOpen result.txt to view the content\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Writing done !! \n",
            "Open result.txt to view the content\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}