19A21A0558.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": " 19A21A0558.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "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/Haneef-Shaik/python-lab/blob/main/19A21A0558.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "klj1dnFKrQXQ"
      },
      "source": [
        "# PythonProgramming Lab\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "Name:- SK.HANEEF`\n",
        "\n",
        "Reg.no:- 19A21A0558\n",
        "\n",
        "section:- CSE-A"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hHXPFCoay0Ul"
      },
      "source": [
        ""
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SKOF0eeCzBeK"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HRKrSytfrivK"
      },
      "source": [
        "# **EXERCISE-1 BASICS**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z0Ih86DxE8ne"
      },
      "source": [
        "**AIM**:\n",
        "a)Running instructions in interactive interpreter and a python script\n",
        "**DESCRIPTION**:\n",
        "Python is a high-level, interpreted, interactive and object-oriented scripting language. Python is\n",
        "designed to be highly readable. It uses English keywords frequently where as other languages\n",
        "use punctuation, and it has fewer syntactical constructions than other languages.\n",
        "Python is Interpreted\n",
        "\n",
        "Python is Interactive\n",
        "Python is Object-Oriented\n",
        "Python is a Beginner's Language\n",
        "Python Programming Running Python Scripts\n",
        "Running Python in THREE ways:\n",
        "a) Running Python Interpreter\n",
        "b) Running Python Scripts in IDLE\n",
        "c) Running python scripts in Command Prompt\n",
        "a) Running Python Interpreter: Python comes with an interactive interpreter. When you type\n",
        "python in your shell or command prompt, the python interpreter becomes active with a >>>\n",
        "prompt and waits for your commands\n",
        "b) Running Python Scripts in IDLE: . Go to File menu click on New File (CTRL+N) and write the\n",
        "code and save first.py\n",
        "c) Running python scripts in Command Prompt: ** **bold text · Before going to run we have to\n",
        "check the PATH in environment variables."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "15n7aAlDZTlE",
        "outputId": "1e015521-3926-4c0e-97ea-6922dd01714c"
      },
      "source": [
        "#Exercise-1 - Basies\n",
        "# a) Running instructions in Interactive interpreter and a Python Script \n",
        "\n",
        "print(\"Hello, Haneef\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Hello, Haneef\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kDdTIC5G8bQE"
      },
      "source": [
        "**AIM**:\n",
        "b)Write a program to purposefully raise Indentation Error and Correct it\n",
        "**DESCRIPTION**:\n",
        "Indentation\n",
        "Python does not support braces to indicate blocks of code for class and function\n",
        "definitions or flow control.\n",
        "Blocks of code are denoted by line indentation.\n",
        "All the continuous lines indented with same number of spaces would form a block.\n",
        "Python strictly follow indentation rules to indicate the blocks."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 128
        },
        "id": "n4W_fxjPbGus",
        "outputId": "4fd49223-7fea-46be-893f-1f3356cd4479"
      },
      "source": [
        "# b) Write a program to purposefully raise Indentation Error and Corret it\n",
        "if i range(10):\n",
        " print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-20ef1176fcb5>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    if i range(10):\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WV8GujP4wU00"
      },
      "source": [
        "# **EXERCISE-2 OPERATIONS bold text**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eLHflFL2fVmH"
      },
      "source": [
        "**AIM**:\n",
        "b)Write a program to purposefully raise Indentation Error and Correct it\n",
        "**DESCRIPTION**:\n",
        "Indentation\n",
        "Python does not support braces to indicate blocks of code for class and function\n",
        "definitions or flow control.\n",
        "Blocks of code are denoted by line indentation.\n",
        "All the continuous lines indented with same number of spaces would form a block.\n",
        "Python strictly follow indentation rules to indicate the blocks."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8al8NHOrbHCL",
        "outputId": "61146c5f-1c8b-4e67-c513-1cd1eedebad8"
      },
      "source": [
        "#Exercise 2-Opera6tions\n",
        "\n",
        "#Write a program to compute distance between two points taking input from the user (Pythagorean Theorem)\n",
        "import math\n",
        "x1=int(input(\"enter x1 value : \"))\n",
        "x2=int(input(\"enter x2 value : \"))\n",
        "\n",
        "y1=int(input(\"enter y1 value : \"))\n",
        "y2=int(input(\"enter y2 value : \"))\n",
        "\n",
        "print(\"Distance between given two points(x1,x2)(y1,y2) :\",float(math.sqrt((x2-x1)**2+(y2-y1)**2)))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter x1 value : 10\n",
            "enter x2 value : 2\n",
            "enter y1 value : 4\n",
            "enter y2 value : 5\n",
            "Distance between given two points(x1,x2)(y1,y2) : 8.06225774829855\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3goP4x0_9kj9"
      },
      "source": [
        "**AIM**:\n",
        "b) Write a program add.py that takes 2 numbers as command line arguments and prints its sum\n",
        "**DESCRIPTION**:\n",
        "The arguments that are given after the name of the program in the command line shell of\n",
        "the operating system are known as Command Line Arguments. Python provides various\n",
        "ways of dealing with these types of arguments. The three most common are:\n",
        "Using sys.argv\n",
        "Using getopt module\n",
        "Using argparse module\n",
        "Using sys.argv\n",
        "The sys module provides functions and variables used to manipulate different parts of the\n",
        "Python runtime environment. This module provides access to some variables used or\n",
        "maintained by the interpreter and to functions that interact strongly with the interpreter.\n",
        "One such variable is sys.argv which is a simple list structure. It’s main purpose are:\n",
        "It is a list of command line arguments.\n",
        "len(sys.argv) provides the number of command line arguments.\n",
        "sys.argv[0] is the name of the current Python script."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TaVah1WhbvwR"
      },
      "source": [
        "# Write a program add.py that takes 2 numbers as command line arguments and prints its sum.\n",
        "\n",
        "import sys\n",
        "\n",
        "a=int(sys.argv[1])\n",
        "b=int(sys.argv[2])\n",
        " \n",
        "print(\"Sum = \",(a+b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fxKTdCGbb0tD"
      },
      "source": [
        "output: PS C:\\Users\\haneef\\Desktop\\python\\exercise-2> python Q2.py 10 30 Sum = 40[link text](https://)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "10bPIUUnb5YK",
        "outputId": "e689c45a-4e09-4eaa-8f9c-b232e9acdf56"
      },
      "source": [
        "# Write a Program for checking whether the given number is an even number or not. \n",
        "n=int(input(\"enter a number to check even/odd : \"))\n",
        "\n",
        "if (n%2==0):\n",
        "    print(\"Given numver \",n,\" is Even\")\n",
        "else:\n",
        "    print(\"Given numver \",n,\" is Odd\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter a number to check even/odd : 10\n",
            "Given numver  10  is Even\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2bRRkSU6wZAk"
      },
      "source": [
        "# **EXERCISE-3 CONTROL FLOW**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hk4qGDZLF6WV"
      },
      "source": [
        "**AIM**:\n",
        "b) Using a for loop, write a program that prints out the decimal equivalents of 1/2, 1/3, 1/4, . .\n",
        ".1/10\n",
        "**DESCRIPTION**\n",
        "For Loop: For loops can iterate over a sequence of numbers using the \"range\" and \"xrange\"\n",
        "functions. The difference between range and xrange is that the range function returns a new list\n",
        "with numbers of that specified range, whereas xrange returns an iterator, which is more eficient.\n",
        "The general format is\n",
        "for x in range(start,stop,step):\n",
        "statements"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qyYwYoGBcBsk",
        "outputId": "c958f18c-5541-4f69-bcff-c081b5adc4e4"
      },
      "source": [
        "#Exercise-3 Control Flow\n",
        "\n",
        "# Using a for loop, write a program that prints out the decimal equivalents of 1/2, 1/3, 1/4,. .1/10 \n",
        "\n",
        "n=int(input(\"enter limit for decimal equivalents of (1/2, 1/3, 1/4,. .1/10) : \"))\n",
        "\n",
        "for i in range(2,n):\n",
        "    print(\"1/\",i,\" = \",(1/i))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter limit for decimal equivalents of (1/2, 1/3, 1/4,. .1/10) : 20\n",
            "1/ 2  =  0.5\n",
            "1/ 3  =  0.3333333333333333\n",
            "1/ 4  =  0.25\n",
            "1/ 5  =  0.2\n",
            "1/ 6  =  0.16666666666666666\n",
            "1/ 7  =  0.14285714285714285\n",
            "1/ 8  =  0.125\n",
            "1/ 9  =  0.1111111111111111\n",
            "1/ 10  =  0.1\n",
            "1/ 11  =  0.09090909090909091\n",
            "1/ 12  =  0.08333333333333333\n",
            "1/ 13  =  0.07692307692307693\n",
            "1/ 14  =  0.07142857142857142\n",
            "1/ 15  =  0.06666666666666667\n",
            "1/ 16  =  0.0625\n",
            "1/ 17  =  0.058823529411764705\n",
            "1/ 18  =  0.05555555555555555\n",
            "1/ 19  =  0.05263157894736842\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qmnYuKfbcFbv",
        "outputId": "406b0315-7aeb-4901-e3de-88fee327ca51"
      },
      "source": [
        "#Write a program using a for loop that loops over a sequence. What is sequence? \n",
        "\n",
        "names=[\"haneef\",\"ganesh\",\"pavan\",\"karthik\"]\n",
        "\n",
        "print(\"-------NAMES--------\")\n",
        "for i in names:\n",
        "    print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-------NAMES--------\n",
            "haneef\n",
            "ganesh\n",
            "pavan\n",
            "karthik\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y5Jtb5z6HqL_"
      },
      "source": [
        "**AIM**:\n",
        "D) Write a program using a while loop that asks the user for a number, and prints a\n",
        "countdownfrom that number to zero.\n",
        "**DESCRIPTION**:\n",
        "While Loop is used to execute a block of statements repeatedly until a given condition is\n",
        "satisfied. And when the condition becomes false, the line immediately after the loop in the\n",
        "program is executed. While loop falls under the category of indefinite iteration\n",
        "The syntax for a while loop is:\n",
        "while [ condition]"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-KZGumMYcYmg",
        "outputId": "2a3767f9-3998-449b-d7cb-dd3554d06786"
      },
      "source": [
        "# Write a program using a while loop that asks the user for a number, and prints a countdown from that number to zero.\n",
        "\n",
        "n=int(input(\"enter starting point of Countdown: \"))\n",
        "\n",
        "print(\"Countdown Starts:-\")\n",
        "while n>=0:\n",
        "    print(n)\n",
        "    n-=1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter starting point of Countdown: 15\n",
            "Countdown Starts:-\n",
            "15\n",
            "14\n",
            "13\n",
            "12\n",
            "11\n",
            "10\n",
            "9\n",
            "8\n",
            "7\n",
            "6\n",
            "5\n",
            "4\n",
            "3\n",
            "2\n",
            "1\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wmQVSC3AwgAB"
      },
      "source": [
        "# **EXERCISE-4 CONTROL FLOW-CONTINUED**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PK_84FmsIAR5"
      },
      "source": [
        "exercise 4:\n",
        "**AIM**:\n",
        "a) Find the sum of all the primes below two million. Each new term in the Fibonacci sequence is\n",
        "generated by adding the previous two terms. Bystarting with 1 and 2, the first 10 terms will be: 1,\n",
        "2, 3, 5, 8, 13, 21, 34, 55, 89, ...\n",
        "**DESCRIPTION**:\n",
        "A Fibonacci sequence is the integer sequence of 0, 1, 1, 2, 3, 5, 8....\n",
        "The first two terms are 0 and 1. All other terms are obtained by adding the preceding two terms.\n",
        "This means to say the nth term is the sum of (n-1)th and (n-2)th term\n",
        "Here, we store the number of terms in nterms. We initialize the first term to 0 and the second\n",
        "term to 1.\n",
        "If the number of terms is more than 2, we use a while loop to find the next term in the sequence\n",
        "by adding the preceding two terms. We then interchange the variables (update it) and continue\n",
        "on with the process."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o2jLJKyNcb0v",
        "outputId": "4a20fcc7-70cf-4a00-ec1b-52fd98f5bbd0"
      },
      "source": [
        "#Exercise-4-Control Flow - Continued\n",
        "                   \n",
        "# Find the sum of all the primes below two million. \n",
        " \n",
        "        \n",
        "n=int(input(\"enter Limit for sum of primes : \"))\n",
        "psum=0\n",
        "for i in range(2,n+1):\n",
        "    c=0\n",
        "    for j in range(2,i+1):\n",
        "        if i%j==0:\n",
        "            c+=1\n",
        "    if(c==1):\n",
        "        print(i,end=' ')    \n",
        "        psum+=i\n",
        "\n",
        "print(\"\") \n",
        "print(\"Sum of sum number : \",psum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter Limit for sum of primes : 40\n",
            "2 3 5 7 11 13 17 19 23 29 31 37 \n",
            "Sum of sum number :  197\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FPG2Wt8dJe-v"
      },
      "source": [
        "**AIM**:\n",
        "b) Each new term in the Fibonacci sequence is generated by adding the previous two terms. By starting with 1 and 2, the first 10 terms will be: 1, 2, 3, 5, 8, 13, 21, 34, 55,89"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "d4kauJwgcf2E",
        "outputId": "e526aa66-25ae-4cbd-de2f-2dc210a79df2"
      },
      "source": [
        "\"\"\"\n",
        "Each new term in the Fibonacci sequence is \n",
        "generated by adding the previous two tems. By starting with l and 2, the first 10 terms will be: \n",
        "1,2,3,5, 8, 13, 21, 34, 55, 89,..\n",
        "\"\"\"\n",
        "\n",
        "n=int(input(\"enter Limit for Fibonacci sequence : \"))\n",
        "\n",
        "a=0\n",
        "b=1\n",
        "c=a+b\n",
        "while c<n:\n",
        "    print(c,end=' ')\n",
        "    a=b\n",
        "    b=c\n",
        "    c=a+b"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter Limit for Fibonacci sequence : 40\n",
            "1 2 3 5 8 13 21 34 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ainQweoPKvg_"
      },
      "source": [
        "**AIM**:\n",
        "c) By considering the terms in the Fibonacci sequence whose values do not exceed\n",
        "\n",
        "million, find the sum of the even-valued terms.\n",
        "**DESCRIPTION**:\n",
        "A Fibonacci sequence is the integer sequence of 0, 1, 1, 2, 3, 5, 8....\n",
        "The first two terms are 0 and 1. All other terms are obtained by adding the preceding two terms.\n",
        "This means to say the nth term is the sum of (n-1)th and (n-2)th term\n",
        "Here, we store the number of terms in nterms. We initialize the first term to 0 and the second\n",
        "term to 1.\n",
        "If the number of terms is more than 2, we use a while loop to find the next term in the sequence\n",
        "by adding the preceding two terms. We then interchange the variables (update it) and continue\n",
        "on with the process."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7Gf9wiFJci_x",
        "outputId": "487cfed5-1dfb-47d1-85c8-2aaf054b0325"
      },
      "source": [
        "\"\"\"\n",
        " By considering the terms in the Fibonacci sequence whose values do not exceed four million, \n",
        "find the sum of the even-valued terms.\n",
        "\"\"\"\n",
        "\n",
        "n=int(input(\"enter Limit for Fibonacci sequence : \"))\n",
        "\n",
        "a=0\n",
        "b=1\n",
        "c=a+b\n",
        "fsum=0\n",
        "while c<n:\n",
        "    a=b\n",
        "    b=c\n",
        "    c=a+b\n",
        "    if c%2==0:\n",
        "        print(c,end=' ')\n",
        "        fsum+=c\n",
        "print(\"\")        \n",
        "print(\"sum of even valued termed fibonacci numbers = \",fsum)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter Limit for Fibonacci sequence : 60\n",
            "2 8 34 \n",
            "sum of even valued termed fibonacci numbers =  44\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OfrDDHAnwjRk"
      },
      "source": [
        "# **EXERCISE-5 DATA STRUCTURES**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sYzM0NFbL-KM"
      },
      "source": [
        "exercise 5:\n",
        "**AIM**:\n",
        "a) Write a program to count the numbers of characters in the string and store them in\n",
        "adictionary data structure\n",
        "**DESCRIPTION**:\n",
        "Given a string, the task is to find the frequencies of all the characters in that string and return a\n",
        "dictionary with key as the character and its value as its frequency in the given string.\n",
        "Method #1 : Naive method\n",
        "Simply iterate through the string and form a key in dictionary of newly occurred element or if\n",
        "element is already occurred, increase its value by 1.\n",
        "Method #2 : Using collections.Counter()\n",
        "The most suggested method that could be used to find all occurrences is this method, this\n",
        "actually gets all element frequency and could also be used to print single element frequency if\n",
        "required."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gYg0TE3Bcmx1",
        "outputId": "13668c6d-0a34-47cd-bede-a8cae3ba80c4"
      },
      "source": [
        "#Exercise 5- DS \n",
        "\n",
        "#Write a program to count the numbers of characters in the string and store them in a dictionary data structure \n",
        "text=input(\"enter you name : \")\n",
        "dic={}\n",
        "for ch in text:\n",
        "  keys=dic.keys()\n",
        "\n",
        "  if ch in keys:\n",
        "    dic[ch]=dic[ch]+1\n",
        "  else:\n",
        "    dic[ch]=1\n",
        "print(\"Dictionary is : \",dic)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter you name : haneef\n",
            "Dictionary is :  {'h': 1, 'a': 1, 'n': 1, 'e': 2, 'f': 1}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LkSfZJiXNRyq"
      },
      "source": [
        "**AIM**:\n",
        "b) Write a program to use split and join methods in the string and trace a birthday with a dictionary data structure.\n",
        "\n",
        "**DESCRIPTION**:\n",
        "Python program to Split a string based on a delimiter and join the string using another delimiter.\n",
        "Split a string can be quite useful sometimes, especially when you need only certain parts of\n",
        "strings. A simple yet effective example is splitting the First-name and Last-name of a person.\n",
        "Another application is CSV(Comma Separated Files). We use split to get data from CSV and join\n",
        "to write data to CSV.\n",
        "In Python, we can use the function split() to split a string and\n",
        "join() to join a string.\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QqG9ANYdctEL",
        "outputId": "4f0d1c1c-db48-4ade-f83e-51f84d93476f"
      },
      "source": [
        "\"\"\"\n",
        " Write a program to use split and join methods in the string and trace a birthday with a \n",
        "dictionary data structure.\n",
        "\"\"\"\n",
        "text={\"haneef\":\"23-may-2002\",\"ganesh\":\"23-may-2001\"}\n",
        "\n",
        "name=input(\"which person Dob you want : \")\n",
        "l=name.split()\n",
        " \n",
        "for i in l:\n",
        "  if i in text.keys():\n",
        "    print(\" \".join([i,\"birthday is \",text[i]]))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "which person Dob you want : haneef\n",
            "haneef birthday is  23-may-2002\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tO43v-c1wrJu"
      },
      "source": [
        "# **EXERCISE-6 DS-CONTINUED**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s40kZwyuOgy0"
      },
      "source": [
        "Exercise 6:\n",
        "**AIM**:\n",
        "a) Write a program combine lists that combines these lists into a dictionary.\n",
        "\n",
        "**DESCRIPTION**:\n",
        "For this, simply declare a dictionary, and then run nested loop for both the lists and assign key\n",
        "and value pairs to from list values to dictionary.\n",
        "Most pythonic and generic method to perform this very task is by using zip(). This function pairs\n",
        "the list element with other list element at corresponding index in form of key-value pairs."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qrVi_Kd5c5Gb",
        "outputId": "251bb932-eea0-433f-e9a8-297fcc83b215"
      },
      "source": [
        "#Exercise-6 DS - Continued\n",
        "\n",
        "#Write a program combine lists that combines these lists into a dictionary. \n",
        "\n",
        "Regno=[\"534\",\"558\",\"546\",\"564\",\"565\",\"530\"]\n",
        "Student_names=[\"pavaneswar\",\"haneef\",\"ganesh\",\"ajay\",\"karthik\",\"somu\"]\n",
        "\n",
        "print(\"Given List are :\")\n",
        "print(\"Student Names: \",Student_names)\n",
        "print(\"Register no Values: \",Regno)\n",
        "\n",
        "dic=dict(zip(Regno,Student_names))\n",
        "print(\"\\n Dictionary: \",dic)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given List are :\n",
            "Student Names:  ['pavaneswar', 'haneef', 'ganesh', 'ajay', 'karthik', 'somu']\n",
            "Register no Values:  ['534', '558', '546', '564', '565', '530']\n",
            "\n",
            " Dictionary:  {'534': 'pavaneswar', '558': 'haneef', '546': 'ganesh', '564': 'ajay', '565': 'karthik', '530': 'somu'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kmHSxpF7Pa6G"
      },
      "source": [
        "**AIM**:\n",
        "b) Write a program to count frequency of characters in a given file. Can you\n",
        "use character frequency to tell wheather the given file is a Python program file, C program file or a text file?\n",
        "**DESCRIPTION**:\n",
        "approaches to count the number of times a letter appears in a text file in Python.\n",
        "Method 1: Using the in-built count() method.\n",
        "Approach:\n",
        "1. Read the file.\n",
        "2. Store the content of the file in a variable.\n",
        "3. Use the count() method with the argument as a letter whose frequency is required.\n",
        "4. Display the count of the letter."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GdpT6X6Nc9XZ"
      },
      "source": [
        "\n",
        "#Write a program to count frequency of characters in a given file. Can you use character frequency \n",
        "#to tell whether the given file is a Python program file, C program file or a text file?\n",
        "\n",
        "filetype=['.py','.c','.txt']\n",
        "fn=input(\"enter the file name : \")\n",
        "f=open(fn,'r')\n",
        "count=dict()\n",
        "\n",
        "print(\"Given file is \",end=\"\")\n",
        "for ft in filetype:\n",
        "  if (ft in fn):\n",
        "    if(ft=='.py'):\n",
        "      print(\"python file\")\n",
        "    elif(ft=='.c'):\n",
        "      print(\"c file\")\n",
        "    elif(ft=='.txt'):\n",
        "      print(\"Text file\")    \n",
        "for line in f:\n",
        "  for ch in line:\n",
        "    if ch in count:\n",
        "      count[ch]=count[ch]+1\n",
        "    else:\n",
        "      count[ch]=1\n",
        "\n",
        "print(count)\n",
        "f.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hjxO0UNBdB8c"
      },
      "source": [
        "output:\n",
        "\n",
        "enter the file name:data.txt Given file is Text file {'h':1,'a':2,'n':3,'e':4,'e':5,'f':6}"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pv2oTJbowxfC"
      },
      "source": [
        "# **EXERCISE-7 FILES**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Asw00XVRj1-"
      },
      "source": [
        "exercise-7:\n",
        "**AIM**:\n",
        "a) Write a program to print each line of a file in reverse order.\n",
        "**DESCRIPTION**:\n",
        "The file handling plays an important role when the data needs to be stored permanently into the\n",
        "file. A file is a named location on disk to store related information. We can access the stored\n",
        "information (non-volatile) after the program termination. In Python, files are treated in two\n",
        "modes as text or binary. The file may be in the text or binary format, and each line of a file is\n",
        "ended with the special character. Hence, a file operation can be done in the following order.\n",
        "□ Open a file\n",
        "□ Read or write - Performing operation\n",
        "□ Close the file"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_smwpp79dJEE"
      },
      "source": [
        "#Exercise 7 Files\n",
        "                             \n",
        "#Write a program to print each line of a file in reverse order.\n",
        "\n",
        "file=open(\"code.txt\",\"r\")\n",
        "if file:\n",
        "  st=file.read()\n",
        "  print(\"File content is: \\n\",st)\n",
        "file.close()\n",
        "\n",
        "print()\n",
        "lines=st.split(\"\\n\")\n",
        "\n",
        "for ln in lines:\n",
        "  i=len(ln)-1\n",
        "  while(i>=0):\n",
        "    print(ln[i],end=\"\")\n",
        "    i=i-1\n",
        "  print()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "X7vCoSLHdLhk"
      },
      "source": [
        "output: File content is: welcome to python programming...! haneef Swanandhra college of engineering and technology\n",
        "\n",
        "!..gnimmargorp nothyp ot emocleW rawsenavap ygolonhcet dna gnirreenigne fo egelloc arhdnanraws"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-8VkBMotSWxE"
      },
      "source": [
        "**AIM**:\n",
        "b) Write a program to compute the number of characters, words and lines in a file\n",
        "**DESCRIPTION**:\n",
        "Given a text file fname, the task is to count the total number of characters, words, spaces and\n",
        "lines in the file.\n",
        "As we know, Python provides multiple in-built features and modules for handling files. Let’s\n",
        "discuss different ways to calculate total number of characters, words, spaces and lines in a file\n",
        "using Python.\n",
        "Method #1: Naive approach\n",
        "In this approach, the idea is to solve the task by developing our own logic. Without using any\n",
        "built-in function of Python, the total number of characters, words, spaces and lines of the file will\n",
        "be calculated.\n",
        "Method #2: Using some built-in functions and OS module functions\n",
        "In this approach, the idea is to use the os.linesep() method of OS module to separate the lines\n",
        "on the current platform. When the interpreter’s scanner encounter os.linesep it replaces it with\n",
        "\\n character. After that strip() and split() functions will be used to carry out the task."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mkSo1a03dPOy"
      },
      "source": [
        "#Write a program to compute the number of characters, words and lines in a file.\n",
        " \n",
        "no_char=no_words=no_lines=0\n",
        "file=open(\"abc.txt\",\"r\")\n",
        "\n",
        "print(\"File Content : \\n\")\n",
        "for line in file:\n",
        "  ln=line.split(\"\\n\")\n",
        "  print(ln)\n",
        "  words=ln.split()\n",
        "  no_lines+=1\n",
        "  no_words+=len(words)\n",
        "  no_char+=len(line)\n",
        "\n",
        "file.close()\n",
        "print(\"\\n No of Lines : \",no_lines,\" Words:\",no_words,\" Characters:\",no_char)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YUdGmgqBdXkm"
      },
      "source": [
        "output:\n",
        "\n",
        "File content:\n",
        "\n",
        "welcome to python programming...! \n",
        "haneef\n",
        "cse-A\n",
        "\n",
        "no of lines:3 words:6 characters:48"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CHg02yBHw5pJ"
      },
      "source": [
        "# **EXERCISE-8 FUNCTIONS**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JPBskih2TTEP"
      },
      "source": [
        "Exeecise-8\n",
        "**AIM**:\n",
        "a) Write a function ball collide that takes two balls as parameters and computes if they\n",
        "arecolliding. Your function should return a Boolean representing whether or not the balls\n",
        "arecolliding.\n",
        "Hint: Represent a ball on a plane as a tuple of (x, y, r), r being the radius If (distance between two\n",
        "balls centers) <= (sum of their radii) then (they are colliding)\n",
        "**DESCRIPTION**:\n",
        "Functions A function in python is a block of code that is defined for doing frequent operations in\n",
        "a particular task. The general format is\n",
        "def Functionname(arguments):\n",
        "Statements\n",
        "**Calling a Function**:\n",
        "A function can be called by its name followed by arguments within parenthesis.\n",
        "function()"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t9D2IvfGdiQM",
        "outputId": "61217fa5-a1e9-4396-ff20-869b7002dd84"
      },
      "source": [
        "#Exercise-8 Functions\n",
        "\"\"\"\n",
        "Write a function ball collide that takes two balls as parameters and computes if they arecolliding. \n",
        "Your function should return a Boolean representing whether or not the balls are colliding. Hint: \n",
        "Represent a ball on a plane as a tuple of (x, y, r), r being the radius \n",
        "If (distance between two balls centres)= (sum of their radii) then (they are \n",
        "colliding) \n",
        "\"\"\"\n",
        "import math\n",
        "\n",
        "def collide(ball1,ball2):\n",
        "   x1,y1,r1=ball1\n",
        "   x2,y2,r2=ball2\n",
        "\n",
        "   print(\"Ball-1: \",ball1)\n",
        "   print(\"Ball-2: \",ball2)\n",
        "\n",
        "   d=math.sqrt((x2-x1)**2+(y2-y1)**2)\n",
        "   print(\"Centroid Distance of two balls: \",d)\n",
        "   print(\"sum of radius ball-1 and ball-2 is {}+{}={}\".format(r1,r2,r1+r2))\n",
        "\n",
        "   if(d<=r1+r2):\n",
        "     return True\n",
        "   else:\n",
        "     return False\n",
        "\n",
        "b1=(-2,-5,4)\n",
        "b2=(4,8,3)\n",
        "if collide(b1,b2):\n",
        "  print(\"BAll are Colliode...!\")\n",
        "else:\n",
        "  print(\"BAll are not Collide...!\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ball-1:  (-2, -5, 4)\n",
            "Ball-2:  (4, 8, 3)\n",
            "Centroid Distance of two balls:  14.317821063276353\n",
            "sum of radius ball-1 and ball-2 is 4+3=7\n",
            "BAll are not Collide...!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "k3QF-ZwvVMT7"
      },
      "source": [
        "**AIM**:\n",
        "b) Find mean, median, mode for the given set of numbers in a list\n",
        "**DESCRIPTION**:\n",
        "Mean : The mean is the average of all numbers and is sometimes called the arithmetic mean.\n",
        "This code calculates Mean or Average of a list containing numbers:\n",
        "Median : The median is the middle number in a group of numbers. This code calculates Median\n",
        "of a list containing numbers:\n",
        "Mode : The mode is the number that occurs most often within a set of numbers. This code\n",
        "calculates Mode of a list containing numbers:\n",
        "We will import Counter from collections library which is a built-in module in Python 2 and 3. This\n",
        "module will help us count duplicate elements in a list. We define a list of numbers and calculate\n",
        "the length of the list. We then call Counter (a dict subclass) which helps to count hashable\n",
        "objects, and we then convert it to dict object. We then initialize a list with a For Loop to compare\n",
        "all the dict values (Number of elements) to the max of all dict values (count of most occurring\n",
        "element) and it returns all the elements equal to max count. If the elements returned are equal to\n",
        "the number of total elements in a list then we print out ‘No mode’, else we print out the modes\n",
        "returned."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0yDtElwrdruV",
        "outputId": "a0dafa75-efb1-4c0e-9324-0899cdff23c4"
      },
      "source": [
        "#Find mean, median, mode for the given set of numbers in a list. \n",
        "\n",
        "def mean(n_list):\n",
        "  return sum(n_list)/len(n_list)\n",
        "def median(n_list):\n",
        "  n_list.sort()\n",
        "  n=len(n_list)\n",
        "  mid=n/2\n",
        "  if(n%2==1):\n",
        "     return n_list[int(mid)]\n",
        "  else:\n",
        "     \n",
        "    return (n_list[mid-1]+n_list[mid])/2\n",
        "\n",
        "def mode(n_list):\n",
        "  n_list.sort()\n",
        "  temp=[]\n",
        "  i=0    \n",
        "  while i<len(n_list):\n",
        "    temp.append(n_list.count(n_list[i]))\n",
        "    i+=1\n",
        "\n",
        "  dic=dict(zip(n_list,temp))\n",
        "  mode={k for(k,v) in dic.items() if v==max(temp)}\n",
        "  return mode\n",
        "\n",
        "n_list1=[100,100,200,200,200,300,400,500,300]\n",
        "\n",
        "print(\"Given list is : \",n_list1)\n",
        "print(\"Mean of the given list: \",mean(n_list1))\n",
        "print(\"Median of the given list: \",median(n_list1))\n",
        "print(\"Mode of the given list: \",mode(n_list1))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given list is :  [100, 100, 200, 200, 200, 300, 400, 500, 300]\n",
            "Mean of the given list:  255.55555555555554\n",
            "Median of the given list:  200\n",
            "Mode of the given list:  {200}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZqCTkhHtxABD"
      },
      "source": [
        "# **EXERCISE-9 FUNCTIONS CONTINUED**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gYQVUhIfXyrG"
      },
      "source": [
        "exercise-9\n",
        "**AIM**:\n",
        "a) Write a function nearly equal to test whether two strings are nearly equal. Two strings a and b are nearly equal when a can be generated by a single mutation on b.\n",
        "**DESCRIPTION**:\n",
        "strlen() function is used to check wether the two string are nearly equal or not by basis of the\n",
        "Length of those Strings\n",
        "len() function is an inbuilt function in Python programming language that returns the length of\n",
        "the string.\n",
        "len() is a built-in function in python.You can use the len() to get the length of the given string,\n",
        "array, list, tuple, dictionary, etc.\n",
        "Value: the given value you want the length of.\n",
        "Return value a return an integer value i.e. the length of the given string, or array, or list, or\n",
        "collections."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mtm8ZwChd3hw",
        "outputId": "c8c06c27-ef32-4e45-a765-110b965ae08b"
      },
      "source": [
        "#Exercise-9 Functions-Continued\n",
        "\"\"\"\n",
        "a) Write a function nealy equal to test whether two strings are nearly equal. Two strings a and bare \n",
        "nearly equal when a can be generated by a single mutation on b.\n",
        "\"\"\"\n",
        "def nearly_equal(str1,str2):\n",
        "  count=0\n",
        "  i=j=0\n",
        "  while(i<len(str1) and j<len(str2)):\n",
        "    if (str1[i]!=str2[j]):\n",
        "      count+=1\n",
        "      if (len(str1)>len(str2)):\n",
        "        i+=1\n",
        "      elif (len(str1)==len(str2)):\n",
        "        pass\n",
        "      else:\n",
        "        i-=1\n",
        "    if(count>1):\n",
        "      return False\n",
        "    i+=1\n",
        "    j+=1\n",
        "  if (count<2):\n",
        "    return True\n",
        "\n",
        "s=input(\"enter string-1:\")\n",
        "s1=input(\"enter string-2:\")\n",
        "blen=nearly_equal(s,s1)\n",
        "if (blen):\n",
        "  print(\"String are nearly equal\")\n",
        "else:\n",
        "    print(\"String are NOT equal\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "enter string-1:haneef\n",
            "enter string-2:shaik haneef\n",
            "String are NOT equal\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DWK5e0RaIJ1v"
      },
      "source": [
        "**AIM**:\n",
        "b) Write a function dup to find all duplicates in the list.\n",
        "**DESCRIPTION**:\n",
        "To check if a list contains any duplicate element follow the following steps,\n",
        "1. Add the contents of list in a set.\n",
        "2. Compare the size of set and list.\n",
        "If size of list & set is equal then it means no duplicates in list.\n",
        "3. If size of list & set are different then it means yes, there are duplicates in list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "62Db0nDHd-Jv",
        "outputId": "2d466afa-811c-438b-d83e-90c0296e2704"
      },
      "source": [
        "# b) Write a function dup to find all duplicates in the list. \n",
        "\n",
        "def duplicates(n_list):\n",
        "  temp=[]\n",
        "  for i in n_list:\n",
        "    coun=n_list.count(i)\n",
        "    if (coun>1 and (i not in temp)):\n",
        "      temp.append(i)\n",
        "  print(\"Duplicates in the list:\",temp) \n",
        "\n",
        "ls=[100,200,100,50,60,870,50]\n",
        "print(\"Given elements in the list:\",ls)\n",
        "duplicates(ls)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given elements in the list: [100, 200, 100, 50, 60, 870, 50]\n",
            "Duplicates in the list: [100, 50]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZmKrXF2dI8Zx"
      },
      "source": [
        "**AIM**:\n",
        "c) Write a function unique to find all the unique elements of a list.\n",
        "**DESCRIPTION**:\n",
        "To find the unique in the list .There is a Specific Method i.e.,\n",
        "Method : Traversal of list\n",
        "Using traversal, we can traverse for every element in the list and check if the element is in the\n",
        "unique_list already if it is not over there, then we can append it in the unique_list.\n",
        "This is done using one for loop and other if statement which check if the value is in the unique\n",
        "list or not which is equivalent to another for loop."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b8vpU_HDeFKe",
        "outputId": "40c02228-db87-42dd-8ecb-323d6cfd3878"
      },
      "source": [
        "# c) Write a function unique to find all the unique elements of a list.\n",
        "\n",
        "def unique(n_list):\n",
        "  print(\"Unique Elements in the list: \",end=\"\")\n",
        "  for i in n_list:\n",
        "    cnt=n_list.count(i)\n",
        "    if cnt==1:\n",
        "       print(i,end=\" \")\n",
        "  \n",
        "\n",
        "ls=[10,20,30,10,20,30,534,556,558]\n",
        "print(\"Given elements in the list:\",ls)\n",
        "unique(ls)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given elements in the list: [10, 20, 30, 10, 20, 30, 534, 556, 558]\n",
            "Unique Elements in the list: 534 556 558 "
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cnnq2qwNxE6p"
      },
      "source": [
        "# **EXERCISE-10 FUNCTIONS-PROBLEM SOLVING**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iS-uv0KyKDkc"
      },
      "source": [
        "Exercise 10:\n",
        "**AIM**:\n",
        "a) Write a function cumulative product to compute cumulative product of a list of numbers.\n",
        "**DESCRIPTION**:\n",
        "A cumulative product is a sequence of partial products of a given sequence. For example, the\n",
        "cumulative products of the sequence. , are , , .. Cumulative products can be implemented in the\n",
        "Wolfram Language as Rest[FoldList[Times, 1, list]]\n",
        "cumprod(A,1) works on successive elements in the columns of A and returns the\n",
        "cumulative products of each column. cumprod(A,2) works on successive elements in the\n",
        "rows of A and returns the cumulative products of each row.\n",
        "umprod() function is used when we want to compute the cumulative product of array elements\n",
        "over a given axis. Syntax : numpy.cumprod(arr, axis=None, dtype=None, out=None) Parameters :\n",
        "arr : [array_like] Array containing numbers whose cumulative product is desired."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JPwSMMwdeOc4",
        "outputId": "d20155be-d30d-4b4c-f1b8-690d61c1cdab"
      },
      "source": [
        "#Exercise-10- Functions - Problem Solving\n",
        "\n",
        "# a) Write a function cumulative product to compute cumulative product of a list of numbers.\n",
        "\n",
        "def c_product(n_list):\n",
        "  pro=1\n",
        "  temp=[]\n",
        "  for i in n_list:\n",
        "    pro*=i\n",
        "    temp.append(pro)\n",
        "  return temp  \n",
        "\n",
        "ls=[10,20,40,30,50]\n",
        "print(\"Given list is: \",ls)\n",
        "print(\"Cumulative Producet list is: \",c_product(ls))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given list is:  [10, 20, 40, 30, 50]\n",
            "Cumulative Producet list is:  [10, 200, 8000, 240000, 12000000]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sfqHvwLiKp4m"
      },
      "source": [
        "AIM:\n",
        "b) Write a function reverse to reverse a list. Without using the reverse function.\n",
        "DESCRIPTION:\n",
        "In this Python code snippet post, we are going to implement a list reverse function from the\n",
        "scratch without using any builtin functions.\n",
        "Let us see how...\n",
        "Iterative solution\n",
        "We can use a for loop to swap the first and last items, the second and the one before the last\n",
        "item and so on until the list is reversed in place. The number of iterations needed is half the list\n",
        "size. If the list has an odd number of items then the middle item will stay in its place."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "az1KwjK-eURQ",
        "outputId": "8adc342b-eb3a-412d-b4a1-87929d2fd010"
      },
      "source": [
        "#b) Write a function reverse to reverse a list. Without using the reverse function.\n",
        "def reverse_list(n_list):\n",
        "  i=0\n",
        "  j=len(n_list)-1\n",
        "  while (i<=j):\n",
        "    temp=n_list[i]\n",
        "    n_list[i]=n_list[j]\n",
        "    n_list[j]=temp\n",
        "    j-=1\n",
        "    i+=1\n",
        "  return n_list\n",
        "\n",
        "ls=[100,200,300,400,500]\n",
        "print(\"Given List is: \",ls)\n",
        "reverse_list(ls)\n",
        "print(\"Reverse of the List is:\",ls)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given List is:  [100, 200, 300, 400, 500]\n",
            "Reverse of the List is: [500, 400, 300, 200, 100]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eb2L5ynsLUxr"
      },
      "source": [
        "**AIM**:\n",
        "c) Write function to compute gcd, lcm of two numbers. Each function shouldn’t exceed one line.\n",
        "**DESCRIPTION**:\n",
        "Python provides you an anonymous function called lambda. It can take any number of\n",
        "arguments, but can only have one expression. It can be used to find LCM and GCD values\n",
        "without exceeding each from from one line.\n",
        "The general format is\n",
        "lambda arguments: expression\n",
        "The expression is executed during the function call and the result is returned.\n",
        "Lambda as a Function\n",
        "The power of using a lambda expression is implementing it using a function"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yyrLx_UseZYv",
        "outputId": "8bd32c1c-440e-4759-e946-e7f25f73191c"
      },
      "source": [
        "# c) Write function to compute ged, lem of two numbers. Each function shouldn't exceed one line. \n",
        "gcd=lambda a,b: a if b==0 else gcd(a,a%b)\n",
        "lcm=lambda a,b: (a*b)/gcd(a,b)\n",
        "\n",
        "x=58\n",
        "y=46\n",
        "print(\"Given Number: \",x,y)\n",
        "print(\"GCD is: \",gcd(x,y))\n",
        "print(\"LCM is: \",lcm(x,y))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Given Number:  58 46\n",
            "GCD is:  58\n",
            "LCM is:  46.0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "97-NaMpFtU01"
      },
      "source": [
        "# **EXERCISE-11 MULTIDIMENTIONAL LISTS**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5nf0WrV7MMBs"
      },
      "source": [
        "exercise 11:\n",
        "**AIM**:\n",
        "a) Write a program that defines a matrix and prints\n",
        "**DESCRIPTION**:\n",
        "Lists are a very widely use data structure in python. They contain a list of elements separated by\n",
        "comma. But sometimes lists can also contain lists within them. These are called nested lists or\n",
        "multidimensional lists. In this article we will see how to create and access elements in a\n",
        "multidimensional list.\n",
        "Methods on Multidimensional lists\n",
        "1. append(): Adds an element at the end of the list.\n",
        "2. extend(): Add the elements of a list (or any iterable), to the end of the current list.\n",
        "3. reverse(): Reverses the order of the list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1o6hWrqttZXc"
      },
      "source": [
        "   # Exercise 11- Multi-D Lists\n",
        "\n",
        "#a) Write a program that defines a matrix and prints \n",
        "\n",
        "\n",
        "matrix=[[]]\n",
        "\n",
        "r=int(input(\"enter number of rows: \"))\n",
        "c=int(input(\"enter number of column: \"))\n",
        "\n",
        "matrix=[[int(input(\"enter value of [%d,%d] : \"%(j,i))) for i in range(c)] for j in range(r)]\n",
        "\n",
        "print(\"Given Matrix is :\")\n",
        "for i in range(r):\n",
        "    for j in range(c):\n",
        "        print(matrix[i][j],end='\\t')\n",
        "    print()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dKn-F40KNJyN"
      },
      "source": [
        "**AIM**:\n",
        "b) Write a program to perform addition of two square matrices\n",
        "**DESCRIPTION**:\n",
        "We can perform matrix addition in following ways in Python.\n",
        "1. Using for loop:\n",
        "Explanation :- In this program we have used nested for loops to iterate through each row and\n",
        "each column. At each point we add the corresponding elements in the two matrices and store it\n",
        "in the result.\n",
        "2. Using nested list comprehension :\n",
        "In Python, we can implement a matrix as nested list (list inside a list). We can treat each\n",
        "element as a row of the matrix.\n",
        "Explanation :-\n",
        "The output of this program is the same as above. We have used nested list comprehension to\n",
        "iterate through each element in the matrix. List comprehension allows us to write concise codes\n",
        "and we must try to use them frequently in Python. They are very helpful.\n",
        "3. uising zip function\n",
        "Explanation :\n",
        "The zip function accepts iterator i of each element(list) of matrix, mapping them, adding them\n",
        "using sum() and storing them in the map form."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v_Wq-SjHtcz2"
      },
      "source": [
        "#b) Write a program to perform addition of two square matrices\n",
        "\n",
        "matrix1=[[]]\n",
        "matrix2=[[]]\n",
        "\n",
        "def readmartix(r,c):\n",
        "   return [[int(input(\"enter value of [%d,%d] : \"%(j,i))) for i in range(c)] for j in range(r)]\n",
        "    \n",
        "    \n",
        "\n",
        "r=int(input(\"Enter no of Rows: \"))\n",
        "c=int(input(\"Enter no of Columns: \"))\n",
        "\n",
        "if r==c:\n",
        "    print(\"enter First matrix elements :- \")\n",
        "    matrix1=readmartix(r,c)\n",
        "    print(\"enter  Second matrix elements :- \")\n",
        "    matrix2=readmartix(r,c)\n",
        "\n",
        "    print(\"Addition of the Matrix..\")\n",
        "    print([[matrix1[i][j]+matrix2[i][j] for j in range(c)] for i in range(r)])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dtFtUKaZQ5ff"
      },
      "source": [
        "AIM:\n",
        "c) Write a program to perform multiplication of two square\n",
        "DESCRIPTION:\n",
        "In Python, we can implement a matrix as nested list (list inside a list).\n",
        "We can treat each element as a row of the matrix.\n",
        "For example X = [[1, 2], [4, 5], [3, 6]] would represent a 3x2 matrix.\n",
        "The first row can be selected as X[0]. And, the element in first row, first column can be selected\n",
        "as X[0][0].\n",
        "Multiplication of two matrices X and Y is defined only if the number of columns in X is equal to\n",
        "the number of rows Y.\n",
        "If X is a n x m matrix and Y is a m x l matrix then, XY is defined and has the dimension n x l (but\n",
        "YX is not defined). Here are a couple of ways to implement matrix multiplication in Python.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "53RURdsVtf-x"
      },
      "source": [
        "#c) Write a program to perform multiplication of two square matrices\n",
        "\n",
        "matrix1=[[]]\n",
        "matrix2=[[]]\n",
        "result=[[]]\n",
        "def readmartix(r,c):\n",
        "   return [[int(input(\"enter value of [%d,%d] : \"%(j,i))) for i in range(c)] for j in range(r)]\n",
        "    \n",
        "    \n",
        "\n",
        "r=int(input(\"Enter no of Rows: \"))\n",
        "c=int(input(\"Enter no of Columns: \"))\n",
        "\n",
        "if r==c:\n",
        "    print(\"enter First matrix elements :- \")\n",
        "    matrix1=readmartix(r,c)\n",
        "    print(\"enter  Second matrix elements :- \")\n",
        "    matrix2=readmartix(r,c)\n",
        "\n",
        "    result=[[0 for j in range(c)] for i in range(r)]\n",
        "    \n",
        "    for i in range(r):\n",
        "        for j in range(c):\n",
        "            for k in range(c):\n",
        "                result[i][j] += matrix1[i][k] * matrix2[k][j]\n",
        "                 \n",
        "print(\"Mulltiplication matrix..\")\n",
        "print(result)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GFtVcz3WtkvM"
      },
      "source": [
        "# **EXERCISE-12 MODULES**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "26QRTVYxS6QK"
      },
      "source": [
        "Excercise 12:\n",
        "**AIM**:\n",
        "b) Write a scripts that imports requests and fetch content from the page.Eg. (Wiki)code:\n",
        "**DESCRIPTION**:\n",
        "The Hypertext Transfer Protocol (HTTP) is an application protocol for distributed, collaborative,\n",
        "hypermedia information systems. HTTP is the foundation of data communication for the World\n",
        "Wide Web.\n",
        "Python requests\n",
        "Requests is a simple and elegant Python HTTP library. It provides methods for accessing Web\n",
        "resources via HTTP.\n",
        "Python requests reading a web page\n",
        "The get() method issues a GET request; it fetches documents identified by the given URL."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a1mG6gFhtjfz"
      },
      "source": [
        "#Exercise-12\n",
        "# b)Write a script thtat imports request and fetch content from the page.Eg(wiki)\n",
        "import requests\n",
        "\n",
        "s=requests.get('https://www.google.com')\n",
        "\n",
        "print(\"statuscode : \",s.status_code)\n",
        "\n",
        "print(\"header content: \",s.headers['content-type'])\n",
        "\n",
        "print(s.text)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NZ4ZhFV8Tq4-"
      },
      "source": [
        "**AIM**:\n",
        "c) Write a simple script that serves a simple HTTPResponse and Simple HTML page.\n",
        "**DESCRIPTION**:\n",
        "**HTTP Protocol**\n",
        "The most important part of a web server is HTTP protocol.So now we will see what exactly this\n",
        "is –\n",
        "It stands for Hyper Text Transfer Protocol.\n",
        "It is an application layer protocol that allows web based applications to communicate and\n",
        "exchange data.\n",
        "The HTTP is the messenger of web.\n",
        "The computer that communicate via the HTTP must speak the HTTP protocol.\n",
        "It is a TCP/IP based protocol.\n",
        "It is used to deliver contents, for eg. images, audios, videos, documents etc.\n",
        "Using HTTP is the most convenient way to quickly and reliably move data on the web.\n",
        "HTML stands for hypertext markup language. It is the standard markup language for web pages\n",
        "that define the structure of the content. These elements are the building blocks of any website"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Hg2munEgtrc7"
      },
      "source": [
        "#c) Write a simple script that servers a simple HHTPResponse and simple HTML Page \n",
        "\n",
        "from flask import Flask,render_template\n",
        "app=Flask(__name__)\n",
        "print(app)\n",
        "@app.route(\"/\")\n",
        "\n",
        "def main():\n",
        "  return render_template('login.html')\n",
        "\n",
        "if __name__==\"__main__\":\n",
        "  app.run(host=\"127.0.0.1\",port=2500)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7M_TAahTttzP"
      },
      "source": [
        "# **Exercise-13 oops**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6fxtIpXVVezd"
      },
      "source": [
        "Exercise 13:\n",
        "**AIM**:\n",
        "a)class variables and instance variable and illustration of the self -variable\n",
        "**DESCRIPTION**:\n",
        "Variables are named storage location. In python variables are not defined by its type instead it\n",
        "will be automatically determined by the value assigned to it. To determine the type of a variable\n",
        "a function called type () is used.\n",
        "class variable is shared by all object instances of a class. .... They are not defined inside any\n",
        "methods of a class. Because a class variable is shared by instances of a class, the Python class\n",
        "owns the variable. As a result, all instances of the class will be able to access that variable\n",
        "Instance variables are owned by instances of the class. This means that for each object or\n",
        "instance of a class, the instance variables are different..... Instance variables, owned by objects\n",
        "of the class, allow for each object or instance to have different values assigned to those\n",
        "variables\n",
        "self variable is used to bind the instance of the class to the instance method. We have to\n",
        "explicitly declare it as the first method argument to access the instance variables and methods.\n",
        "This variable is used only with the instance methods."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LppsR8SDtvop"
      },
      "source": [
        "#Exercise-13 oops\n",
        "#a)Class varibles and instance variable and illustration of the self-variable\n",
        "\n",
        "#Robot\n",
        "\n",
        "class robot:\n",
        "    name=\"Ganesh Reedy\"\n",
        "    version=2.0\n",
        "    speed=\"1THz\"\n",
        "    memory=\"1ZB\"\n",
        "    \n",
        "    def robotspecifications(self):\n",
        "        print(\"Robot Name : \",robo.name)\n",
        "        print(\" Version : \",robo.version)\n",
        "        print(\"Speed : \",robo.speed)\n",
        "        print(\"Memory : \",robo.memory)\n",
        "    def update(up):\n",
        "        up.version=3.0\n",
        "        up.speed=\"2THz\"\n",
        "        up.memory=\"2ZB\"    \n",
        "robo=robot()\n",
        "\n",
        "robo.robotspecifications()\n",
        "\n",
        " \n",
        "c=input(\"want to upgrade the Robot Features to 100% (y/n): \")\n",
        "\n",
        "if c=='y':\n",
        "    robo.update()\n",
        "\n",
        "robo.robotspecifications()\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1XWSYnrFt1rm"
      },
      "source": [
        "#b)ATM Macine\n",
        "\n",
        "class Bank_of_Swarnandhra_ATM:\n",
        "    def __init__(self):\n",
        "        self.balance=0\n",
        "        \n",
        "    def balance_enquiry(self):\n",
        "        print(\"Balance in yoour Account = \",self.balance)  \n",
        "    \n",
        "    def deposit(self):\n",
        "        amount=int(input(\"enter Amount : \"))\n",
        "        self.balance+=amount \n",
        "        print(\"Amount is successfully Deposited....\")  \n",
        "    \n",
        "    def withdraw(self):\n",
        "        amount=int(input(\"enter Amount : \"))\n",
        "        if amount<=self.balance:\n",
        "            print(\"*****Thank You take Money*****\")\n",
        "            self.balance-=amount   \n",
        "        else:\n",
        "            print(\"Sorry insufficient Balance\")        \n",
        "    \n",
        "    def exit(self):\n",
        "        print(\"Thank you\")\n",
        "bank=Bank_of_Swarnandhra_ATM()\n",
        "\n",
        "while(True):\n",
        "    print(\"1.Balance Enquiry\")\n",
        "    print(\"2.Deposit\")\n",
        "    print(\"3.withdraw\")\n",
        "    print(\"4.exit\")\n",
        "    c=int(input(\"enter your option:\"))\n",
        "    if c==1:\n",
        "        bank.balance_enquiry()\n",
        "    elif c==2:\n",
        "        bank.deposit()\n",
        "    elif c==3:\n",
        "        bank.withdraw()\n",
        "    elif c==4:\n",
        "        break    \n",
        "    else:\n",
        "        print(\"invald option\")\n",
        "        pass\n",
        "                 "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oLS67ctkt7Ij"
      },
      "source": [
        "# **EXERCISE-14 GUI PROGRAMMING**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "A-0fjK0sMhus"
      },
      "source": [
        "Exercise 14: \n",
        "**AIM**:\n",
        "a. Write a GUI for an Expression Calculator using tk\n",
        "DESCRIPTION:\n",
        "Tkinter is a Python package which comes with many functions and methods that can be used to\n",
        "create an application. In order to create a tkinter application, we generally create an instance of\n",
        "tkinter frame, i.e., Tk(). It helps to display the root window and manages all the other\n",
        "components of the tkinter application. We can initialize the tkinter instance by assigning the\n",
        "variable to it."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BtP8X-f1t-So"
      },
      "source": [
        "#Exercise-14 GUI,Graphics\n",
        "\n",
        "#write a GUI for an Expression Calculater using tk\n",
        "\n",
        "from tkinter import *\n",
        "\n",
        "win = Tk() \n",
        "win.geometry(\"312x324\")   \n",
        "win.resizable(0, 0)   \n",
        "win.title(\"Calculator\")\n",
        "\n",
        " \n",
        "\n",
        "def btn_click(item):    \n",
        "    global expression\n",
        "    expression = expression + str(item)\n",
        "    input_text.set(expression)\n",
        "\n",
        " \n",
        "def bt_clear(): \n",
        "    global expression \n",
        "    expression = \"\" \n",
        "    input_text.set(\"\")\n",
        " \n",
        " \n",
        "def bt_equal():\n",
        "    global expression\n",
        "    result = str(eval(expression))  \n",
        "    input_text.set(result)\n",
        "    expression = \"\"\n",
        " \n",
        "expression = \"\"\n",
        " \n",
        " \n",
        " \n",
        "input_text = StringVar()\n",
        " \n",
        " \n",
        "input_frame = Frame(win, width=312, height=50, bd=0, highlightbackground=\"black\", highlightcolor=\"black\", highlightthickness=2)\n",
        " \n",
        "input_frame.pack(side=TOP)\n",
        "  \n",
        " \n",
        "input_field = Entry(input_frame, font=('arial', 18, 'bold'), textvariable=input_text, width=50, bg=\"#eee\", bd=0, justify=RIGHT)\n",
        " \n",
        "input_field.grid(row=0, column=0)\n",
        " \n",
        "input_field.pack(ipady=10)  \n",
        " \n",
        "btns_frame = Frame(win, width=312, height=272.5, bg=\"grey\")\n",
        " \n",
        "btns_frame.pack()\n",
        " \n",
        " \n",
        " \n",
        "clear = Button(btns_frame, text = \"C\", fg = \"black\", width = 32, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: bt_clear()).grid(row = 0, column = 0, columnspan = 3, padx = 1, pady = 1)\n",
        " \n",
        "divide = Button(btns_frame, text = \"/\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: btn_click(\"/\")).grid(row = 0, column = 3, padx = 1, pady = 1)\n",
        " \n",
        " \n",
        "seven = Button(btns_frame, text = \"7\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(7)).grid(row = 1, column = 0, padx = 1, pady = 1)\n",
        " \n",
        "eight = Button(btns_frame, text = \"8\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(8)).grid(row = 1, column = 1, padx = 1, pady = 1)\n",
        " \n",
        "nine = Button(btns_frame, text = \"9\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(9)).grid(row = 1, column = 2, padx = 1, pady = 1)\n",
        " \n",
        "multiply = Button(btns_frame, text = \"*\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: btn_click(\"*\")).grid(row = 1, column = 3, padx = 1, pady = 1)\n",
        " \n",
        " \n",
        " \n",
        "four = Button(btns_frame, text = \"4\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(4)).grid(row = 2, column = 0, padx = 1, pady = 1)\n",
        " \n",
        "five = Button(btns_frame, text = \"5\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(5)).grid(row = 2, column = 1, padx = 1, pady = 1)\n",
        " \n",
        "six = Button(btns_frame, text = \"6\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(6)).grid(row = 2, column = 2, padx = 1, pady = 1)\n",
        " \n",
        "minus = Button(btns_frame, text = \"-\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: btn_click(\"-\")).grid(row = 2, column = 3, padx = 1, pady = 1)\n",
        "  \n",
        " \n",
        "one = Button(btns_frame, text = \"1\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(1)).grid(row = 3, column = 0, padx = 1, pady = 1)\n",
        " \n",
        "two = Button(btns_frame, text = \"2\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(2)).grid(row = 3, column = 1, padx = 1, pady = 1)\n",
        " \n",
        "three = Button(btns_frame, text = \"3\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(3)).grid(row = 3, column = 2, padx = 1, pady = 1)\n",
        " \n",
        "plus = Button(btns_frame, text = \"+\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: btn_click(\"+\")).grid(row = 3, column = 3, padx = 1, pady = 1)\n",
        " \n",
        " \n",
        " \n",
        "zero = Button(btns_frame, text = \"0\", fg = \"black\", width = 21, height = 3, bd = 0, bg = \"#fff\", cursor = \"hand2\", command = lambda: btn_click(0)).grid(row = 4, column = 0, columnspan = 2, padx = 1, pady = 1)\n",
        " \n",
        "point = Button(btns_frame, text = \".\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: btn_click(\".\")).grid(row = 4, column = 2, padx = 1, pady = 1)\n",
        " \n",
        "equals = Button(btns_frame, text = \"=\", fg = \"black\", width = 10, height = 3, bd = 0, bg = \"#eee\", cursor = \"hand2\", command = lambda: bt_equal()).grid(row = 4, column = 3, padx = 1, pady = 1)\n",
        " \n",
        "win.mainloop()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3MHw5mM7uEkF"
      },
      "source": [
        "#2)Write a program to implement the following figures using turtle\n",
        " #a)\n",
        " import turtle\n",
        "\n",
        "turtle.pensize(3)\n",
        "turtle.speed(20)\n",
        "turtle.bgcolor(\"black\")\n",
        "\n",
        " \n",
        "for i in range(5):\n",
        "    for col in [\"blue\",\"red\",\"yellow\"] :\n",
        "     turtle.color(col)   \n",
        "     turtle.circle(55)\n",
        "     turtle.left(30)\n",
        "turtle.done()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xAH5ASroPDRb"
      },
      "source": [
        "**AIM**:\n",
        "b. Write a program to implement the following figures using turtle\n",
        "**DESCRIPTION**:\n",
        "The turtle module is an extended reimplementation of the same-named module from the Python\n",
        "standard distribution up to version Python 2.5.\n",
        "It tries to keep the merits of the old turtle module and to be (nearly) 100% compatible with it.\n",
        "This means in the first place to enable the learning programmer to use all the commands,\n",
        "classes and methods interactively when using the module from within IDLE run with the -n\n",
        "switch.\n",
        "The turtle module provides turtle graphics primitives, in both object-oriented and procedure-\n",
        "oriented ways. Because it uses tkinter for the underlying graphics, it needs a version of Python installed with Tk support"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3IqshMrnuFVD"
      },
      "source": [
        "#b)\n",
        "import turtle  \n",
        "   \n",
        "t = turtle.Turtle()  \n",
        "turtle.pensize(2)  \n",
        "turtle.speed(100)  \n",
        " \n",
        "for i in range(40):\n",
        "    for j in range(4):\n",
        "        turtle.forward(70)\n",
        "        turtle.left(90)\n",
        "    turtle.left(10)        \n",
        "turtle.done() "
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VRkTi8touILc"
      },
      "source": [
        "# **EXERCISE-15 TESTING**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tx-u_sHquLwF"
      },
      "source": [
        "                          #Exercise-15\n",
        "#a)write a test-case to check function even numbers which return True on passing a list of all even numbers\n",
        "\n",
        "def checklistiseven(elements):\n",
        "    p=True\n",
        "    for i in elements:\n",
        "        if i%2==1:\n",
        "            p=False\n",
        "            break\n",
        "    return p\n",
        "            \n",
        "          \n",
        "elements=[]\n",
        "\n",
        "n=int(input(\"enter limit of input: \"))\n",
        "\n",
        "for i in range(n):\n",
        "    elements.append(int(input(\"element-\"+str(i+1)+\" : \")))\n",
        "\n",
        "print(checklistiseven(elements))    \n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8RfzRb15Ta_D"
      },
      "source": [
        "**AIM**:\n",
        "b)write a test-case to check the function reverse string which returns the reversed string\n",
        "**DESCRIPTION**:\n",
        "Python string library does’nt support the in-built “reverse()” as done by other python containers\n",
        "like list, hence knowing other methods to reverse string can prove to be useful. This article\n",
        "discusses several ways to achieve it.\n",
        "The reversed() returns the reversed iterator of the given string and then its elements are joined\n",
        "empty string separated using join(). And reversed order string is formed.\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K0dgPuUeuNs8"
      },
      "source": [
        "#b)write a test-case to check function reverse string which returns the reversed string\n",
        "\n",
        "\n",
        "def rev_string(name):\n",
        "    return name[::-1]\n",
        "\n",
        "\n",
        "name=input(\"enter any String: \")\n",
        "\n",
        "print(\"Reverse of the given String = \"+rev_string(name))\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oCA8T9_kuQpW"
      },
      "source": [
        "# **EXERCISE-16 ADVANCED**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SRJAbSAYT9Zy"
      },
      "source": [
        "Exercise 16: \n",
        "**AIM**:\n",
        "a)Build any one classical data structure\n",
        "**DESCRIPTION**:\n",
        "What is a Data Structure?\n",
        "Organizing, managing and storing data is important as it enables easier access and eficient\n",
        "modifications. Data Structures allows you to organize your data in such a way that enables you\n",
        "to store collections of data, relate them and perform operations on them accordingly.\n",
        "Stack Stacks are linear Data Structures which are based on the principle of Last-In-First-Out\n",
        "(LIFO) where data which is entered last will be the first to get accessed. It is built using the array\n",
        "structure and has operations namely, pushing (adding) elements, popping (deleting) elements\n",
        "and accessing elements only from one point in the stack called as the TOP. This TOP is the\n",
        "pointer to the current position of the stack. Stacks are prominently used in applications such as\n",
        "Recursive Programming, reversing words, undo mechanisms in word editors and so forth."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gFR4XNB2uYFX"
      },
      "source": [
        "                                #Exercise-16\n",
        "\n",
        "#a)Build any one classical data structure                                  \n",
        "\n",
        "\n",
        "stack=[]\n",
        "\n",
        "while True:\n",
        "    print(\"1.Push\\n2.Pop\\n3.Display\\n4.Exit\")\n",
        "    c=int(input(\"enter your choice: \"))\n",
        "    \n",
        "    if c==1:\n",
        "        e=int(input(\"enter element: \"))\n",
        "        stack.append(e)\n",
        "        print(\"element is Pushed\")\n",
        "    elif c==2:\n",
        "        if len(stack)==0:\n",
        "            print(\"stack is empty\")\n",
        "        else:\n",
        "            print(\"element \"+str(stack[len(stack)-1])+\" is Poped\")\n",
        "            stack.remove(stack[len(stack)-1])\n",
        "    elif c==3:\n",
        "        if len(stack)==0:\n",
        "            print(\"stack is empty\")\n",
        "        else:\n",
        "            print(\"elements in the stack : \"+str(stack))    \n",
        "    elif c==4:\n",
        "        break\n",
        "    else:\n",
        "        print(\"invalid choice......\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6tz-EnUZVqR7"
      },
      "source": [
        "**AIM**:\n",
        "b)write a program to solve knapsack problem\n",
        "**DESCRIPTION**:\n",
        "python program for 0-1 knapsack problem\n",
        "Problem statement-We are given weights and values of n items, we need to put these items in a bag of capacity W up to the maximum capacity w. We need to carry a maximum number of items and return its value."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wmKROj30uayt"
      },
      "source": [
        "#b)write a program to solve knapsack problem\n",
        " \n",
        "def knapSack(W, wt, val, n):\n",
        "\tK = [[0 for x in range(W + 1)] for x in range(n + 1)]\n",
        "\n",
        "\t \n",
        "\tfor i in range(n + 1):\n",
        "\t\tfor w in range(W + 1):\n",
        "\t\t\tif i == 0 or w == 0:\n",
        "\t\t\t\tK[i][w] = 0\n",
        "\t\t\telif wt[i-1] <= w:\n",
        "\t\t\t\tK[i][w] = max(val[i-1] + K[i-1][w-wt[i-1]], K[i-1][w])\n",
        "\t\t\telse:\n",
        "\t\t\t\tK[i][w] = K[i-1][w]\n",
        "\n",
        "\treturn K[n][W]\n",
        "\n",
        " \n",
        "val = [60, 100, 120,130]\n",
        "wt = [10, 20, 30,40]\n",
        "W = 10\n",
        "n = len(val)\n",
        "print(knapSack(W, wt, val, n))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ua0WGV1qucqp"
      },
      "source": [
        "# **EXERCISE-17&18 DATA ANALYSIS**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cGtU_aDhWl87"
      },
      "source": [
        "Exercise 17 & 18- Data analysis\n",
        "**AIM**:\n",
        "1. Data analysis or manipulation using the following packages\n",
        "a) Numpy b) Pandas a) Scipy b) matplotlib\n",
        "**DESCRIPTION**:\n",
        "Learn how to analyze data using Python..... It includes following parts: Data Analysis libraries:\n",
        "will learn to use Pandas, Numpy and Scipy libraries to work with a sample dataset. We will\n",
        "introduce you to pandas, an open-source library, and we will use it to load, manipulate, analyze,\n",
        "and visualize cool datasets.\n",
        "**SciPy** is a free and open-source Python library used for scientific computing and technical\n",
        "computing. It is a collection of mathematical algorithms and convenience functions built on the\n",
        "**NumPy** extension of Python\n",
        "NumPy is the fundamental package for scientific computing in Python. .... NumPy arrays\n",
        "facilitate advanced mathematical and other types of operations on large numbers of data.\n",
        "**Matplotlib** is a plotting library for the Python programming language and its numerical\n",
        "mathematics extension NumPy. It provides an object-oriented API for embedding plots into\n",
        "applications using general-purpose GUI toolkits like Tkinter, wxPython, Qt, or GTK\n",
        "**Pandas** is an open source Python package that is most widely used for data science/data\n",
        "analysis and machine learning tasks. It is built on top of another package named Numpy, which\n",
        "provides support for multi-dimensional arrays.\n",
        "**Scikit-learn** is probably the most useful library for machine learning in Python. The sklearn\n",
        "library contains a lot of eficient tools for machine learning and statistical modeling including\n",
        "classification, regression, clustering and dimensionality reduction.\n",
        "**Seaborn** is a library in Python predominantly used for making statistical graphics. Seaborn is a\n",
        "data visualization library built on top of matplotlib and closely integrated with pandas data\n",
        "structures in Python"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "U0FsE6IKueqA"
      },
      "source": [
        "   #Exercise 17-Data Analysis \n",
        "#Data analysis or manipulation using the following packages \n",
        " \n",
        " #PYTHON VERSIONS\n",
        "\n",
        "#sys\n",
        "import sys\n",
        "print('python:{}'.format(sys.version))\n",
        "\n",
        "#scipy\n",
        "import scipy\n",
        "print('scipy:{}'.format(scipy.__version__))\n",
        "\n",
        "#numpy\n",
        "import  numpy\n",
        "print('numpy:{}'.format(numpy.__version__))\n",
        "\n",
        "#matplotlib\n",
        "import  matplotlib\n",
        "print('matplotlib:{}'.format(matplotlib.__version__))\n",
        "\n",
        "import   pandas\n",
        "print('pandas:{}'.format(pandas.__version__))\n",
        "\n",
        "import  sklearn\n",
        "print('sklearn:{}'.format(sklearn.__version__))\n",
        "\n",
        "import  seaborn\n",
        "print('seaborn:{}'.format(seaborn.__version__))\n",
        "\n",
        "import  urllib\n",
        "print('urllib:{}'.format(urllib.__name__))\n",
        "\n",
        "\n",
        "import  csv\n",
        "print('csv:{}'.format(csv.__version__))\n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3IiyUt_nuinw"
      },
      "source": [
        "# **NUMPY**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3VyBuZwdumEl"
      },
      "source": [
        "#a) NumPy \n",
        "#example code for initializaing numpy array\n",
        "import numpy as np\n",
        "a=np.array([2,6,8])\n",
        "print(type(a))\n",
        "\n",
        "print(a.shape)\n",
        "print(a[0])\n",
        "print(a[1])\n",
        "print(a[2])\n",
        "\n",
        "a[0]=10\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Mw4VuBmlum--"
      },
      "source": [
        "#create a rank 2 array\n",
        "import numpy as np\n",
        "b=np.array([[1,2,3],[4,5,6]])\n",
        "print(b.shape)\n",
        "print(b)\n",
        "print(b[0,0],b[0,1],b[1,0])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZUbsSmB0unH2"
      },
      "source": [
        "#craete a 3x3 array of all zeros\n",
        "\n",
        "a=np.zeros((3,3))\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AF-O9VvzunPY"
      },
      "source": [
        "#craete a 2x2 array of all ones\n",
        "b=np.ones((2,2))\n",
        "print(b)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eGzYe-cZunZc"
      },
      "source": [
        "#craete a 3x3 constant array\n",
        "c=np.full((3,3),7)\n",
        "print(c)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vYwr74kMuv43"
      },
      "source": [
        "#create a 3x3 array filled with random values\n",
        "\n",
        "d=np.random.random((3,3))\n",
        "print(d)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r54W-UGLuxKA"
      },
      "source": [
        "#craete a 3x3 identity matrix\n",
        "e=np.eye(3)\n",
        "print(e)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fu7ZPKXDuynW"
      },
      "source": [
        "#convert list to array\n",
        "f=np.array([1,2,3,4])\n",
        "print(f)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tlGz4VVIu0mN"
      },
      "source": [
        "#arange() will create array with regularly incrementing values\n",
        "g=np.arange(2,10)\n",
        "print(g)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "N_HNW-04u0ow"
      },
      "source": [
        "#note  mix of tuple and lists\n",
        "\n",
        "h=np.array([[1,2,3],[4,5,6],(1+1j,3.,2.)])\n",
        "print(h)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MrQHvEcWu2vb"
      },
      "source": [
        " #create an array of range with float data type\n",
        "i=np.arange(1,8,dtype=np.float)\n",
        "print(i)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jDTX7Y08u49A"
      },
      "source": [
        "#linespace\n",
        "j = np.linspace(2.,4.,5)\n",
        "print(j)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-1YgI6Lvu4_t"
      },
      "source": [
        "#indices()\n",
        "k=np.indices((3,3))\n",
        "print(k)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z93uiisGu5Ei"
      },
      "source": [
        "#numpy datatypes\n",
        "x=np.array([0,1])\n",
        "y=np.array([2.0,3.0])\n",
        "z=np.array([5,6],dtype=np.int64)\n",
        "print(x.dtype,y.dtype,z.dtype)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0vaXv5pGu9tY"
      },
      "source": [
        "#basic slicing\n",
        "x=np.array([5,6,7,8,9])\n",
        "print(x[1:7:2])\n",
        "print(x[-2:5])\n",
        "print(x[-1:1:-1])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zcZmoh9pu9xb"
      },
      "source": [
        "#boolean array indexing\n",
        "a=np.array(([1,2],[3,4],[5,6]))\n",
        "print(a>2)\n",
        "print(a[a>2])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UW239kH1u91B"
      },
      "source": [
        "import numpy as np\n",
        "x=np.array([[1,2],[3,4][5,6]])\n",
        "y=np.array([[7,8],[9,10],[11,12]])\n",
        "print(x+y)\n",
        "print(np.add(x,y))\n",
        "print(x-y)\n",
        "print(np.subtract(x-y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r6v0WZPnvBxW"
      },
      "source": [
        "#products\n",
        "print(x*y)\n",
        "print(np.multiply(x,y))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k65u3q4bvB2B"
      },
      "source": [
        "#vectors\n",
        "a=np.array([9,10])\n",
        "b=np.array([11,12])\n",
        "print(a.dot(b))\n",
        "print(np.dot(a,b))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n9NCG-yWvB6R"
      },
      "source": [
        "#sum function\n",
        "x=np.array([[1,2],[3,4]])\n",
        "print(np.sum(x))\n",
        "print(np.sum(x,axis=0))\n",
        "print(np.sum(x,axis=1))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BPBptUtqvM2M"
      },
      "source": [
        "#transpose function\n",
        "x=np.array([[1,2],[3,4])\n",
        "print(x)\n",
        "print(x,T)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UvY2wQDYvPEx"
      },
      "source": [
        "# **Pandas**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AWxBze8gvRck"
      },
      "source": [
        "# b) Pandas\n",
        "\n",
        "import pandas as pd\n",
        "\n",
        "s=pd.Series([1,2,3,4,5],index=['A','B','C','D','E'])\n",
        "s"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e_PeSNKovRfA"
      },
      "source": [
        "#creating data frame\n",
        "import pandas as pd \n",
        "data = {'Name':['Teju', 'sahi', 'honey', 'bunny'],\n",
        "        'Age':[19,15,20,13]}\n",
        "df = pd.DataFrame(data)\n",
        "print(df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "2WDIGhz5vWZk"
      },
      "source": [
        "#read from iris data\n",
        "from sklearn.datasets import load_iris\n",
        "import numpy as np\n",
        "iris=load_iris()\n",
        "iris"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v0ib9kznvYtE"
      },
      "source": [
        "x=pd.DataFrame(iris.data)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vgDum6dovZDL"
      },
      "source": [
        "x.shape\n",
        "x.columns=['sepal_length','sepal_width','petal_length','petal_width']\n",
        "x.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NqBBzlFjvZHX"
      },
      "source": [
        "x.tail()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v82A4sqFvZLF"
      },
      "source": [
        "x.describe()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cUZxSuykvdu-"
      },
      "source": [
        "x.cov()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Xk40BX5_vdyg"
      },
      "source": [
        "x.corr()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vvb_U6koviQ6"
      },
      "source": [
        "# **SCIPY**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_66H6OrIvkCv"
      },
      "source": [
        "import numpy as np\n",
        "np.linspace(1.,3.,5.)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OH8PZPfpvk1v"
      },
      "source": [
        "#kmeans using scipy\n",
        "from scipy.cluster.vq import kmeans,vq,whiten\n",
        "from numpy import vstack,array\n",
        "from numpy.random import rand\n",
        "data=vstack((rand(100,3)+array([.5,.5,.5]),rand(100,3)))\n",
        "data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qOs--0BLvk8m"
      },
      "source": [
        "data=whiten(data)\n",
        "data"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "71aj2IJPvlAj"
      },
      "source": [
        "centroids=kmeans(data,3)\n",
        "centroids"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DFPp-VhQvvsv"
      },
      "source": [
        "clx=vq(data,centroids)\n",
        "clx"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ND-crsByvzcQ"
      },
      "source": [
        "# **MATPLOTLIB**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "jfd25Zu4v2ux"
      },
      "source": [
        "#import library\n",
        "\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "x=np.arange(5)\n",
        "y=(35,45,28,37,60)\n",
        "\n",
        "plt.bar(x,y)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yTmKfYetv2y1"
      },
      "source": [
        "plt.scatter(x,y)\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68DX4j3Qv214"
      },
      "source": [
        "import pandas as pd\n",
        "from sklearn.datasets import load_iris\n",
        "\n",
        "iris=load_iris()\n",
        "df=pd.DataFrame(iris.data)\n",
        "df.columns=['sepal_length','sepal_width','petal_length','petal_width']\n",
        "df.head()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HoyQeDsRv98W"
      },
      "source": [
        "df.hist()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YFVlvNffv-D_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 182
        },
        "outputId": "959a7a68-cf3f-44d4-f72e-5cf9155fb6ef"
      },
      "source": [
        "df.plot()\n",
        "plt.show()"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "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-1-b10099301634>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\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;31mNameError\u001b[0m: name 'df' is not defined"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "loqqMcjyv-ND"
      },
      "source": [
        "df.boxplot()\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Nqup1GQCwDit"
      },
      "source": [
        "print(s)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nQC1kf56wFdR"
      },
      "source": [
        "#creating data frame\n",
        "import pandas as pd\n",
        " \n",
        " \n",
        "data = {'Name':['pavan', 'ganesh', 'haneef', 'sai ganesh'],\n",
        "        'Age':[22, 21, 19, 18]}\n",
        " \n",
        " \n",
        "df = pd.DataFrame(data)\n",
        " \n",
        " \n",
        "print(df)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iOLMzwqJwHOY"
      },
      "source": [
        " #Custom labels\n",
        "x=np.linspace(0,20,1000)\n",
        "y=np.sin(x)\n",
        "\n",
        "plt.plot(x,y,label='sample Label')\n",
        "plt.title('sample plot Title')\n",
        "plt.xlabel('x axis label')\n",
        "plt.ylabel('y axis label')\n",
        "plt.grid(True)\n",
        "\n",
        "plt.figtext(0.5, 0.01, 'Fig1: sinusoidal', ha='rigth', va='bottom')\n",
        "\n",
        "plt.legrnd(loc='best',framealpha=0.5,prop={'size':'small'})\n",
        "\n",
        "plt.tight_layout(pad=1)\n",
        "\n",
        "plt.show()"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}