Assignment_2.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Assignment_2.ipynb",
      "provenance": [],
      "authorship_tag": "ABX9TyOgcJfda9KOvjKel8iNVNvI",
      "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/Jagannath8/GoeduHub-Training/blob/main/Assignment_2.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ob-s-P9qmnwg"
      },
      "source": [
        "# **GO_STP_579 -> Jagannath Pal**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Uhkx9E9vmnUh"
      },
      "source": [
        "# ***Assignment_2***\n",
        "\n",
        "---\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pvraVOFJnN0x"
      },
      "source": [
        "**1. Is a list mutable?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bnj7L_C0nYuA"
      },
      "source": [
        "Lists in python are mutable data types as the elements of the list can be modified, individual elements can be replaced, and the order of elements can be changed even after the list has been created."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3CYqTbAOoVUK",
        "outputId": "28ac6e67-04ea-4c77-a5a6-d4cf7a94029b"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "print(a)\n",
        "a[2]=\"litchi\"\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'mango', 'orange', 'banana', 'grapes']\n",
            "['apple', 'mango', 'litchi', 'banana', 'grapes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hd0MveVmzXAX"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7xjnfgOiv4Cy"
      },
      "source": [
        "**2. Does a list need to be homogeneous?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ujCPz4tCwGNh"
      },
      "source": [
        "Lists can be either homogeneous or heterogeneous. But sometimes we need to access heterogeneous data separately according to their data types. Lists are mutable sequences, typically used to store collections of homogeneous items."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cR1adzpkwh8d",
        "outputId": "483cbc87-ceed-4fd3-a9f3-f8d932963379"
      },
      "source": [
        "a = ['apple', 10, 'orange', 15.2, 'grapes']\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 10, 'orange', 15.2, 'grapes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "15NpSFHJzZAm"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-981Q71CzdAu"
      },
      "source": [
        "**3. What is the difference between a list and a tuple.**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bNfcwMEa2PmP"
      },
      "source": [
        "i)List is mutable where as Tuple is immutable.\n",
        "ii)List iteration is slower and is time consuming where as Tuple iteration is faster.\n",
        "iii)List consumes more memory where as Tuples consumes less memory.\n",
        "iv)List provides many in-built methods where as Tuples have less in-built methods.\n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l3cq140H27U6"
      },
      "source": [
        "**4. How to find the number of elements in the list?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UDlmzxxt_MEl"
      },
      "source": [
        "To get the number of elements in a list is to use the Python built-in function len()."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xznkZyC3_Mj0",
        "outputId": "7357913f-94d1-42e4-e3a2-37dbe7354ea6"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "print(len(a))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ce1lLmh-_dbU"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lN9HL4dQ_hIR"
      },
      "source": [
        "**5. How to check whether the list is empty or not?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BbZB2AEq_59j"
      },
      "source": [
        "We can use the Python bool() function. The bool function gives the output as False, if the list is empty. But, if the list is not empty, the bool function given the output as True."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VsJhMTyG_6tF",
        "outputId": "ad722799-1ca1-4ced-a30d-927db1e270ad"
      },
      "source": [
        "new = [];\n",
        "if bool(new)==False:\n",
        "\tprint(\"The list is empty.\");\n",
        "else:\n",
        "\tprint(\"The list is not empty.\");"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The list is empty.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j_ImCIPvAOBb"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4DqzYkomARrr"
      },
      "source": [
        "**6. How to find the first and last element of the list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SBbCjOIvAaKP",
        "outputId": "149d8108-be13-40d9-95f6-ba718b57adfd"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "print(\"First element: \", a[0])\n",
        "print(\"First element: \", a[-1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "First element:  apple\n",
            "First element:  grapes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HiDnEkZbAsJJ"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fSn4Gl_eAtXc"
      },
      "source": [
        "**7. How to find the largest and lowest value in the list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C6VeHvZUBECV",
        "outputId": "a698c2fb-d506-468f-fdf5-64440bd98530"
      },
      "source": [
        "value = [10, 20, 5, 45, 100]\n",
        "value.sort()\n",
        "print(\"Largest element is:\", value[-1])\n",
        "print(\"Lowest element is:\", value[0])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Largest element is: 100\n",
            "Lowest element is: 5\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RhoQC5GfBZjr"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JtbqLSgiBa85"
      },
      "source": [
        "**8. How to access elements of the list?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jF8UhoyIBvyy"
      },
      "source": [
        "List items are indexed and you can access them by referring to the index."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jntMcDZyBmJO",
        "outputId": "0403f259-8fcd-49ac-c915-ff896963e14a"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "print(a[2], a[4])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "orange grapes\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xeJM4pkGB3TP"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xg-wxM9xB5F1"
      },
      "source": [
        "**9. Remove elements in a list before a specific index**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Vh9pymi6CcXW"
      },
      "source": [
        "To remove an item at specified index or position from a List, we can use pop () method of List class with index provided as argument."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lZ_eBOc6CFD0",
        "outputId": "5e8efc06-0ece-4026-996d-47cd7febe32b"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "a.pop(3)\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'mango', 'orange', 'grapes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OJd4BJVnChlS"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3C7iyK8CCjd4"
      },
      "source": [
        "**10. Remove elements in a list between 2 indices**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BEsCkOoeErSC"
      },
      "source": [
        "To remove an elements in a list between 2 indices we can use del keyword with index provided as argument."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5JoiZxSrCpw8",
        "outputId": "1460908e-9310-4001-efbe-8c8b625e67d5"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "del a[1:4]\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'grapes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aS9IIs15FAnB"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ynjbUS4bFCBe"
      },
      "source": [
        "**11. Return every 2nd element in a list between 2 indices**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uZri55TQFHag",
        "outputId": "fd748f14-12d2-49ae-ef05-5cee80de9a2b"
      },
      "source": [
        "b = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]\n",
        "c = b[3:8]\n",
        "print(c)\n",
        "print(\"Second element in a list between 2 indices: \", c[1])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[40, 50, 60, 70, 80]\n",
            "Second element in a list between 2 indices:  50\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GFuigKFuIRzH"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rNdQJb1ZH-Kf"
      },
      "source": [
        "**12. Get the first element from each nested list in a list**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AH5uQxA4ITkp",
        "outputId": "5d646e71-0ece-47c0-bc04-22ad4d29823a"
      },
      "source": [
        "nested_list =[ [[0,1,2],[3,4,5],[6,7,8]], [[10,11,12],[13,14,15],[16,77,88]], [[20,21,22],[23,24,25],[26,27,28]] ]\n",
        "print([item[0] for item in nested_list])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[[0, 1, 2], [10, 11, 12], [20, 21, 22]]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m_6OYviDNIEy"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ugBDAqBWNJO6"
      },
      "source": [
        "**13. How to modify elements of the list?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yMHf0S6AN2JG"
      },
      "source": [
        "We can modify an item within a list in Python by referring to the item’s index."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I7Mbyz6tNmOf",
        "outputId": "d4f28bb2-741a-493c-8739-a8ec711cf5b3"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "print(a)\n",
        "a[2]=\"litchi\"\n",
        "a[4]=\"guava\"\n",
        "print(a)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'mango', 'orange', 'banana', 'grapes']\n",
            "['apple', 'mango', 'litchi', 'banana', 'guava']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_dKANZN9N4rX"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Np3Z3JQ9N50a"
      },
      "source": [
        "**14. How to concatenate two lists?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ne0Ctyg88RWH"
      },
      "source": [
        "We can concatenate two lists using the + operator"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "goeJfkpJ7x32",
        "outputId": "3c9a166f-11a8-45d8-eb05-448bb33ce6ed"
      },
      "source": [
        "list1 = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "list2 = ['lion', 'tiger', 'deer', 'beer', 'rhino']\n",
        "concatenate_list = list1+list2\n",
        "print(concatenate_list)"
      ],
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'mango', 'orange', 'banana', 'grapes', 'lion', 'tiger', 'deer', 'beer', 'rhino']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z84Oy9kV8YYZ"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "OlSxTHGJ8Zsi"
      },
      "source": [
        "**15. How to add two lists element-wise in python?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "y5CwnSXD98Xa"
      },
      "source": [
        "We can run a loop and append the sum of same indices to the new list."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "B0xkwegY8gee",
        "outputId": "23a964c4-5de9-4f81-9c74-25cd87565ec0"
      },
      "source": [
        "list1 = [1, 3, 5, 7, 9]\n",
        "list2 = [2, 4, 6, 8, 10]\n",
        "result = []\n",
        "for i in range(0, len(list1)):\n",
        "    result.append(list1[i] + list2[i])\n",
        "print (\"Resultant list is : \" + str(result))"
      ],
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Resultant list is : [3, 7, 11, 15, 19]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pc1zJe3s-G6z"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mCdRJljp-IRk"
      },
      "source": [
        "**16. Difference between del and clear?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a2dH9fhT-M1z"
      },
      "source": [
        "del(): To remove items by index or slice we can use the del method in python .W can also remove elements from a list with del statements.\n",
        "clear(): It is used to empty the entire list. This can be used if someone wants an empty list for any other purpose. \n",
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JFlyWWBIBkAJ"
      },
      "source": [
        "**17. Difference between remove and pop?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "chMIX3AlBub_"
      },
      "source": [
        "remove(): It is an inbuilt function in Python programming language that removes a given object from the list. It does not return any value.\n",
        "\n",
        "pop(): It removes the item at the given index from the list and returns  the removed item.\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2NyM_2mVCFnM"
      },
      "source": [
        "**18. Difference between append and extend?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Sk93_pMCLoT"
      },
      "source": [
        "append(): It is a built-in function in Python. It adds a single element at the end of the list.\n",
        "\n",
        "extend(): It is a built-in function in Python. It is used to add multiple elements at the end of an already existing list. \n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-e-6G_pUCsiw"
      },
      "source": [
        "**19. Difference between indexing and Slicing?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oPrpdpwSC4SC"
      },
      "source": [
        "Indexing: Indexing is used to obtain individual elements. It can be done in Python Sequences types like list, string, tuples.\n",
        "\n",
        "Slicing: Slicing is used to obtain a sequence of elements. We can specify a range of indexes. It can be done in Python Sequences types like list, string, tuple, range objects.\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "awMXcrxQD0YJ"
      },
      "source": [
        "**20. Difference between sort and sorted?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BcHEJu-3EPqT"
      },
      "source": [
        "sort(): This function belongs to the list class in Python and can only be used with lists.\n",
        "sorted(): The function sorted() can be used to sort any iterable. i. e. list, dictionary, tuple, etc.\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "puhOQvNeEZRt"
      },
      "source": [
        "**21. Difference between reverse and reversed?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1n0ysvFaE4iw"
      },
      "source": [
        "reverse(): It inverts the order of items in the given list. It doesn’t create a new list object instead straightway modifies the original copy.\n",
        "\n",
        "reversed(): It allows us to process the items in a sequence in reverse order. It accepts a sequence and returns an iterator.\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nS2W8uIxFI-e"
      },
      "source": [
        "**22. Difference between copy and deepcopy?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5gM2grEgFQAD"
      },
      "source": [
        "copy(): It creates a shallow copy of the original list. This means it copies the top level of the list only. If in that list you have more complex data structures having nested elements, then those will not be cloned. So the new list only hold half the reference of the original list.\n",
        "\n",
        "deepcopy(): It is more subtle as it copies even the nested objects recursively. Although copy.deepcopy() is slightly slower than copy.copy(), it’s safer to use if you don’t know whether the list being copied contains other lists (or other mutable objects like dictionaries or sets).\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KeaP-kYTF8d8"
      },
      "source": [
        "**23. How to remove duplicate elements in the list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uYqIeF0GGVUA",
        "outputId": "3b8ee851-83fe-4d95-e89e-82956e196bed"
      },
      "source": [
        "new = [1, 2, 3, 1, 2, 4, 5, 4 ,6, 2]\n",
        "print(\"List Before Duplicates:\", new)\n",
        "temp = []\n",
        "for i in new:\n",
        "    if i not in temp:\n",
        "        temp.append(i)\n",
        "\n",
        "new = temp\n",
        "print(\"List After removing duplicates:\", new)"
      ],
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "List Before Duplicates: [1, 2, 3, 1, 2, 4, 5, 4, 6, 2]\n",
            "List After removing duplicates: [1, 2, 3, 4, 5, 6]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2iNBjPK-HNZW"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4OiRMdvDGwOy"
      },
      "source": [
        "**24. How to find an index of an element in the python list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IZak7iXOG8vY",
        "outputId": "a887aac2-b78a-4d20-cd26-f1a0d40683bb"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "index = a.index(\"banana\")\n",
        "print(index)"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "O33s0U40HOlS"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ImJR9WiLHPyr"
      },
      "source": [
        "**25. How to find the occurrences of an element in the python list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V_D8JZAVHgwC",
        "outputId": "4d14a8dd-7219-47d5-e5f0-911cd854aec8"
      },
      "source": [
        "num = [3, 1, 2, 3, 1, 2, 4, 2, 4 , 6, 2, 5, 6, 2, 1]\n",
        "print(\"2 has occured\", num.count(2), \"times.\")"
      ],
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "2 has occured 5 times.\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vb3y7BPrIDBH"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qWeDe4YFIEB4"
      },
      "source": [
        "**26. How to insert an item at a given position?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n_-LtUGaI4r_"
      },
      "source": [
        "By using insert()"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "54-SmNYsIXIF",
        "outputId": "a7e02791-bd8a-448c-de8e-b8ad4b1d414b"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "a.insert(3, \"guava\")\n",
        "print(a)"
      ],
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['apple', 'mango', 'orange', 'guava', 'banana', 'grapes']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4QzrvVePJCGK"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yhMMNM5BJC_4"
      },
      "source": [
        "**27. How to check if an item is in the list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lcxSLEg0JXNX",
        "outputId": "e7b5f800-c8dc-43f7-9e1e-4b13908dbb85"
      },
      "source": [
        "a = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "item = input(\"Enter the item: \")\n",
        "if item in a:\n",
        "  print(item, \"is present\")"
      ],
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Enter the item: mango\n",
            "mango is present\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8NgItzRlJ8Mu"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LhHtm9epJ_IN"
      },
      "source": [
        "**28. How to flatten a list in python?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0WIMEq2cKe1K",
        "outputId": "d4cb1ed3-f613-4bff-b496-8daa24d9736f"
      },
      "source": [
        "nested = [['a','b','c'],['d','e','f'],['g','h','i']]\n",
        "flat = []\n",
        "for i in nested:\n",
        "    for j in i:\n",
        "        flat.append(j)\n",
        "print(\"Original list:\", nested)\n",
        "print(\"Flattened list:\", flat)"
      ],
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Original list: [['a', 'b', 'c'], ['d', 'e', 'f'], ['g', 'h', 'i']]\n",
            "Flattened list: ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x6tC_1O2Kt-E"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8xNWXcGJKvi_"
      },
      "source": [
        "**29. How to convert python list to other data structures like set, tuple, dictionary?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0DLmfREpLIC4",
        "outputId": "492a23db-c31f-4b28-8227-62295c4816f4"
      },
      "source": [
        "fruit = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "tup = tuple(fruit)\n",
        "print(\"TUPLE: \", tup)\n",
        "set1 = set(fruit)\n",
        "print(\"SET: \", set1)\n",
        "\n",
        "slno = [1, 2, 3, 4, 5]\n",
        "dictionary = dict(zip(slno, fruit))\n",
        "print(\"DICTIONARY: \", dictionary)"
      ],
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "TUPLE:  ('apple', 'mango', 'orange', 'banana', 'grapes')\n",
            "SET:  {'mango', 'banana', 'apple', 'grapes', 'orange'}\n",
            "DICTIONARY:  {1: 'apple', 2: 'mango', 3: 'orange', 4: 'banana', 5: 'grapes'}\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2_BDbf9MyyL"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KIbUzxXcM0Pr"
      },
      "source": [
        "**30. How to apply a function to all items in the list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BoTTnZUcNX7p",
        "outputId": "06911dcf-53e6-441a-85a2-30be8de97481"
      },
      "source": [
        "fruit = ['apple', 'mango', 'orange', 'banana', 'grapes']\n",
        "cap = []\n",
        "for i in fruit:\n",
        "    cap.append(i.upper())\n",
        "print(cap)\n"
      ],
      "execution_count": 34,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "['APPLE', 'MANGO', 'ORANGE', 'BANANA', 'GRAPES']\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "T6MgW8HvODHv"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LJgfRhnGOE0d"
      },
      "source": [
        "**31. How to filter the elements based on a function in a python list?**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lDW98vz1OZW0",
        "outputId": "bc5944b5-083e-458b-c978-e0518dd9a2b7"
      },
      "source": [
        "scores = [70, 60, 40, 90, 50, 50, 60, 85, 30]\n",
        "filtered = filter(lambda score: score >= 60, scores)\n",
        "print(list(filtered))"
      ],
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "[70, 60, 90, 60, 85]\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QBXB4NWpO5zy"
      },
      "source": [
        "\n",
        "\n",
        "---\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ApLSOqABO6-F"
      },
      "source": [
        "**32. How python lists are stored in memory?**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FA-NsSyfQjXI"
      },
      "source": [
        "Lists are stored in distinct chunks of memory which are linked together with pointers, which enables efficient use of memory generally and doesn't require resizing.\n",
        "\n",
        "---\n",
        "\n"
      ]
    }
  ]
}