28. All_about_Lists_in_Python.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1ATZ7GfgUq3M"
      },
      "source": [
        "# **Python list**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5Yd-RBeBUq3Q"
      },
      "source": [
        "**Python lists are like containers.**\n",
        "\n",
        "Consider a varibale \"Flower\". Now, in this variable we can store only a single thing i.e.,\n",
        "\n",
        "Flower = \"Sunflower\"\n",
        "\n",
        "But, if we wish to store more than one element in this variable we can't.\n",
        "\n",
        "*This limitation introduces something called \"List\" in python, which allows us to store more than one element in it.*\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yOlsqJpDUq3S"
      },
      "source": [
        "### **Introduction to list**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Acu_z9BfUq3T"
      },
      "source": [
        "List is a collection of things enclosed in a SQUARE BRACKET and seperated by commas\n",
        "\n",
        "Example,\n",
        "list1 = [\"a\", 100, 0.10]"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "deePr9k4Uq3U"
      },
      "source": [
        "\n",
        "\n",
        "> #### <u>**Facts about list:**</u>\n",
        "\n",
        "**1. List is dynamically sized array!**\n",
        "<br>  _Meaning you can add or remove elements at runtime without defining a fixed size beforehand._\n",
        "\n",
        "**2. Can stores sequence of various data types.**\n",
        "<br>  _A single list can contain many data types like int, str, boolean, float, objects._\n",
        "\n",
        "**3. Not homogenous, its heterogenous!**\n",
        "<br>  _Lists are not restricted to a single data type... a single list can contain multiple types of elements._\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "62f6OtzwUq3V"
      },
      "source": [
        "> #### <u>**Charcteristics of list:**</u>\n",
        "\n",
        "**1. Ordered list :**  \n",
        "    _which says elements in the list have fixed position._\n",
        "\n",
        "**2. Lists are Mutable :**  \n",
        "    _which means alterations/changes are possible, you can modify list content (e.g., adding, removing, or updating elements)._\n",
        "\n",
        "**3. Duplicates allowed :**  \n",
        "    _lists can have duplicate elements!_\n",
        "\n",
        "**4. List Indexing helping access the elements stored in a list :**  \n",
        "   _which means you can access elements using their position (offset)._  \n",
        "   * The first element has an index of 0\n",
        "\n",
        "   * <u>Indexing</u> :  It's a shift or offset from start; usually indexing begins from 0. To conclude why,  \n",
        "   let's consider this:\n",
        "\n",
        "        `list_a` = [1, 2, 3, 4, 5, 6]  \n",
        "\n",
        "        | Index             | 0   | 1   | 2   | 3   | 4   | 5   |\n",
        "        |-------------------|-----|-----|-----|-----|-----|-----|\n",
        "        | Element of list_a | 1   | 2   | 3   | 4   | 5   | 6   |\n",
        "\n",
        "        ```python\n",
        "        print(list_a[0])\n",
        "        O/p : 1\n",
        "        ```\n",
        "\n",
        "**5. Negative indexing support :**  \n",
        "   _which says you can access elements using negative indexes, counting from the end._  \n",
        "   Consider `list_a` from above for negative indexing:  \n",
        "\n",
        "   | Negative indexing    | -6  | -5  | -4  | -3  | -2  | -1  |\n",
        "   |----------------------|-----|-----|-----|-----|-----|-----|\n",
        "   | Element of list_a    | 1   | 2   | 3   | 4   | 5   | 6   |\n",
        "\n",
        "**6. List can be quantified :**  \n",
        "    _the `len()` function gives the number of elements present in a list._  \n",
        "    _no matter how big your list is, you can easily find the length of your list, the elements present in your list!_\n",
        "\n",
        "**7. List supports slicing :**  \n",
        "    _which implements list allows to retrieve a subset of elements using slicing `(list[start:end])`_\n",
        "\n",
        "<u> Slicing can be done in 2 main formats:</u>  \n",
        "\n",
        "a. `[start:end]` : This slice starts at the start index and goes up to, but does not include, the end index.  \n",
        "    - `start`: The index at which the slice begins (inclusive).  \n",
        "    - `end`: The index at which the slice ends, that index is excluded or else for end we can consider length till we want to consider the elements of the list.  \n",
        "\n",
        "```python\n",
        "lst = [0, 1, 29, 13, 78, 95, 46]  \n",
        "sliced_lst = lst[2:5]  \n",
        "Output: [29, 13, 78]\n",
        "```\n",
        "b. `[start:end:stride]` : This adds a third argument called stride, which determines how many steps to take between each element.  \n",
        "    - `stride`: A step size, which can be positive or negative. If negative, it reverses the direction of the slice.\n",
        "\n",
        "```python\n",
        "lst = [0, 1, 29, 13, 78, 95, 46]  \n",
        "sliced_lst = lst[2:7:2]  \n",
        "Output: [29, 78, 46]\n",
        "```\n",
        "\n",
        "**8. List can be sorted :**  \n",
        "    _which means you can sort the list in ascending `(list.sort())` or descending order `(list.sort(reverse=True))`_\n",
        "\n",
        "**9. List can be revered :**  \n",
        "    _This implements the order of elements can be revered using `list.reverse()`_\n",
        "\n",
        "**10. List can give Min and Max element, if all elements have a uniform and comparable data type, such as only integers, only floats, or only strings :**  \n",
        "    _which indicates if you use `(min(list))` it will find the smallest and if you use `(max(list))` it will find the largest element from the list._\n",
        "\n",
        "**11. List supports appending :**  \n",
        "    _add a single element to the end of the list using `list.append(x)`_  \n",
        "    _If you want to add something to your list, you can use append simply, this will add elements to the end of the list!_  \n",
        "\n",
        "**12. List supports inserting of elements at a specific position :**  \n",
        "    _insert adds an element at a specific position in list using `list.insert(index, value)`_  \n",
        "    _If you want to add an element at a specific position in a list, you can use insert function to do so!_\n",
        "\n",
        "**13. List supports extending :**  \n",
        "    _extending allows to add multiple elements together at the end of the list using `list.extend([x, y, z])`_  \n",
        "    _If you want to add multiple elements then use extend!_"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jeq2Gld8Uq3W"
      },
      "source": [
        "### **Different lists and using indexing to access the elements!**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S5QpC1DRUq3X",
        "outputId": "2e16ea80-76b6-4615-d353-653ab894f45c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Int data type list : [23, 78, 100, 29987, 1, 0]\n",
            "First element from int list :  23\n",
            "Last element from int list : 0\n",
            "Length of the int list : 6\n",
            "\n",
            "String data type list : ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
            "First element of str list : mahira\n",
            "Last element of string list: Pen\n",
            "length of the str list : 6\n",
            "\n",
            "Boolean data type list : [True, False]\n",
            "First element of boolean list : True\n",
            "Second element of boolean list : False\n",
            "Length of the boolean list : 2\n",
            "\n",
            "float data type list : [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
            "Fourth element of float_list : 99.1\n",
            "Second last element of float list : 0.006\n",
            "Length of the float list : 6\n",
            "\n",
            "All mixed data type list : ['hello', 956, 0.03, 'welcome', True, 78.0, 9.21, 55, False, 'SUCCESS']\n",
            "Fourth last element of all_datatype_list : 9.21\n",
            "Length of mixed data type list : 10\n"
          ]
        }
      ],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "print(f\"Int data type list : {int_list}\")\n",
        "print(\"First element from int list : \", int_list[0])\n",
        "print(f\"Last element from int list : {int_list[-1]}\")\n",
        "print(f\"Length of the int list : {len(int_list)}\")\n",
        "print()\n",
        "\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "print(f\"String data type list : {string_list}\")\n",
        "print(f\"First element of str list : {string_list[0]}\")\n",
        "print(f\"Last element of string list: {string_list[-1]}\")\n",
        "print(f\"length of the str list : {len(string_list)}\")\n",
        "print()\n",
        "\n",
        "boolean_list = [True, False]\n",
        "print(f\"Boolean data type list : {boolean_list}\")\n",
        "print(f\"First element of boolean list : {boolean_list[0]}\")\n",
        "print(f\"Second element of boolean list : {boolean_list[1]}\")\n",
        "#print(f\"Last element of boolean list : {boolean_list[-3]}\")\n",
        "print(f\"Length of the boolean list : {len(boolean_list)}\")\n",
        "print()\n",
        "\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
        "print(f\"float data type list : {float_list}\")\n",
        "print(f\"Fourth element of float_list : {float_list[3]}\")\n",
        "print(f\"Second last element of float list : {float_list[-2]}\")\n",
        "print(f\"Length of the float list : {len(float_list)}\")\n",
        "print()\n",
        "\n",
        "all_datatype_list = ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"]\n",
        "print(f'All mixed data type list : {all_datatype_list}')\n",
        "print(f\"Fourth last element of all_datatype_list : {all_datatype_list[-4]}\")\n",
        "print(f\"Length of mixed data type list : {len(all_datatype_list)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AiN3aNFTUq3a"
      },
      "source": [
        "#### **Using Slicing**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PpE85-UvUq3b",
        "outputId": "802f7e55-bccd-47ca-f652-4be4aae224a0"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sample univerity data list : ['Suman', 233, 9.5, True, 'Abhinav', 449, 3.31, False, 'Mahira', 160, 6.09, True]\n"
          ]
        }
      ],
      "source": [
        "sample_university_data = [\"Suman\", 233, 9.5, True, \"Abhinav\", 449, 3.31, False, \"Mahira\", 160, 6.09, True]\n",
        "lst = sample_university_data # for quick short access we are storing our main database to a list lst\n",
        "print(f\"Sample univerity data list : {lst}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "odYuP_UMUq3c",
        "outputId": "052f0dae-4cff-49e6-9e88-d9efaede1817"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Length of sample university list : 12\n"
          ]
        }
      ],
      "source": [
        "print(\"Length of sample university list :\", len(lst))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8p_OqnuiUq3c",
        "outputId": "6faf2f3b-5156-4750-c22d-eca0535cfb31"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lst[:] slicing prints the list as it is : ['Suman', 233, 9.5, True, 'Abhinav', 449, 3.31, False, 'Mahira', 160, 6.09, True]\n",
            "lst[1:] prints everything except first element : [233, 9.5, True, 'Abhinav', 449, 3.31, False, 'Mahira', 160, 6.09, True]\n",
            "lst[:-1] prints everything except last element : ['Suman', 233, 9.5, True, 'Abhinav', 449, 3.31, False, 'Mahira', 160, 6.09]\n"
          ]
        }
      ],
      "source": [
        "print(f\"lst[:] slicing prints the list as it is : {lst[:]}\")\n",
        "print(f\"lst[1:] prints everything except first element : {lst[1:]}\")\n",
        "print(f\"lst[:-1] prints everything except last element : {lst[:-1]}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DIi_x6PtUq3d",
        "outputId": "e779fba5-2ba5-46dd-e4ce-93f4baadb387"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Abhinav's data : ['Abhinav', 449, 3.31, False]\n",
            "Suman's data : ['Suman', 233, 9.5, True]\n",
            "Mahira's data : ['Mahira', 160, 6.09, True]\n"
          ]
        }
      ],
      "source": [
        "print(\"Abhinav's data :\",lst[4:8])\n",
        "print(\"Suman's data :\", lst[0:4])\n",
        "print(f\"Mahira's data : {lst[8:12]}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "t65fx87uUq3e",
        "outputId": "185b2344-b28a-4c99-9547-3d4164e3e2d8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All data except Suman's data : ['Abhinav', 449, 3.31, False, 'Mahira', 160, 6.09, True]\n",
            "All data except Mahira's data : ['Suman', 233, 9.5, True, 'Abhinav', 449, 3.31, False]\n"
          ]
        }
      ],
      "source": [
        "print(f\"All data except Suman's data : {lst[4:]}\")\n",
        "print(f\"All data except Mahira's data : {lst[:8]}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s-JLrQ_9Uq3e",
        "outputId": "06c6d827-6689-4c04-e0ec-64ac13c045a9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "lst[::] prints the complete list : ['Suman', 233, 9.5, True, 'Abhinav', 449, 3.31, False, 'Mahira', 160, 6.09, True]\n",
            "lst[0::2] prints elements with a stride of 2 : ['Suman', 9.5, 'Abhinav', 3.31, 'Mahira', 6.09]\n",
            "lst[0::3] prints elements from start with stride 3 (3 steps) : ['Suman', True, 3.31, 160]\n"
          ]
        }
      ],
      "source": [
        "print(f\"lst[::] prints the complete list : {lst[::]}\")\n",
        "print(f\"lst[0::2] prints elements with a stride of 2 : {lst[0::2]}\")\n",
        "print(f\"lst[0::3] prints elements from start with stride 3 (3 steps) : {lst[0::3]}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cVyosC6GUq3f",
        "outputId": "2ed6e06e-9676-4016-e609-c40bd18bc896"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "All student names present in the list : ['Suman', 'Abhinav', 'Mahira']\n",
            "Corresponding roll no. of those students : [233, 449, 160]\n",
            "Corresponding Grade point of those students : [9.5, 3.31, 6.09]\n",
            "Did that student passed? (corresponding pass status - True/False) : [True, False, True]\n"
          ]
        }
      ],
      "source": [
        "print(f\"All student names present in the list : {lst[0:12:4]}\")\n",
        "print(f\"Corresponding roll no. of those students : {lst[1:12:4]}\")\n",
        "print(f\"Corresponding Grade point of those students : {lst[2:12:4]}\")\n",
        "print(f\"Did that student passed? (corresponding pass status - True/False) : {lst[3:12:4]}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IQB1BL6TUq3f"
      },
      "source": [
        "#### **Sorting, reversing of list**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2DcLpTk1Uq3g"
      },
      "source": [
        "| Feature                     | `list.sort()`           | `list.sort(reverse=True)`   |\n",
        "|-----------------------------|-------------------------|-----------------------------|\n",
        "| **_Purpose_**                 | Ascending order         | Descending order            |\n",
        "| **_Effect on List_**          | Modifies in-place        | Modifies in-place           |\n",
        "| **_Element Comparison_**      |           ✅      | ✅                    |\n",
        "| **_Example_**                 | `[3, 1, 4, 2].sort()`    | `[3, 1, 4, 2].sort(reverse=True)` |\n",
        "| **_Result_**                  | `[1, 2, 3, 4]`          | `[4, 3, 2, 1]`              |\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "kRpaWUQ5Uq3h"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MkfYR5VBUq3h",
        "outputId": "f0d1c7eb-a20d-4c7f-f903-c5f376cd80cb"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ordering int list [23, 78, 100, 29987, 1, 0] in ascending order using sort ➜ [0, 1, 23, 78, 100, 29987]\n",
            "\n",
            "Ordering string list ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen'] in ascending order using sort ➜ ['Maths', 'Pen', 'Physics', 'book', 'mahira', 'science']\n",
            "\n",
            "Ordering boolean list [True, False] in ascending order using sort ➜ [False, True]\n",
            "\n",
            "Ordering float list [12.0, 89.99, 78.88, 99.1, 0.006, 0.5] in ascending order using sort ➜ [0.006, 0.5, 12.0, 78.88, 89.99, 99.1]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "int_list.sort()\n",
        "print(f\"Ordering int list [23, 78, 100, 29987, 1, 0] in ascending order using sort ➜ {int_list}\")\n",
        "print()\n",
        "\n",
        "string_list.sort()\n",
        "print(f\"Ordering string list ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen'] in ascending order using sort ➜ {string_list}\")\n",
        "print()\n",
        "\n",
        "boolean_list.sort()\n",
        "print(f\"Ordering boolean list [True, False] in ascending order using sort ➜ {boolean_list}\")\n",
        "print()\n",
        "\n",
        "float_list.sort()\n",
        "print(f\"Ordering float list [12.0, 89.99, 78.88, 99.1, 0.006, 0.5] in ascending order using sort ➜ {float_list}\")\n",
        "print()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "tkJgKpEGUq3i"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mUSJU8U-Uq3j",
        "outputId": "2aa00be3-0e17-4474-90ff-195b8b9bb815"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ordering int list [23, 78, 100, 29987, 1, 0] in descending order using sort(reverse = True) ➜ [29987, 100, 78, 23, 1, 0]\n",
            "\n",
            "Ordering string list ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen'] in descending order using sort(reverse = True) ➜ ['science', 'mahira', 'book', 'Physics', 'Pen', 'Maths']\n",
            "\n",
            "Ordering boolean list [True, False] in descending order using sort(reverse = True) ➜ [True, False]\n",
            "\n",
            "Ordering float list [12.0, 89.99, 78.88, 99.1, 0.006, 0.5] in descending order using sort(reverse = True) ➜ [99.1, 89.99, 78.88, 12.0, 0.5, 0.006]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "int_list.sort(reverse = True)\n",
        "print(f\"Ordering int list [23, 78, 100, 29987, 1, 0] in descending order using sort(reverse = True) ➜ {int_list}\")\n",
        "print()\n",
        "\n",
        "string_list.sort(reverse = True)\n",
        "print(f\"Ordering string list ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen'] in descending order using sort(reverse = True) ➜ {string_list}\")\n",
        "print()\n",
        "\n",
        "boolean_list.sort(reverse = True)\n",
        "print(f\"Ordering boolean list [True, False] in descending order using sort(reverse = True) ➜ {boolean_list}\")\n",
        "print()\n",
        "\n",
        "float_list.sort(reverse = True)\n",
        "print(f\"Ordering float list [12.0, 89.99, 78.88, 99.1, 0.006, 0.5] in descending order using sort(reverse = True) ➜ {float_list}\")\n",
        "print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3nKFU3nQUq3k"
      },
      "source": [
        "| Feature                   | `list.sort(reverse=True)`          | `list.reverse()`             |\n",
        "|---------------------------|-------------------------------------|------------------------------|\n",
        "| **Purpose**               | Sort the list in descending order  | Reverse the current order    |\n",
        "| **Behavior**              | Sorting (based on element values)  | Flipping (no value comparison) |\n",
        "| **Element Comparison**    | Required                          | Not required                 |\n",
        "| **Order Dependency**      | Independent of current order       | Dependent on current order   |"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "IlL44UEWUq3k"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
        "all_datatype_list = ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "amIfpkh6Uq3k",
        "outputId": "baf19922-3720-47ee-cbba-38498fcdaf2d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reversed (flipped) int list [23, 78, 100, 29987, 1, 0] ➜ [0, 1, 29987, 100, 78, 23]\n",
            "\n",
            "Reversed (flipped) string list ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen'] ➜ ['Pen', 'science', 'Maths', 'Physics', 'book', 'mahira']\n",
            "\n",
            "Reversed (flipped) boolean list [True, False] ➜ [False, True]\n",
            "\n",
            "Reversed (flipped) float list [12.0, 89.99, 78.88, 99.1, 0.006, 0.5] ➜ [0.5, 0.006, 99.1, 78.88, 89.99, 12.0]\n",
            "\n",
            "Reversed (flipped) list of mixed data type elements ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"] ➜ ['SUCCESS', False, 55, 9.21, 78.0, True, 'welcome', 0.03, 956, 'hello']\n",
            "\n"
          ]
        }
      ],
      "source": [
        "int_list.reverse()\n",
        "print(f\"Reversed (flipped) int list [23, 78, 100, 29987, 1, 0] ➜ {int_list}\")\n",
        "print()\n",
        "\n",
        "string_list.reverse()\n",
        "print(f\"Reversed (flipped) string list ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen'] ➜ {string_list}\")\n",
        "print()\n",
        "\n",
        "boolean_list.reverse()\n",
        "print(f\"Reversed (flipped) boolean list [True, False] ➜ {boolean_list}\")\n",
        "print()\n",
        "\n",
        "float_list.reverse()\n",
        "print(f\"Reversed (flipped) float list [12.0, 89.99, 78.88, 99.1, 0.006, 0.5] ➜ {float_list}\")\n",
        "print()\n",
        "\n",
        "all_datatype_list.reverse()\n",
        "print(f\"Reversed (flipped) list of mixed data type elements ['hello', 956, 0.03, \\\"welcome\\\", True, 78.00, 9.21, 55, False, \\\"SUCCESS\\\"] ➜ {all_datatype_list}\")\n",
        "print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kBl12raCUq3l"
      },
      "source": [
        "#### **Maximum and Minimum from list**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "x13E7agcUq3m"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cS98jEsgUq3m",
        "outputId": "6d68bd94-708a-4f11-8266-bea59e2b2494"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Maximum of int list : 29987\n",
            "Minimum of int list : 0\n",
            "\n",
            "Maximum of string list : science\n",
            "Minimum of string list : Maths\n",
            "\n",
            "Maximum of boolean list : True\n",
            "Minimum of boolean list : False\n",
            "\n",
            "Maximum of float list : 99.1\n",
            "Minimum of float list : 0.006\n",
            "\n"
          ]
        }
      ],
      "source": [
        "print(f\"Maximum of int list : {max(int_list)}\")\n",
        "print(f\"Minimum of int list : {min(int_list)}\")\n",
        "print()\n",
        "\n",
        "print(f\"Maximum of string list : {max(string_list)}\")\n",
        "print(f\"Minimum of string list : {min(string_list)}\")\n",
        "print()\n",
        "\n",
        "print(f\"Maximum of boolean list : {max(boolean_list)}\")\n",
        "print(f\"Minimum of boolean list : {min(boolean_list)}\")\n",
        "print()\n",
        "\n",
        "print(f\"Maximum of float list : {max(float_list)}\")\n",
        "print(f\"Minimum of float list : {min(float_list)}\")\n",
        "print()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bW5N1i6yUq3m"
      },
      "source": [
        "#### **Appending list**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "id": "swYOgtr2Uq3n"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
        "all_datatype_list = ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8L3JCldTUq3n",
        "outputId": "9f7e1c5d-c0d4-4b31-90db-0df8da7ae7e2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adding 654 to int list using append : [23, 78, 100, 29987, 1, 0, 654]\n",
            "\n",
            "Adding 'notes' to string list : ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen', 'notes']\n",
            "\n",
            "Adding True value to boolean data tye : [True, False, True]\n",
            "\n",
            "Adding a float value to float_list : [12.0, 89.99, 78.88, 99.1, 0.006, 0.5, 0.0125]\n",
            "\n",
            "Mixed data type list after appending values : ['hello', 956, 0.03, 'welcome', True, 78.0, 9.21, 55, False, 'SUCCESS', 'coffee', 50.9]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "int_list.append(654) #int_list[len(int_list):] = [654] or int_list.insert(len(int_list), 654)\n",
        "print(f\"Adding 654 to int list using append : {int_list}\")\n",
        "print()\n",
        "\n",
        "string_list.append(\"notes\") #string_list[len(string_list):] = [\"notes\"] or string_list.insert(len(string_list), \"notes\")\n",
        "print(f\"Adding 'notes' to string list : {string_list}\")\n",
        "print()\n",
        "\n",
        "boolean_list.append(True) #boolean_list[len(boolean_list):] = [True] or boolean_list.insert(len(boolean_list), True)\n",
        "print(f\"Adding True value to boolean data tye : {boolean_list}\")\n",
        "print()\n",
        "\n",
        "float_list.append(0.0125) #float_list[len(float_list):] = [0.0125] or float_list.insert(len(float_list), 0.0125)\n",
        "print(f\"Adding a float value to float_list : {float_list}\")\n",
        "print()\n",
        "\n",
        "all_datatype_list.append(\"coffee\") # all_datatype_list[len(all_datatype_list):] = \"coffee\" or all_datatype_list.insert(len(all_datatype_list), \"coffee\")\n",
        "all_datatype_list.append(50.9) # all_datatype_list[len(all_datatype_list):] = 50.9 or all_datatype_list.insert(len(all_datatype_list), 50.9)\n",
        "print(f\"Mixed data type list after appending values : {all_datatype_list}\")\n",
        "print()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vWMKahHsUq3o"
      },
      "source": [
        "#### **Inserting in list**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "2ZfS7mGTUq3o"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
        "all_datatype_list = ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rWhnRfHaUq3p",
        "outputId": "9bad26b0-f552-4d3c-f2cb-a6c37617de75"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Int list after inserting 654 at position 4 (index 3) : [23, 78, 100, 654, 29987, 1, 0]\n",
            "\n",
            "Inserting 'notes' to string list at 0th index (making 1st element) : ['notes', 'mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
            "\n",
            "Boolean list after inserting True at position 3 (index 2) : [True, False, True]\n",
            "\n",
            "Float list after inserting 0.0125 at position 7 (index 6) : [12.0, 89.99, 78.88, 99.1, 0.006, 0.5, 0.0125]\n",
            "\n",
            "Mixed data type list after inserting 'coffee' at 6th position : ['hello', 956, 0.03, 'welcome', True, 'coffee', 78.0, 9.21, 55, False, 'SUCCESS']\n",
            "\n"
          ]
        }
      ],
      "source": [
        "int_list.insert(3, 654)\n",
        "print(f\"Int list after inserting 654 at position 4 (index 3) : {int_list}\")\n",
        "print()\n",
        "\n",
        "string_list.insert(0, \"notes\")\n",
        "print(f\"Inserting 'notes' to string list at 0th index (making 1st element) : {string_list}\")\n",
        "print()\n",
        "\n",
        "boolean_list.insert(2, True)\n",
        "print(f\"Boolean list after inserting True at position 3 (index 2) : {boolean_list}\")\n",
        "print()\n",
        "\n",
        "float_list.insert(6, 0.0125)\n",
        "print(f\"Float list after inserting 0.0125 at position 7 (index 6) : {float_list}\")\n",
        "print()\n",
        "\n",
        "all_datatype_list.insert(5, \"coffee\")\n",
        "#all_datatype_list.insert(2,50.9)\n",
        "print(f\"Mixed data type list after inserting 'coffee' at 6th position : {all_datatype_list}\")\n",
        "print()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f7xEszWiUq3p"
      },
      "source": [
        "#### **Using extend to add multiple elements in a list**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TIHqgTbtUq3q",
        "outputId": "3fb29ceb-0565-47e3-e406-7f71c4c27fbc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Adding multiple elements to int list : [23, 78, 100, 654, 29987, 1, 0, 99, 654, 41, 33, 1]\n",
            "\n",
            "Adding multiple elements to string list : ['notes', 'mahira', 'book', 'Physics', 'Maths', 'science', 'Pen', 'novels', 'sketching', 'notes']\n",
            "\n",
            "Adding multiple elements to boolean list : [True, False, True, True, False, False, True, False]\n",
            "\n",
            "Adding multiple elements to float list : [12.0, 89.99, 78.88, 99.1, 0.006, 0.5, 0.0125, 7388.0099999, 1e-06, 9.9, 1.111111111111111e+19]\n",
            "\n",
            "Adding multiple elements to mixed data type list : ['hello', 956, 0.03, 'welcome', True, 'coffee', 78.0, 9.21, 55, False, 'SUCCESS', 5, True, 'coffee', 56, 'flowers', 2.009, False, 100731901232]\n",
            "\n"
          ]
        }
      ],
      "source": [
        "int_list.extend([99, 654, 41, 33, 1])\n",
        "print(f\"Adding multiple elements to int list : {int_list}\")\n",
        "print()\n",
        "\n",
        "string_list.extend([\"novels\", \"sketching\", \"notes\"])\n",
        "print(f\"Adding multiple elements to string list : {string_list}\")\n",
        "print()\n",
        "\n",
        "boolean_list.extend([True, False, False, True, False])\n",
        "print(f\"Adding multiple elements to boolean list : {boolean_list}\")\n",
        "print()\n",
        "\n",
        "float_list.extend([7388.0099999, 0.000001000, 9.9, 11111111111111111111.344443333])\n",
        "print(f\"Adding multiple elements to float list : {float_list}\")\n",
        "print()\n",
        "\n",
        "all_datatype_list.extend([5, True, \"coffee\", 56, \"flowers\", 2.009, False, 100731901232])\n",
        "#all_datatype_list.insert(2,50.9)\n",
        "print(f\"Adding multiple elements to mixed data type list : {all_datatype_list}\")\n",
        "print()\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y7ykQJXtUq3q"
      },
      "source": [
        "#### **Remove, Pop and clear elements from list**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "-sSOP4k6Uq3q"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
        "all_datatype_list = ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EJEWsorxUq3r",
        "outputId": "5c25a562-50e2-492c-bde0-cbd50e47425d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[23, 78, 29987, 1, 0]\n",
            "['mahira', 'book', 'Physics', 'Maths', 'Pen']\n"
          ]
        }
      ],
      "source": [
        "int_list.remove(100)\n",
        "print(int_list)\n",
        "\n",
        "string_list.remove(\"science\")\n",
        "print(string_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "ZXlUVexzUq33"
      },
      "outputs": [],
      "source": [
        "int_list = [23, 78, 100, 29987, 1, 0]\n",
        "string_list = ['mahira', 'book', 'Physics', 'Maths', 'science', 'Pen']\n",
        "boolean_list = [True, False]\n",
        "float_list = [12.0, 89.99, 78.88, 99.1, 0.006, 0.5]\n",
        "all_datatype_list = ['hello', 956, 0.03, \"welcome\", True, 78.00, 9.21, 55, False, \"SUCCESS\"]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UOpVTGieUq33",
        "outputId": "08479325-4c6e-4d43-b949-399759d2f8c6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "boolean_list.pop() removes last element from the list : [True]\n",
            "string_list.pop(0) removes element at 0th index or 1st element : ['book', 'Physics', 'Maths', 'science', 'Pen']\n",
            "int_list.pop(1) removes element at index 1 : [23, 100, 29987, 1, 0]\n",
            "float_list.pop(-2) removes 2nd last element of the list i.e., element at -2 index : [12.0, 89.99, 78.88, 99.1, 0.5]\n"
          ]
        }
      ],
      "source": [
        "boolean_list.pop() # similar to boolean_list.pop(-1)\n",
        "print(f\"boolean_list.pop() removes last element from the list : {boolean_list}\")\n",
        "\n",
        "string_list.pop(0)\n",
        "print(f\"string_list.pop(0) removes element at 0th index or 1st element : {string_list}\")\n",
        "\n",
        "int_list.pop(1)\n",
        "print(f\"int_list.pop(1) removes element at index 1 : {int_list}\")\n",
        "\n",
        "float_list.pop(-2)\n",
        "print(f\"float_list.pop(-2) removes 2nd last element of the list i.e., element at -2 index : {float_list}\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5BlglrT7Uq34",
        "outputId": "1e1e93b9-7b79-4b7c-a595-8fbfbfacf15c"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Boolean list after using clear function :  []\n",
            "Float list after using clear function :  []\n"
          ]
        }
      ],
      "source": [
        "boolean_list.clear()\n",
        "print(\"Boolean list after using clear function : \", boolean_list)\n",
        "\n",
        "float_list.clear()\n",
        "print(\"Float list after using clear function : \", float_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MwEgCxIlUq34",
        "outputId": "ecf79618-d191-4e40-9ba6-ebd9cb77f950"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n"
          ]
        }
      ],
      "source": [
        "list_a = [0, 78, 56, 38, 23, 89, 45, 49, 56, 38, 47, 56]\n",
        "print(list_a.count(56))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1yyY9PuoUq35",
        "outputId": "9c174995-1e9b-4bb5-fcac-0c78739f715a"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2\n",
            "8\n",
            "11\n"
          ]
        }
      ],
      "source": [
        "print(list_a.index(56))\n",
        "print(list_a.index(56, 5))\n",
        "print(list_a.index(56, 9))\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SaQ8DaD8Uq35"
      },
      "source": [
        "\n",
        "**14. List supports concatenation :**  \n",
        "    _which suggests you can combine two or more lists using the `+` operator._\n",
        "\n",
        "**15. List supports multiplication :**  \n",
        "    _which suggests you can repeat the elements of a list multiple times using the `*` operator._  \n",
        "\n",
        "**16. List supports membership testing :**  \n",
        "    _which suggests you can check if an element exists in a list using the `in` keyword._\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "2JeKz1lwU80Z"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.0"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}