TASK7_Numpy_and_Pandas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyOngSYu/51cKPoFjEyKd07L",
      "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/aneeshmurali-n/Python-Tasks/blob/main/TASK7_Numpy_and_Pandas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#NumPy"
      ],
      "metadata": {
        "id": "rHraDngyE9_B"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1. How to extract all odd numbers from arr?\n"
      ],
      "metadata": {
        "id": "72OqNgVUFv1B"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "k_rtpw-yE57T",
        "outputId": "ab629656-8149-491e-d7f4-ff050716c9b2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 3 5 7 9]\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
        "#print(arr % 2 == 1) #base logic\n",
        "#We re using arr % 2 == 1 to create a boolean mask where True represents positions in the array where the corresponding element is odd, and then using this mask to filter the elements of arr.\n",
        "odd_numbers = arr[arr % 2 == 1] # Use boolean indexing to extract odd numbers\n",
        "print(odd_numbers)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##2. Replace all odd numbers in arr with -1 without changing"
      ],
      "metadata": {
        "id": "U2r6nJCtI0VP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "arr = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
        "arr[arr % 2 == 1] = -1 # Replace all odd numbers with -1\n",
        "print(arr) # Print the modified array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0pwLJwAzI5N6",
        "outputId": "7025fcb2-7450-422d-9e56-bdc0bd26a440"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 0 -1  2 -1  4 -1  6 -1  8 -1]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##3.  Convert a 1D array to a 2D array with 2 rows\n",
        "<p>Desired Output:<br>\n",
        "array([[0, 1, 2, 3, 4],<br>\n",
        "        [5, 6, 7, 8, 9]])</p>\n"
      ],
      "metadata": {
        "id": "MlsZHbaxLWfX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "arr = np.arange(10)  # 1D array with numbers from 0 to 9\n",
        "# Reshape the 1D array to a 2D array with 2 rows\n",
        "array_2d = arr.reshape(2, -1)\n",
        "#2 indicates the number of rows you want in the reshaped array.\n",
        "#-1, is a placeholder. When -1 is used in the reshape() method,\n",
        "#it means that NumPy should automatically determine the number of columns based on the size of the array and the specified number of rows.\n",
        "print(array_2d)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OiAgG8yNLQ-1",
        "outputId": "ecddcc72-21ee-4144-fb77-af8f77e4260b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 1 2 3 4]\n",
            " [5 6 7 8 9]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##4. Stack arrays a and b vertically\n",
        "<p>Desired Output:<br>\n",
        " array([[0, 1, 2, 3, 4],<br>\n",
        "        [5, 6, 7, 8, 9],<br>\n",
        "        [1, 1, 1, 1, 1],<br>\n",
        "        [1, 1, 1, 1, 1]])</p>"
      ],
      "metadata": {
        "id": "L1lS1uZ7Nakk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "a = np.arange(10).reshape(2, -1)  # Create a 2D array 'a' with numbers from 0 to 9, reshaped to have 2 rows\n",
        "#print(a,end = '\\n\\n')\n",
        "b = np.repeat(1, 10).reshape(2, -1)  # Create a 2D array 'b' with all elements as 1, reshaped to have 2 rows\n",
        "#print(b,end = '\\n\\n')\n",
        "arr_stack_a_b = np.vstack((a, b)) # Stack arrays 'a' and 'b' vertically, def vstack(tup, *, dtype=None, casting='same_kind')\n",
        "print(arr_stack_a_b) # print vertically stacked array\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Cm86Wg5kNhMD",
        "outputId": "391886a5-1ef4-4b08-e732-ed65dadfd3fa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 1 2 3 4]\n",
            " [5 6 7 8 9]\n",
            " [1 1 1 1 1]\n",
            " [1 1 1 1 1]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##5. Stack the arrays a and b horizontally.\n",
        "<p>Desired Output:<br>\n",
        " array([[0, 1, 2, 3, 4, 1, 1, 1, 1, 1],<br>\n",
        "        [5, 6, 7, 8, 9, 1, 1, 1, 1, 1]])</p>"
      ],
      "metadata": {
        "id": "cBpbfkwOQnZS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "a = np.arange(10).reshape(2,-1)\n",
        "b = np.repeat(1, 10).reshape(2,-1)\n",
        "# Stack arrays 'a' and 'b' horizontally\n",
        "arr_stack_a_b = np.hstack((a, b)) #def hstack(tup, *, dtype=None, casting='same_kind')\n",
        "print(arr_stack_a_b) # print horizontally stacked array"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LPzBGxvkQ7It",
        "outputId": "2997de8b-07cb-49da-c1d6-78e94df2bcf0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[0 1 2 3 4 1 1 1 1 1]\n",
            " [5 6 7 8 9 1 1 1 1 1]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##6.How to get the common items between two python numpy arrays?\n",
        "Get the common items between a and b\n",
        "\n"
      ],
      "metadata": {
        "id": "9jlzRfMk5auv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "a = np.array([1, 2, 3, 2, 3, 4, 3, 4, 5, 6])\n",
        "b = np.array([7, 2, 10, 2, 7, 4, 9, 4, 9, 8])\n",
        "# Use the np.intersect1d function to find the common items between arrays a and b\n",
        "# This function returns the sorted, unique values that are in both of the input arrays\n",
        "c = np.intersect1d(a, b) #def intersect1d(ar1, ar2, assume_unique=False, return_indices=False)\n",
        "# Print the common items\n",
        "print(c)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fu-AMyeq5cAH",
        "outputId": "4fffc6f0-313d-4a35-8ba4-9f26d3fb5f41"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[2 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##7.How to remove from one array those items that exist in another?\n",
        "Q. From array a remove all items present in array b"
      ],
      "metadata": {
        "id": "KW-rWR_c7JaW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2, 3, 4, 5])\n",
        "b = np.array([5, 6, 7, 8, 9])\n",
        "\n",
        "# Use the np.setdiff1d function to find the items in a that are not in b\n",
        "# This function returns the sorted, unique values in a that are not in b\n",
        "a = np.setdiff1d(a, b) # Remove items in b from a\n",
        "print(a) # Print array a"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "38ibiaGm7OhY",
        "outputId": "89147ab6-da6f-499a-cf4b-96268af8525e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1 2 3 4]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##8. How to get the positions where elements of two arrays match?\n",
        "\n",
        "Q. Get the positions where elements of a and b match\n",
        "<p>Desired Output:<br>\n",
        "(array([1, 3, 5, 7]),)</p>"
      ],
      "metadata": {
        "id": "Le13VBDh89om"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2, 3, 2, 3, 4, 3, 4, 5, 6])\n",
        "b = np.array([7, 2, 10, 2, 7, 4, 9, 4, 9, 8])\n",
        "\n",
        "# Use np.where to find the positions where elements of a and b match\n",
        "matched = np.where(a == b)\n",
        "# Print the matching positions\n",
        "print(matched)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gjWtqrgI9P6O",
        "outputId": "3b8786b4-0dd4-4211-f485-75241cf616f0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(array([1, 3, 5, 7]),)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##9. How to extract all numbers between a given range from a numpy array?\n",
        "Get all items between 5 and 10 from a\n",
        "<p>Desired Output:<br>\n",
        "(array([6, 9, 10]),)</p>"
      ],
      "metadata": {
        "id": "LgZGUjiU-57E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([2, 6, 1, 9, 10, 3, 27])\n",
        "\n",
        "# Use boolean indexing to get all items between 5 and 10\n",
        "items_5_to_10 = a[(a >= 5) & (a <= 10)]\n",
        "# Print items between 5 and 10 from a\n",
        "print(items_5_to_10)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zL9_j6p6_hHO",
        "outputId": "ce1c6fe5-80ce-4e22-e83c-993fb2a0b3c5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[ 6  9 10]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Pandas"
      ],
      "metadata": {
        "id": "K4IvYZupBkQ8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Pandas Data Series"
      ],
      "metadata": {
        "id": "YMyTyXH4Bmbc"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1. Write a Pandas program to convert a dictionary to a Pandas series.\n",
        "\n",
        "```\n",
        "Sample Series:\n",
        "Original dictionary:\n",
        "{'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 800}\n",
        "\n",
        "Converted series:\n",
        "a    100\n",
        "b    200\n",
        "c    300\n",
        "d    400\n",
        "e    800\n",
        "dtype: int64\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "SzW81h4EBrjn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd #Import the Pandas library\n",
        "\n",
        "#original dictionary\n",
        "data = {'a': 100, 'b': 200, 'c': 300, 'd': 400, 'e': 800}\n",
        "# pd.Series(data) function converts the dictionary data into a Pandas series.\n",
        "# The keys of the dictionary become the index of the series, and the values of the dictionary become the values of the series.\n",
        "# Print the converted series\n",
        "print(f\"Converted series:\\n{pd.Series(data)}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YwtXMt1MBlas",
        "outputId": "d8fce0c1-1917-4e6b-ff11-1cc7038de006"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Converted series:\n",
            "a    100\n",
            "b    200\n",
            "c    300\n",
            "d    400\n",
            "e    800\n",
            "dtype: int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##2. Write a Pandas program to convert a NumPy array to a Pandas series.\n",
        "```\n",
        "Sample Series:\n",
        "  NumPy array:\n",
        "[10 20 30 40 50]\n",
        "Converted Pandas series:\n",
        "0    10\n",
        "1    20\n",
        "2    30\n",
        "3    40\n",
        "4    50\n",
        "dtype: int64\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "ZSzPlnpHEMyx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# NumPy array\n",
        "numpy_array = np.array([10, 20, 30, 40, 50])\n",
        "\n",
        "# Convert the NumPy array to a Pandas series\n",
        "pandas_series = pd.Series(numpy_array)\n",
        "\n",
        "# Print the original NumPy array and the converted Pandas series\n",
        "print(f\"NumPy array:\\n{numpy_array}\\nConverted Pandas series:\\n{pandas_series}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ud-fMOosEzfx",
        "outputId": "c43fe604-6cd0-4470-e2e7-e3e022e595dc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "NumPy array:\n",
            "[10 20 30 40 50]\n",
            "Converted Pandas series:\n",
            "0    10\n",
            "1    20\n",
            "2    30\n",
            "3    40\n",
            "4    50\n",
            "dtype: int64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##3. Write a Pandas program to change the data type of given a column or a Series.\n",
        "\n",
        "```\n",
        "Sample Series:\n",
        "    Original Data Series:\n",
        "0       100\n",
        "1       200\n",
        "2    python\n",
        "3    300.12\n",
        "4       400\n",
        "dtype: object\n",
        "Change the said data type to numeric:\n",
        "0    100.00\n",
        "1    200.00\n",
        "2       NaN\n",
        "3    300.12\n",
        "4    400.00\n",
        "dtype: float64\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "Vrvb_MapF2mp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Define the original data series\n",
        "data_series = pd.Series([100, 200, 'python', 300.12, 400])\n",
        "\n",
        "# Print the original data series\n",
        "print(f\"Original Data Series:\\n{data_series}\\n\")\n",
        "\n",
        "# Change the data type to numeric, coercing errors to NaN\n",
        "numeric_series = pd.to_numeric(data_series, errors='coerce')\n",
        "\n",
        "# Print the converted series\n",
        "print(f\"Change the said data type to numeric:\\n{numeric_series}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8t8PdL5TF_MS",
        "outputId": "5ee80e52-7003-4e5f-8db5-d8a241bb1725"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original Data Series:\n",
            "0       100\n",
            "1       200\n",
            "2    python\n",
            "3    300.12\n",
            "4       400\n",
            "dtype: object\n",
            "\n",
            "Change the said data type to numeric:\n",
            "0    100.00\n",
            "1    200.00\n",
            "2       NaN\n",
            "3    300.12\n",
            "4    400.00\n",
            "dtype: float64\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##4. Write a Pandas program to convert the first column of a DataFrame as a Series.\n",
        "\n",
        "```\n",
        "Sample Output:  \n",
        "Original DataFrame\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     2     5     5\n",
        "2     3     6     8\n",
        "3     4     9    12\n",
        "4     7     5     1\n",
        "5    11     0    11\n",
        "\n",
        "1st column as a Series:\n",
        "0     1\n",
        "1     2\n",
        "2     3\n",
        "3     4\n",
        "4     7\n",
        "5    11\n",
        "Name: col1, dtype: int64\n",
        "<class 'pandas.core.series.Series'>\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "3nEze-odH6gC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Create the original DataFrame\n",
        "data = {'col1': [1, 2, 3, 4, 7, 11], 'col2': [4, 5, 6, 9, 5, 0], 'col3': [7, 5, 8, 12, 1, 11]} # a dictionary 'data' with three keys: 'col1', 'col2', and 'col3'.\n",
        "                                                                                               # Each key has a list of values that will form the columns of the DataFrame.\n",
        "\n",
        "df = pd.DataFrame(data)                     # pd.DataFrame(data) function converts the dictionary into a DataFrame named df.\n",
        "\n",
        "# Print the original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# Convert the first column to a Series\n",
        "first_column_series = df['col1']            # This accesses the column labeled 'col1' from the DataFrame df and assigns it to the variable first_column_series.\n",
        "                                            # The resulting first_column_series is a Pandas Series containing the values of the first column.\n",
        "\n",
        "\n",
        "# Print the first column as a Series\n",
        "print(f\"1st column as a Series:\\n{first_column_series}\\n{type(first_column_series)}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-6l5qOPSIAQx",
        "outputId": "64351dee-48be-4b23-cc5a-84815dd19c61"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     5\n",
            "2     3     6     8\n",
            "3     4     9    12\n",
            "4     7     5     1\n",
            "5    11     0    11\n",
            "\n",
            "1st column as a Series:\n",
            "0     1\n",
            "1     2\n",
            "2     3\n",
            "3     4\n",
            "4     7\n",
            "5    11\n",
            "Name: col1, dtype: int64\n",
            "<class 'pandas.core.series.Series'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##5. Write a Pandas program to convert a given Series to an array.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original Data Series:\n",
        "0       100\n",
        "1       200\n",
        "2    python\n",
        "3    300.12\n",
        "4       400\n",
        "dtype: object\n",
        "Series to an array\n",
        "['100' '200' 'python' '300.12' '400']\n",
        "<class 'numpy.ndarray'>\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "XjQIjd9KLtEH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Define the original data series\n",
        "data_series = pd.Series(['100', '200', 'python', '300.12', '400'])\n",
        "\n",
        "# Print the original data series\n",
        "print(f\"Original Data Series:\\n{data_series}\\n\")\n",
        "\n",
        "# Convert the Series to a NumPy array\n",
        "np_array = data_series.to_numpy()                       # .to_numpy() method converts the Pandas series 'data_series' into a NumPy array.\n",
        "\n",
        "# Print the converted array and its type\n",
        "print(f\"Series to an array\\n{np_array}\\n{type(np_array)}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2BT5gdpxL2Pb",
        "outputId": "b5f63302-dec7-4d49-aae5-6466f7b8d76b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original Data Series:\n",
            "0       100\n",
            "1       200\n",
            "2    python\n",
            "3    300.12\n",
            "4       400\n",
            "dtype: object\n",
            "\n",
            "Series to an array\n",
            "['100' '200' 'python' '300.12' '400']\n",
            "<class 'numpy.ndarray'>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##6 Write a Pandas program to convert Series of lists to one Series.\n",
        "```\n",
        "Sample Output:\n",
        "Original Series of list\n",
        "0    [Red, Green, White]\n",
        "1           [Red, Black]\n",
        "2               [Yellow]\n",
        "dtype: object\n",
        "One Series\n",
        "0       Red\n",
        "1     Green\n",
        "2     White\n",
        "3       Red\n",
        "4     Black\n",
        "5    Yellow\n",
        "dtype: object\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "g9MrxFUGNvZn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "# Create a Series\n",
        "series_of_lists = pd.Series([['Red', 'Green', 'White'],['Red', 'Black'],['Yellow']])\n",
        "\n",
        "# Flatten the Series of lists into one Series using explode and reset_index\n",
        "one_series = series_of_lists.explode().reset_index(drop=True) # explode() function to convert each element of the list-like objects in the Series into separate rows.\n",
        "                                                                # reset_index(drop=True) to reset the index of the resulting Series so that it is sequential.\n",
        "print(f\"Original Series of list\\n{series_of_lists}\\n\\nOne Series\\n{one_series}\")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lWEIy6oAN8-f",
        "outputId": "64659293-5e49-4062-e2b1-5c7f8673541c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original Series of list\n",
            "0    [Red, Green, White]\n",
            "1           [Red, Black]\n",
            "2               [Yellow]\n",
            "dtype: object\n",
            "\n",
            "One Series\n",
            "0       Red\n",
            "1     Green\n",
            "2     White\n",
            "3       Red\n",
            "4     Black\n",
            "5    Yellow\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##7.Write a Pandas program to sort a given Series.\n",
        "```\n",
        "Sample Output:\n",
        "Original Data Series:\n",
        "0       100\n",
        "1       200\n",
        "2    python\n",
        "3    300.12\n",
        "4       400\n",
        "dtype: object\n",
        "0       100\n",
        "1       200\n",
        "3    300.12\n",
        "4       400\n",
        "2    python\n",
        "dtype: object\n",
        "```"
      ],
      "metadata": {
        "id": "_xlQ32ABRcMu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Data Series\n",
        "data = pd.Series([100, 200, 'python', 300.12, 400])\n",
        "\n",
        "# Print original Data Series\n",
        "print(f\"Original Data Series:\\n{data}\\n\")\n",
        "\n",
        "# Sort the Data Series\n",
        "sorted_data = data.astype(str).sort_values() #convert all elements in the Series to strings using astype(str) and then sort it with sort_values() methode\n",
        "\n",
        "# Print sorted Data Series\n",
        "print(f\"Sorted Data Series:\\n{sorted_data}\")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m6Zd-v0mRgc2",
        "outputId": "ed4830ea-2369-4ea4-ba03-c0cd38ed242d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original Data Series:\n",
            "0       100\n",
            "1       200\n",
            "2    python\n",
            "3    300.12\n",
            "4       400\n",
            "dtype: object\n",
            "\n",
            "Sorted Data Series:\n",
            "0       100\n",
            "1       200\n",
            "3    300.12\n",
            "4       400\n",
            "2    python\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##Pandas DataFrame"
      ],
      "metadata": {
        "id": "zSdA0NutU9k_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "##1.Write a Pandas program to create a dataframe from a dictionary and display it.\n",
        "```\n",
        "Sample data: {'X':[78,85,96,80,86], 'Y':[84,94,89,83,86],'Z':[86,97,96,72,83]}\n",
        "Expected Output:\n",
        "    X   Y   Z                                                         \n",
        "0  78  84  86                                                        \n",
        "1  85  94  97                                                         \n",
        "2  96  89  96                                                      \n",
        "3  80  83  72                                                         \n",
        "4  86  86  83\n",
        "\n",
        "```\n"
      ],
      "metadata": {
        "id": "PZjHPDT1VEEf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'X': [78, 85, 96, 80, 86], 'Y': [84, 94, 89, 83, 86], 'Z': [86, 97, 96, 72, 83]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Print DataFrame\n",
        "print(df)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7_icDHxvVJA7",
        "outputId": "20984aec-1bbc-4ecc-ece2-10a9060d21b5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "    X   Y   Z\n",
            "0  78  84  86\n",
            "1  85  94  97\n",
            "2  96  89  96\n",
            "3  80  83  72\n",
            "4  86  86  83\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##2. Write a Pandas program to create and display a DataFrame from a specified dictionary data which has the index labels.\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "\n",
        "```\n",
        "Expected Output:\n",
        "   attempts       name qualify  score                              \n",
        "a         1  Anastasia     yes   12.5                                 \n",
        "b         3       Dima      no    9.0                                 \n",
        "....                              \n",
        "i         2      Kevin      no    8.0                                \n",
        "j         1      Jonas     yes   19.0\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "4wGvqOvrZZvZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "print(df)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "aJYV-_BgZb_J",
        "outputId": "3950d306-7a37-4083-9a52-cef0457179f1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "   attempts       name qualify  score\n",
            "a         1  Anastasia     yes   12.5\n",
            "b         3       Dima      no    9.0\n",
            "c         2  Katherine     yes   16.5\n",
            "d         3      James      no    NaN\n",
            "e         2      Emily      no    9.0\n",
            "f         3    Michael     yes   20.0\n",
            "g         1    Matthew     yes   14.5\n",
            "h         1      Laura      no    NaN\n",
            "i         2      Kevin      no    8.0\n",
            "j         1      Jonas     yes   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##3. Write a Pandas program to get the first 3 rows of a given DataFrame.\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "\n",
        "```\n",
        "Expected Output:\n",
        "First three rows of the data frame:                                   \n",
        "   attempts       name qualify  score                              \n",
        "a         1  Anastasia     yes   12.5                                 \n",
        "b         3       Dima      no    9.0                                 \n",
        "c         2  Katherine     yes   16.5\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "peWjAfo5dhPr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "print(f\"First three rows of the data frame:\\n{df.head(3)}\") # The .head(3) method retrieves the first 3 rows of the DataFrame df.\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "21m32-NLdmnO",
        "outputId": "49251ff1-5229-4186-de63-dbf06c8d12bb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "First three rows of the data frame:\n",
            "   attempts       name qualify  score\n",
            "a         1  Anastasia     yes   12.5\n",
            "b         3       Dima      no    9.0\n",
            "c         2  Katherine     yes   16.5\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##4.Write a Pandas program to select the 'name' and 'score' columns from the following DataFrame.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Select specific columns:                                               \n",
        "        name  score                                                  \n",
        "a  Anastasia   12.5                                                   \n",
        "b       Dima    9.0                                                \n",
        "c  Katherine   16.5                                                    \n",
        "...                                                  \n",
        "h      Laura    NaN                                                   \n",
        "i      Kevin    8.0                                                  \n",
        "j      Jonas   19.0\n",
        "```"
      ],
      "metadata": {
        "id": "JQehm3Uyet4D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "\n",
        "print(f\"Select specific columns:\\n{df[['name', 'score']]}\") #The double square brackets [['name', 'score']] are used to specify a list of column names that we want to select from the DataFrame df."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YpYfJZ5Reu47",
        "outputId": "664ad85c-c51f-4372-f4e0-1bb258c90524"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Select specific columns:\n",
            "        name  score\n",
            "a  Anastasia   12.5\n",
            "b       Dima    9.0\n",
            "c  Katherine   16.5\n",
            "d      James    NaN\n",
            "e      Emily    9.0\n",
            "f    Michael   20.0\n",
            "g    Matthew   14.5\n",
            "h      Laura    NaN\n",
            "i      Kevin    8.0\n",
            "j      Jonas   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##5.  Write a Pandas program to select the specified columns and rows from a given data frame.\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "Select 'name' and 'score' columns in rows 1, 3, 5, 6 from the following data frame.\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Select specific columns and rows:\n",
        "   score qualify\n",
        "b    9.0      no\n",
        "d    NaN      no\n",
        "f   20.0     yes\n",
        "g   14.5     yes\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "iSjlG-W9gjOD"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Select rows b,d,f,g and columns 'score' and 'qualify' and print output\n",
        "# .loc, we can specify the row labels and column labels accordingly.\n",
        "print(f\"Select specific columns and rows:\\n{df.loc[['b','d','f','g'], ['score', 'qualify']]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O-M57sktgwaX",
        "outputId": "f65c52be-a7c3-4fb7-d895-8801bae789f3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Select specific columns and rows:\n",
            "   score qualify\n",
            "b    9.0      no\n",
            "d    NaN      no\n",
            "f   20.0     yes\n",
            "g   14.5     yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##6. Write a Pandas program to select the rows where the number of attempts in the examination is greater than 2.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "\n",
        "```\n",
        "Expected Output:\n",
        "Number of attempts in the examination is greater than 2:\n",
        "      name  score  attempts qualify\n",
        "b     Dima    9.0         3      no\n",
        "d    James    NaN         3      no\n",
        "f  Michael   20.0         3     yes\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "Kie641r5jvAV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# select the rows where the number of attempts in the examination is greater than 2.\n",
        "print(f\"Number of attempts in the examination is greater than 2:\\n{df.loc[df['attempts'] > 2]}\")\n",
        "\n",
        "#df['attempts'] > 2 selects rows where the condition is True.\n",
        "#df.loc[boolean_condition] selects rows based on the boolean condition and selects all columns by default (:)."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RvzwkzwXj3Ff",
        "outputId": "24eb4aef-e357-4757-9e86-aab647b9849a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of attempts in the examination is greater than 2:\n",
            "      name  score  attempts qualify\n",
            "b     Dima    9.0         3      no\n",
            "d    James    NaN         3      no\n",
            "f  Michael   20.0         3     yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##7. Write a Pandas program to select the rows where the score is missing, i.e. is NaN.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "\n",
        "```\n",
        "Expected Output:\n",
        "Rows where score is missing:\n",
        "   attempts   name qualify  score\n",
        "d         3  James      no    NaN\n",
        "h         1  Laura      no    NaN\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "JvVRnDZBoWpe"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "# select the rows where the score is missing, i.e. is NaN.\n",
        "print(f\"Rows where score is missing:\\n{df.loc[df['score'].isna()]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YHsAWeaJoe_l",
        "outputId": "7795ea10-c7b6-4b92-e36b-7c5d111455b6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rows where score is missing:\n",
            "   attempts   name qualify  score\n",
            "d         3  James      no    NaN\n",
            "h         1  Laura      no    NaN\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##8. Write a Pandas program to select the rows the score is between 15 and 20 (inclusive).\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Rows where score between 15 and 20 (inclusive):                        \n",
        "   attempts       name qualify  score                                  \n",
        "c         2  Katherine     yes   16.5                                \n",
        "f         3    Michael     yes   20.0                                 \n",
        "j         1      Jonas     yes   19.0\n",
        "```\n"
      ],
      "metadata": {
        "id": "Kg69Xv6FqTtW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "# select the rows the score is between 15 and 20 (inclusive).\n",
        "print(f\"Rows where score between 15 and 20 (inclusive):\\n{df.loc[ (df['score'] >= 15) & (df['score'] <= 20) ]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6o7W1iDyqVUG",
        "outputId": "d49f2fce-c11c-48dc-92d4-26e7d5fd5d90"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Rows where score between 15 and 20 (inclusive):\n",
            "   attempts       name qualify  score\n",
            "c         2  Katherine     yes   16.5\n",
            "f         3    Michael     yes   20.0\n",
            "j         1      Jonas     yes   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##9. Write a Pandas program to select the rows where number of attempts in the examination is less than 2 and score greater than 15.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Number of attempts in the examination is less than 2 and score greater than 15 :\n",
        "    name  score  attempts qualify\n",
        "j  Jonas   19.0         1     yes\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "__UCuQAIswlf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# select the rows where number of attempts in the examination is less than 2 and score greater than 15.\n",
        "print(f\"Number of attempts in the examination is less than 2 and score greater than 15 :\\n{df.loc[ (df['attempts'] < 2) & (df['score'] > 15) ]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cFDJ-dsfs0zb",
        "outputId": "8d3149fd-42cf-4341-eb1a-adb3fd32b88b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of attempts in the examination is less than 2 and score greater than 15 :\n",
            "    name  score  attempts qualify\n",
            "j  Jonas   19.0         1     yes\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##10. Write a Pandas program to change the score in row 'd' to 11.5.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "```\n",
        "\n",
        "```\n",
        "Expected Output:\n",
        "Change the score in row 'd' to 11.5:                                  \n",
        "   attempts       name qualify  score                                \n",
        "a         1  Anastasia     yes   12.5                               \n",
        "b         3       Dima      no    9.0                                \n",
        "c         2  Katherine     yes   16.5\n",
        "...                                \n",
        "i         2      Kevin      no    8.0                                 \n",
        "j         1      Jonas     yes   19.0\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "GSoxfpmBtkmQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "# change the score in row 'd' to 11.5.\n",
        "df.loc['d','score'] = 11.5\n",
        "# Accessing a Specific Cell: df.loc['d', 'score'] allows you to access the cell in row 'd' and column 'score'.\n",
        "# Modifying the Value: The assignment operation df.loc['d', 'score'] = 11.5 changes the value in that cell to 11.5.\n",
        "\n",
        "\n",
        "print(f\"Change the score in row 'd' to 11.5:\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qaiSY2mZto9M",
        "outputId": "5417d48f-28b7-43b5-97fa-adb7263017c7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Change the score in row 'd' to 11.5:\n",
            "   attempts       name qualify  score\n",
            "a         1  Anastasia     yes   12.5\n",
            "b         3       Dima      no    9.0\n",
            "c         2  Katherine     yes   16.5\n",
            "d         3      James      no   11.5\n",
            "e         2      Emily      no    9.0\n",
            "f         3    Michael     yes   20.0\n",
            "g         1    Matthew     yes   14.5\n",
            "h         1      Laura      no    NaN\n",
            "i         2      Kevin      no    8.0\n",
            "j         1      Jonas     yes   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##11. Write a Pandas program to calculate the sum of the examination attempts by the students.\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Sum of the examination attempts by the students:                     \n",
        "19\n",
        "```"
      ],
      "metadata": {
        "id": "ZlJkVpw_wBuh"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "#calculate the sum of the examination attempts by the students\n",
        "print(f\"Sum of the examination attempts by the students:\\n{df['attempts'].sum()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FekbJ8e8wG_Y",
        "outputId": "eafe3134-1225-47bd-c859-9263df215c32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Sum of the examination attempts by the students:\n",
            "19\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##12. Write a Pandas program to calculate the mean of all students' scores. Data is stored in a dataframe.\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Mean score for each different student in data frame:                  \n",
        "13.5625\n",
        "```"
      ],
      "metadata": {
        "id": "5lTjZBi6xE14"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "#calculate the mean of all students' scores. Data is stored in a dataframe.\n",
        "print(f\"Mean score for each different student in data frame: \\n{df['score'].mean()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8AwJSJKVxG9g",
        "outputId": "36ae3319-997c-429c-f212-00234c9befda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean score for each different student in data frame: \n",
            "13.5625\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##13. Write a Pandas program to replace the 'qualify' column contains the values 'yes' and 'no' with True and False.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "\n",
        "```\n",
        "Expected Output:\n",
        "Replace the 'qualify' column contains the values 'yes' and 'no'  with T\n",
        "rue and  False:                                                      \n",
        "   attempts       name  qualify  score                              \n",
        "a         1  Anastasia     True   12.5                          \n",
        "b         3       Dima    False    9.0                              \n",
        "......                           \n",
        "i         2      Kevin    False    8.0                                 \n",
        "j         1      Jonas     True   19.0\n",
        "```"
      ],
      "metadata": {
        "id": "MRlP7Auix5gJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "#replace the 'qualify' column contains the values 'yes' and 'no' with True and False.\n",
        "df['qualify'] = df['qualify'].replace({'yes':True, 'no':False})\n",
        "\n",
        "print(f\"Replace the 'qualify' column contains the values 'yes' and 'no'  with True and  False:\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CvsyP1pYyEJx",
        "outputId": "915fa112-b46c-4740-a5f3-b8e9e74ca5a5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Replace the 'qualify' column contains the values 'yes' and 'no'  with True and  False:\n",
            "   attempts       name  qualify  score\n",
            "a         1  Anastasia     True   12.5\n",
            "b         3       Dima    False    9.0\n",
            "c         2  Katherine     True   16.5\n",
            "d         3      James    False    NaN\n",
            "e         2      Emily    False    9.0\n",
            "f         3    Michael     True   20.0\n",
            "g         1    Matthew     True   14.5\n",
            "h         1      Laura    False    NaN\n",
            "i         2      Kevin    False    8.0\n",
            "j         1      Jonas     True   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##14. Write a Pandas program to change the name 'James' to 'Suresh' in name column of the DataFrame.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Change the name 'James' to \\?Suresh\\?:                                \n",
        "   attempts       name qualify  score                                  \n",
        "a         1  Anastasia     yes   12.5                                  \n",
        "b         3       Dima      no    9.0                                  \n",
        ".......                               \n",
        "i         2      Kevin      no    8.0                                 \n",
        "j         1      Jonas     yes   19.0\n",
        "```"
      ],
      "metadata": {
        "id": "T6B7Q5cq0LQy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "#change the name 'James' to 'Suresh' in name column of the DataFrame.\n",
        "df['name'] = df['name'].replace('James','Suresh')\n",
        "\n",
        "\n",
        "print(f\"Change the name 'James' to \\?Suresh\\?:\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TdUPFd9X0YX0",
        "outputId": "2d5071d6-de3c-4f18-d5b4-b9cd225205d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Change the name 'James' to \\?Suresh\\?:\n",
            "   attempts       name qualify  score\n",
            "a         1  Anastasia     yes   12.5\n",
            "b         3       Dima      no    9.0\n",
            "c         2  Katherine     yes   16.5\n",
            "d         3     Suresh      no    NaN\n",
            "e         2      Emily      no    9.0\n",
            "f         3    Michael     yes   20.0\n",
            "g         1    Matthew     yes   14.5\n",
            "h         1      Laura      no    NaN\n",
            "i         2      Kevin      no    8.0\n",
            "j         1      Jonas     yes   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##15. Write a Pandas program to delete the 'attempts' column from the DataFrame.\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "Delete the 'attempts' column from the data frame:                    \n",
        "        name qualify  score                                          \n",
        "a  Anastasia     yes   12.5                                           \n",
        "b       Dima      no    9.0                                          \n",
        ".....                                       \n",
        "i      Kevin      no    8.0                                          \n",
        "j      Jonas     yes   19.0\n",
        "```"
      ],
      "metadata": {
        "id": "UtDElDlq3Lpb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "#delete the 'attempts' column from the DataFrame.\n",
        "df = df.drop(columns='attempts')\n",
        "print(f\"Delete the 'attempts' column from the data frame:\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3lP9mOnK3NLS",
        "outputId": "b5188ce4-2bd5-4c72-e848-1dbb77548b36"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Delete the 'attempts' column from the data frame:\n",
            "        name qualify  score\n",
            "a  Anastasia     yes   12.5\n",
            "b       Dima      no    9.0\n",
            "c  Katherine     yes   16.5\n",
            "d      James      no    NaN\n",
            "e      Emily      no    9.0\n",
            "f    Michael     yes   20.0\n",
            "g    Matthew     yes   14.5\n",
            "h      Laura      no    NaN\n",
            "i      Kevin      no    8.0\n",
            "j      Jonas     yes   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##16.  Write a Pandas program to insert a new column in existing DataFrame.\n",
        "\n",
        "```\n",
        "Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "```\n",
        "```\n",
        "Expected Output:\n",
        "New DataFrame after inserting the 'color' column                       \n",
        "   attempts       name qualify  score   color                       \n",
        "a         1  Anastasia     yes   12.5     Red                         \n",
        "b         3       Dima      no    9.0    Blue                        \n",
        ".......                     \n",
        "i         2      Kevin      no    8.0   Green                        \n",
        "j         1      Jonas     yes   19.0     Red\n",
        "```"
      ],
      "metadata": {
        "id": "MjOeYOzI5ePI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample Python dictionary data and list labels:\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "labels = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data, index = labels)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "# 'index = labels' This specifies the list labels as the index labels for the DataFrame.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "# Define a new column 'color'\n",
        "df['color'] = ['Red', 'Blue', 'Green', 'Yellow', 'Orange', 'Purple', 'Pink', 'Black', 'Green', 'Red']  # Assigning a list of colors as values to the new column 'color'\n",
        "\n",
        "print(f\"New DataFrame after inserting the 'color' column\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Am9LMLwK5fI8",
        "outputId": "7850d82d-eec6-431d-ab14-5b846e7d843b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "New DataFrame after inserting the 'color' column\n",
            "   attempts       name qualify  score   color\n",
            "a         1  Anastasia     yes   12.5     Red\n",
            "b         3       Dima      no    9.0    Blue\n",
            "c         2  Katherine     yes   16.5   Green\n",
            "d         3      James      no    NaN  Yellow\n",
            "e         2      Emily      no    9.0  Orange\n",
            "f         3    Michael     yes   20.0  Purple\n",
            "g         1    Matthew     yes   14.5    Pink\n",
            "h         1      Laura      no    NaN   Black\n",
            "i         2      Kevin      no    8.0   Green\n",
            "j         1      Jonas     yes   19.0     Red\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##17.  Write a Pandas program to rename columns of a given DataFrame\n",
        "\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     2     5     8\n",
        "2     3     6     9\n",
        "New DataFrame after renaming columns:\n",
        "   Column1  Column2  Column3\n",
        "0        1        4        7\n",
        "1        2        5        8\n",
        "2        3        6        9\n",
        "```"
      ],
      "metadata": {
        "id": "2gMPgPw57aHr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "#sample data dict\n",
        "sample_data = {'col1':[1,2,3], 'col2':[4,5,6], 'col3':[7,8,9]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(sample_data)\n",
        "\n",
        "#print original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "#rename columns of a given DataFrame\n",
        "df = df.rename(columns = {'col1':'Column1', 'col2':'Column2', 'col3':'Column3'})\n",
        "\n",
        "#print new dataFrame after renaming columns\n",
        "print(f\"New DataFrame after renaming columns:\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YDUXhPdQ7r29",
        "outputId": "c0a5843f-18eb-4479-871a-12b4de3a926c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     8\n",
            "2     3     6     9\n",
            "\n",
            "New DataFrame after renaming columns:\n",
            "   Column1  Column2  Column3\n",
            "0        1        4        7\n",
            "1        2        5        8\n",
            "2        3        6        9\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##18. Write a Pandas program to select rows from a given DataFrame based on values in some columns.\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     4     5     8\n",
        "2     3     6     9\n",
        "3     4     7     0\n",
        "4     5     8     1\n",
        "Rows for colum1 value == 4\n",
        "   col1  col2  col3\n",
        "1     4     5     8\n",
        "3     4     7     0\n",
        "```"
      ],
      "metadata": {
        "id": "n4uLkBbC_gAF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "#sample data dict\n",
        "sample_data = {'col1':[1,4,3,4,5], 'col2':[4,5,6,7,8], 'col3':[7,8,9,0,1]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(sample_data)\n",
        "\n",
        "#print original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "#select rows from a given DataFrame based on values in some columns.\n",
        "#Rows for colum1 value == 4\n",
        "print(f\"Rows for colum1 value == 4\\n{df.loc[df['col1'] == 4]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HwEcqOGk_pj1",
        "outputId": "a803d785-7f0a-4313-f43f-10796ddafd53"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     4     5     8\n",
            "2     3     6     9\n",
            "3     4     7     0\n",
            "4     5     8     1\n",
            "\n",
            "Rows for colum1 value == 4\n",
            "   col1  col2  col3\n",
            "1     4     5     8\n",
            "3     4     7     0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##19. Write a Pandas program to add one row in an existing DataFrame.\n",
        "\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     4     5     8\n",
        "2     3     6     9\n",
        "3     4     7     0\n",
        "4     5     8     1\n",
        "After add one row:\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     4     5     8\n",
        "2     3     6     9\n",
        "3     4     7     0\n",
        "4     5     8     1\n",
        "5    10    11    12\n",
        "```"
      ],
      "metadata": {
        "id": "Fn1T5EXBB8sN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': [1, 4, 3, 4, 5], 'col2': [4, 5, 6, 7, 8], 'col3': [7, 8, 9, 0, 1]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Print original DataFrame\n",
        "print(f\"Original DataFrame:\\n{df}\\n\")\n",
        "\n",
        "# Add new row values 10, 11, 12 at the index position specified by len(df).\n",
        "# the len(df) returns the current number of rows in the DataFrame which is 5\n",
        "df.loc[len(df)] = [10, 11, 12] # add new row at index 5\n",
        "\n",
        "# DataFrame after adding new row\n",
        "print(f\"After add one row:\\n{df}\")\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bpUVtxEgB9nm",
        "outputId": "dc00b012-a921-44a9-cc89-f52b6ca1df54"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame:\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     4     5     8\n",
            "2     3     6     9\n",
            "3     4     7     0\n",
            "4     5     8     1\n",
            "\n",
            "After add one row:\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     4     5     8\n",
            "2     3     6     9\n",
            "3     4     7     0\n",
            "4     5     8     1\n",
            "5    10    11    12\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##20. Write a Pandas program to replace all the NaN values with Zero's in a column of a dataframe.\n",
        "\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "\n",
        "   attempts       name qualify  score\n",
        "0         1  Anastasia     yes   12.5\n",
        "1         3       Dima      no    9.0\n",
        "2         2  Katherine     yes   16.5\n",
        ".....\n",
        "8         2      Kevin      no    8.0\n",
        "9         1      Jonas     yes   19.0\n",
        "\n",
        "```\n",
        "```\n",
        "\n",
        "New DataFrame replacing all NaN with 0:\n",
        "   attempts       name qualify  score\n",
        "0         1  Anastasia     yes   12.5\n",
        "1         3       Dima      no    9.0\n",
        "2         2  Katherine     yes   16.5\n",
        ".....\n",
        "8         2      Kevin      no    8.0\n",
        "9         1      Jonas     yes   19.0\n",
        "```"
      ],
      "metadata": {
        "id": "150aqGtrdk9p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample dictionary data\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "# print Original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# replace NaN values with 0 in the 'score' column\n",
        "df['score'] = df['score'].fillna(0)\n",
        "\n",
        "# print New DataFrame replacing all NaN with 0:\n",
        "print(f\"New DataFrame replacing all NaN with 0:\\n{df}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jJQT1S-EdmAA",
        "outputId": "5b573408-8a1f-4190-ffd3-545961ca8bf7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   attempts       name qualify  score\n",
            "0         1  Anastasia     yes   12.5\n",
            "1         3       Dima      no    9.0\n",
            "2         2  Katherine     yes   16.5\n",
            "3         3      James      no    NaN\n",
            "4         2      Emily      no    9.0\n",
            "5         3    Michael     yes   20.0\n",
            "6         1    Matthew     yes   14.5\n",
            "7         1      Laura      no    NaN\n",
            "8         2      Kevin      no    8.0\n",
            "9         1      Jonas     yes   19.0\n",
            "\n",
            "New DataFrame replacing all NaN with 0:\n",
            "   attempts       name qualify  score\n",
            "0         1  Anastasia     yes   12.5\n",
            "1         3       Dima      no    9.0\n",
            "2         2  Katherine     yes   16.5\n",
            "3         3      James      no    0.0\n",
            "4         2      Emily      no    9.0\n",
            "5         3    Michael     yes   20.0\n",
            "6         1    Matthew     yes   14.5\n",
            "7         1      Laura      no    0.0\n",
            "8         2      Kevin      no    8.0\n",
            "9         1      Jonas     yes   19.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##21. Write a Pandas program to count the NaN values in one or more columns in DataFrame.\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "   attempts       name qualify  score\n",
        "0         1  Anastasia     yes   12.5\n",
        "1         3       Dima      no    9.0\n",
        "2         2  Katherine     yes   16.5\n",
        "3         3      James      no    NaN\n",
        "4         2      Emily      no    9.0\n",
        "5         3    Michael     yes   20.0\n",
        "6         1    Matthew     yes   14.5\n",
        "7         1      Laura      no    NaN\n",
        "8         2      Kevin      no    8.0\n",
        "9         1      Jonas     yes   19.0\n",
        "\n",
        "Number of NaN values in one or more columns:\n",
        "2\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "ckGcd4A8iJIP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample dictionary data\n",
        "exam_data = {'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19],\n",
        "'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes']}\n",
        "\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "\n",
        "# Reorder columns as per the expected output\n",
        "df = df.reindex(columns=['attempts', 'name', 'qualify', 'score'])\n",
        "\n",
        "# print Original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# print Number of NaN values in one or more columns:\n",
        "print(f\"Number of NaN values in one or more columns:\\n{df.isna().sum().sum()}\")\n",
        "\n",
        "# When we call .sum() on the DataFrame resulting from df.isna(), it sums up the boolean values (True is treated as 1 and False as 0) along the columns (axis=0 by default).\n",
        "# This gives you a Series where each value is the count of NaN values in each column.\n",
        "# attempts    0\n",
        "# name        0\n",
        "# qualify     0\n",
        "# score       2\n",
        "# dtype: int64\n",
        "# (Second .sum()):This .sum() is called on the Series resulting from the first .sum().\n",
        "# It sums up all the values in the Series, which gives the total number of NaN values in the entire DataFrame."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xNLlhcyiiLyn",
        "outputId": "274f4f23-efb9-4bde-a1ab-c7a54831c195"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   attempts       name qualify  score\n",
            "0         1  Anastasia     yes   12.5\n",
            "1         3       Dima      no    9.0\n",
            "2         2  Katherine     yes   16.5\n",
            "3         3      James      no    NaN\n",
            "4         2      Emily      no    9.0\n",
            "5         3    Michael     yes   20.0\n",
            "6         1    Matthew     yes   14.5\n",
            "7         1      Laura      no    NaN\n",
            "8         2      Kevin      no    8.0\n",
            "9         1      Jonas     yes   19.0\n",
            "\n",
            "Number of NaN values in one or more columns:\n",
            "2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##22. Write a Pandas program to drop a list of rows from a specified DataFrame.\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     4     5     8\n",
        "2     3     6     9\n",
        "3     4     7     0\n",
        "4     5     8     1\n",
        "\n",
        "\n",
        "New DataFrame after removing 2nd & 4th rows:\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     4     5     8\n",
        "3     4     7     0\n",
        "```"
      ],
      "metadata": {
        "id": "Xi7UO28-le8G"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': [1, 4, 3, 4, 5], 'col2': [4, 5, 6, 7, 8], 'col3': [7, 8, 9, 0, 1]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Print original DataFrame\n",
        "print(f\"Original DataFrame:\\n{df}\\n\")\n",
        "\n",
        "# drop a list of rows from a specified DataFrame. drop index 2 and 4\n",
        "new_df = df.drop([2,4])\n",
        "\n",
        "# print New DataFrame after removing 2nd & 4th rows:\n",
        "print(f\"print New DataFrame after removing 2nd & 4th rows:\\n{new_df}\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AJRhioXjlkiB",
        "outputId": "ecb1a4fc-bc6b-4b27-923c-2b317d95cfef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame:\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     4     5     8\n",
            "2     3     6     9\n",
            "3     4     7     0\n",
            "4     5     8     1\n",
            "\n",
            "print New DataFrame after removing 2nd & 4th rows:\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     4     5     8\n",
            "3     4     7     0\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##23. . Write a Pandas program to convert DataFrame column type from string to datetime.\n",
        "\n",
        "```\n",
        "\n",
        "Sample data:\n",
        "String Date:\n",
        "0    3/11/2000\n",
        "1    3/12/2000\n",
        "2    3/13/2000\n",
        "dtype: object\n",
        "\n",
        "\n",
        "Original DataFrame (string to datetime):\n",
        "           0\n",
        "0 2000-03-11\n",
        "1 2000-03-12\n",
        "2 2000-03-13\n",
        "```"
      ],
      "metadata": {
        "id": "yM-WMU2ypBjE"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data as a pandas Series\n",
        "pd_series = pd.Series(['3/11/2000', '3/12/2000', '3/13/2000'])\n",
        "\n",
        "# Print original Series\n",
        "print(f\"String Date:\\n{pd_series}\\n\")\n",
        "\n",
        "# Convert the Series to a DataFrame\n",
        "df = pd.DataFrame(pd_series)\n",
        "\n",
        "# Convert the column to datetime\n",
        "df[0] = pd.to_datetime(df[0])   # df[0] is passed as an argument to pd.to_datetime(), which means the entire column 0 of the DataFrame is being converted from strings to datetime objects.\n",
        "\n",
        "\n",
        "# Print DataFrame after conversion\n",
        "print(f\"Original DataFrame (string to datetime):\\n{df}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DpJ85G3_pCXs",
        "outputId": "8b3a17e4-3031-489d-dbb1-4d0223275ce3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "String Date:\n",
            "0    3/11/2000\n",
            "1    3/12/2000\n",
            "2    3/13/2000\n",
            "dtype: object\n",
            "\n",
            "Original DataFrame (string to datetime):\n",
            "           0\n",
            "0 2000-03-11\n",
            "1 2000-03-12\n",
            "2 2000-03-13\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##24. Write a Pandas program to find the row for where the value of a given column is maximum.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original DataFrame\n",
        "   col1  col2  col3\n",
        "0     1     4     7\n",
        "1     2     5     8\n",
        "2     3     6    12\n",
        "3     4     9     1\n",
        "4     7     5    11\n",
        "Row where col1 has maximum value:\n",
        "4\n",
        "Row where col2 has maximum value:\n",
        "3\n",
        "Row where col3 has maximum value:\n",
        "2\n",
        "```"
      ],
      "metadata": {
        "id": "UenJkI9wvR0M"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data dict\n",
        "data = {'col1': [1, 2, 3, 4, 7], 'col2': [4, 5, 6, 9, 5], 'col3': [7, 8, 12, 1, 11]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Print original DataFrame\n",
        "print(f\"Original DataFrame:\\n{df}\\n\")\n",
        "\n",
        "# Find the row for where each column has its maximum value and print its index\n",
        "print(f\"Row where col1 has maximum value:\\n{df['col1'].idxmax()}\\n\") # df['col1'].idxmax() finds the index of the maximum value in 'col1'.\n",
        "print(f\"Row where col2 has maximum value:\\n{df['col2'].idxmax()}\\n\")\n",
        "print(f\"Row where col3 has maximum value:\\n{df['col3'].idxmax()}\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Mby47Y_cvV2E",
        "outputId": "d50a5c96-b9d4-47c7-9663-a6b097a2b823"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame:\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     8\n",
            "2     3     6    12\n",
            "3     4     9     1\n",
            "4     7     5    11\n",
            "\n",
            "Row where col1 has maximum value:\n",
            "4\n",
            "\n",
            "Row where col2 has maximum value:\n",
            "3\n",
            "\n",
            "Row where col3 has maximum value:\n",
            "2\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##25. Write a Pandas program to get the datatypes of columns of a DataFrame.\n",
        "\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame:\n",
        "   attempts       name qualify  score\n",
        "0         1  Anastasia     yes   12.5\n",
        "1         3       Dima      no    9.0\n",
        ".......\n",
        "8         2      Kevin      no    8.0\n",
        "9         1      Jonas     yes   19.0\n",
        "Data types of the columns of the said DataFrame:\n",
        "attempts      int64\n",
        "name         object\n",
        "qualify      object\n",
        "score       float64\n",
        "dtype: object\n",
        "```"
      ],
      "metadata": {
        "id": "xUsp1_Miyxwa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "#Sample dictionary data\n",
        "exam_data = {'attempts': [1, 3, 2, 3, 2, 3, 1, 1, 2, 1],\n",
        "'name': ['Anastasia', 'Dima', 'Katherine', 'James', 'Emily', 'Michael', 'Matthew', 'Laura', 'Kevin', 'Jonas'],\n",
        "'qualify': ['yes', 'no', 'yes', 'no', 'no', 'yes', 'yes', 'no', 'no', 'yes'],\n",
        "'score': [12.5, 9, 16.5, np.nan, 9, 20, 14.5, np.nan, 8, 19]\n",
        "}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data = exam_data)\n",
        "# 'data = exam_data' This specifies the dictionary exam_data as the data to populate the DataFrame columns.\n",
        "\n",
        "# print Original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# get the datatypes of columns of a DataFrame\n",
        "print(f\"Data types of the columns of the said DataFrame:\\n{df.dtypes}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CJwuzh6ry2dM",
        "outputId": "e511d5a6-2a28-48d0-932d-ad8bdb890634"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   attempts       name qualify  score\n",
            "0         1  Anastasia     yes   12.5\n",
            "1         3       Dima      no    9.0\n",
            "2         2  Katherine     yes   16.5\n",
            "3         3      James      no    NaN\n",
            "4         2      Emily      no    9.0\n",
            "5         3    Michael     yes   20.0\n",
            "6         1    Matthew     yes   14.5\n",
            "7         1      Laura      no    NaN\n",
            "8         2      Kevin      no    8.0\n",
            "9         1      Jonas     yes   19.0\n",
            "\n",
            "Data types of the columns of the said DataFrame:\n",
            "attempts      int64\n",
            "name         object\n",
            "qualify      object\n",
            "score       float64\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##26. Write a Pandas program to group by the first column and get second column as lists in rows.\n",
        "\n",
        "```\n",
        "Sample data:\n",
        "Original DataFrame\n",
        "col1 col2\n",
        "0 C1 1\n",
        "1 C1 2\n",
        "2 C2 3\n",
        "3 C2 3\n",
        "4 C2 4\n",
        "5 C3 6\n",
        "6 C2 5\n",
        "\n",
        "\n",
        "Group on the col1:\n",
        "col1\n",
        "C1 [1, 2]\n",
        "C2 [3, 3, 4, 5]\n",
        "C3 [6]\n",
        "Name: col2, dtype: object\n",
        "```"
      ],
      "metadata": {
        "id": "JyiPUiYi7e8J"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': ['C1', 'C1', 'C2', 'C2', 'C2', 'C3', 'C2'], 'col2': [1, 2, 3, 3, 4, 6, 5]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Print original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# Group by 'col1' and get 'col2' as lists in rows\n",
        "gpd_df = df.groupby('col1')['col2'].apply(list)  # df.groupby('category')['values'].apply(list)\n",
        "# df.groupby('col1') creates a groupby object where each unique value in 'col1' forms a group.\n",
        "# ['col2'] then selects the 'col2' column from each group.\n",
        "#.apply(list) is applied to each group of 'values'.It converts each group (which is a Series of numbers) into a list.\n",
        "\n",
        "# Print grouped DataFrame\n",
        "print(f\"Group on the col1:\\n{gpd_df}\")\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jU-wwg847f-I",
        "outputId": "8e5a2e81-1e91-42f0-eb77-126811072465"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "  col1  col2\n",
            "0   C1     1\n",
            "1   C1     2\n",
            "2   C2     3\n",
            "3   C2     3\n",
            "4   C2     4\n",
            "5   C3     6\n",
            "6   C2     5\n",
            "\n",
            "Group on the col1:\n",
            "col1\n",
            "C1          [1, 2]\n",
            "C2    [3, 3, 4, 5]\n",
            "C3             [6]\n",
            "Name: col2, dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##27  Write a Pandas program to count number of columns of a DataFrame.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original DataFrame\n",
        "  col1 col2 col3\n",
        "0  1    4   7\n",
        "1  2    5   8\n",
        "2  3    6   12\n",
        "3  4    9   1\n",
        "4  7    5   11\n",
        "\n",
        "Number of columns:\n",
        "3\n",
        "```"
      ],
      "metadata": {
        "id": "SFRq3_tCCFAH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': [1, 2, 3, 4, 7], 'col2': [4, 5, 6, 9, 5], 'col3': [7, 8, 12, 1, 11]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# print Original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "#df.shape returns a tuple (number of row , number of column) so df.shape[1] returns the second element in the tuple which is  number of column\n",
        "print(f\"Number of columns:\\n{df.shape[1]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YYs1_davCJgm",
        "outputId": "6f70de59-2aae-4f05-ea6e-1edf9032052f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     8\n",
            "2     3     6    12\n",
            "3     4     9     1\n",
            "4     7     5    11\n",
            "\n",
            "Number of columns:\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##28.  Write a Pandas program to get first n records of a DataFrame.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original DataFrame\n",
        "col1 col2 col3\n",
        "0 1 4 7\n",
        "1 2 5 5\n",
        "2 3 6 8\n",
        "3 4 9 12\n",
        "4 7 5 1\n",
        "5 11 0 11\n",
        "\n",
        "First 3 rows of the said DataFrame':\n",
        "col1 col2 col3\n",
        "0 1 4 7\n",
        "1 2 5 5\n",
        "2 3 6 8\n",
        "```\n"
      ],
      "metadata": {
        "id": "BokKlY8mFJF3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': [1, 2, 3, 4, 7, 11], 'col2': [4, 5, 6, 9, 5, 0], 'col3': [7, 5, 8, 12, 1, 11]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# print Original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# get first 3 records of a DataFrame.\n",
        "print(f\"First 3 rows of the said DataFrame':\\n{df.head(3)}\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QjJfclJ2FMV1",
        "outputId": "cbe3a0f3-9565-4645-91ad-2fc543024c14"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     5\n",
            "2     3     6     8\n",
            "3     4     9    12\n",
            "4     7     5     1\n",
            "5    11     0    11\n",
            "\n",
            "First 3 rows of the said DataFrame':\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     5\n",
            "2     3     6     8\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##29. Write a Pandas program to get last n records of a DataFrame.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original DataFrame\n",
        "col1 col2 col3\n",
        "0 1 4 7\n",
        "1 2 5 5\n",
        "2 3 6 8\n",
        "3 4 9 12\n",
        "4 7 5 1\n",
        "5 11 0 11\n",
        "\n",
        "Last 3 rows of the said DataFrame':\n",
        "col1 col2 col3\n",
        "3 4 9 12\n",
        "4 7 5 1\n",
        "5 11 0 11\n",
        "```"
      ],
      "metadata": {
        "id": "uml27ZTLG133"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': [1, 2, 3, 4, 7, 11], 'col2': [4, 5, 6, 9, 5, 0], 'col3': [7, 5, 8, 12, 1, 11]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# print Original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# get last 3 records of a DataFrame.\n",
        "print(f\"Last 3 rows of the said DataFrame':\\n{df.tail(3)}\\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5qHPHghNG5nX",
        "outputId": "e4d7dcba-514c-4409-dca3-1d22128ab606"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     5\n",
            "2     3     6     8\n",
            "3     4     9    12\n",
            "4     7     5     1\n",
            "5    11     0    11\n",
            "\n",
            "Last 3 rows of the said DataFrame':\n",
            "   col1  col2  col3\n",
            "3     4     9    12\n",
            "4     7     5     1\n",
            "5    11     0    11\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##30.  Write a Pandas program to get topmost n records within each group of a DataFrame.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original DataFrame\n",
        "col1 col2 col3\n",
        "0 1 4 7\n",
        "1 2 5 5\n",
        "2 3 6 8\n",
        "3 4 9 12\n",
        "4 7 5 1\n",
        "5 11 0 11\n",
        "\n",
        "```\n",
        "```\n",
        "topmost n records within each group of a DataFrame:\n",
        "col1 col2 col3\n",
        "5 11 0 11\n",
        "4 7 5 1\n",
        "3 4 9 12\n",
        "col1 col2 col3\n",
        "3 4 9 12\n",
        "2 3 6 8\n",
        "1 2 5 5\n",
        "4 7 5 1\n",
        "col1 col2 col3\n",
        "3 4 9 12\n",
        "5 11 0 11\n",
        "2 3 6 8\n",
        "```"
      ],
      "metadata": {
        "id": "L4XK0MvjHvle"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'col1': [1, 2, 3, 4, 7, 11], 'col2': [4, 5, 6, 9, 5, 0], 'col3': [7, 5, 8, 12, 1, 11]}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# Function to get top n records within each group\n",
        "def get_top_n_records(df, sort_col, n=3):\n",
        "    return df.sort_values(by=sort_col, ascending=False).head(n)\n",
        "\n",
        "print(\"topmost n records within each group of a DataFrame:\")\n",
        "\n",
        "print(f\"{get_top_n_records(df, 'col1', n=3)}\\n\")\n",
        "\n",
        "print(f\"{get_top_n_records(df, 'col2', n=4)}\\n\")\n",
        "\n",
        "print(f\"{get_top_n_records(df, 'col3', n=3)}\\n\")\n"
      ],
      "metadata": {
        "id": "YipVwKR9H0D_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d1d14dc5-1269-4ece-d542-7ecc1cfbca1c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "   col1  col2  col3\n",
            "0     1     4     7\n",
            "1     2     5     5\n",
            "2     3     6     8\n",
            "3     4     9    12\n",
            "4     7     5     1\n",
            "5    11     0    11\n",
            "\n",
            "topmost n records within each group of a DataFrame:\n",
            "   col1  col2  col3\n",
            "5    11     0    11\n",
            "4     7     5     1\n",
            "3     4     9    12\n",
            "\n",
            "   col1  col2  col3\n",
            "3     4     9    12\n",
            "2     3     6     8\n",
            "1     2     5     5\n",
            "4     7     5     1\n",
            "\n",
            "   col1  col2  col3\n",
            "3     4     9    12\n",
            "5    11     0    11\n",
            "2     3     6     8\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##31. Write a Pandas program to add a prefix or suffix to all columns of a given DataFrame.\n",
        "\n",
        "```\n",
        "Sample Output:\n",
        "Original DataFrame\n",
        "W X Y Z\n",
        "0 68 78 84 86\n",
        "1 75 85 94 97\n",
        "2 86 96 89 96\n",
        "3 80 80 83 72\n",
        "4 66 86 86 83\n",
        "\n",
        "Add prefix:\n",
        "A_W A_X A_Y A_Z\n",
        "0 68 78 84 86\n",
        "1 75 85 94 97\n",
        "2 86 96 89 96\n",
        "3 80 80 83 72\n",
        "4 66 86 86 83\n",
        "\n",
        "Add suffix:\n",
        "W_1 X_1 Y_1 Z_1\n",
        "0 68 78 84 86\n",
        "1 75 85 94 97\n",
        "2 86 96 89 96\n",
        "3 80 80 83 72\n",
        "4 66 86 86 83\n",
        "\n",
        "```"
      ],
      "metadata": {
        "id": "-DkWJCoLKEWl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample data\n",
        "data = {'W': [68, 75, 86, 80, 66], 'X': [78, 85, 96, 80, 86], 'Y': [84, 94, 89, 83, 86], 'Z': [86, 97, 96, 72, 83]}\n",
        "\n",
        "# Create the DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "\n",
        "# Print original DataFrame\n",
        "print(f\"Original DataFrame\\n{df}\\n\")\n",
        "\n",
        "# Add prefix using add_prefix method\n",
        "prefixed_df = df.add_prefix('A_')\n",
        "\n",
        "# print DataFrame with prefix added\n",
        "print(f\"Add prefix:\\n{prefixed_df}\")\n",
        "\n",
        "# Add suffix using add_suffix method\n",
        "suffixed_df = df.add_suffix('_1')\n",
        "\n",
        "# Print DataFrame with suffix added\n",
        "print(f\"Add suffix:\\n{suffixed_df}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mvHGNsnyKKil",
        "outputId": "c9ce5cc9-d5b1-4283-ab96-7504da65a08a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Original DataFrame\n",
            "    W   X   Y   Z\n",
            "0  68  78  84  86\n",
            "1  75  85  94  97\n",
            "2  86  96  89  96\n",
            "3  80  80  83  72\n",
            "4  66  86  86  83\n",
            "\n",
            "Add prefix:\n",
            "   A_W  A_X  A_Y  A_Z\n",
            "0   68   78   84   86\n",
            "1   75   85   94   97\n",
            "2   86   96   89   96\n",
            "3   80   80   83   72\n",
            "4   66   86   86   83\n",
            "Add suffix:\n",
            "   W_1  X_1  Y_1  Z_1\n",
            "0   68   78   84   86\n",
            "1   75   85   94   97\n",
            "2   86   96   89   96\n",
            "3   80   80   83   72\n",
            "4   66   86   86   83\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##32. Write a Pandas program to convert continuous values of a column in a given DataFrame to categorical.\n",
        "```\n",
        "Input:\n",
        " 'name': ['Alberto Franco','Gino Mcneill','Ryan Parkes', 'Eesha Hinton', 'Syed Wharton', 'Kierra Gentry'],\n",
        "      'age': [18, 22, 85, 50, 80, 5]\n",
        "\n",
        "\n",
        "Output:\n",
        "Age group:\n",
        "0 kids\n",
        "1 adult\n",
        "2 elderly\n",
        "3 adult\n",
        "4 elderly\n",
        "5 kids\n",
        "Name: age_groups, dtype: category\n",
        "Categories (3, object): [kids < adult < elderly]\n",
        "```"
      ],
      "metadata": {
        "id": "YVPoIwDPMbIM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Sample DataFrame\n",
        "data = {\n",
        "    'Name': ['Alberto Franco','Gino Mcneill','Ryan Parkes', 'Eesha Hinton', 'Syed Wharton', 'Kierra Gentry'],\n",
        "    'Age': [18, 22, 85, 50, 80, 5]\n",
        "}\n",
        "\n",
        "# Create DataFrame\n",
        "df = pd.DataFrame(data)\n",
        "#print(df)\n",
        "\n",
        "# Define bins and labels for age groups\n",
        "bins = [0, 19, 60, 120]  # Bins for kids, adult, elderly\n",
        "\n",
        "# Ages from 0 up to (but not including) 19 are categorized as 'kids'.\n",
        "# Ages from 19 up to (but not including) 60 are categorized as 'adult'.\n",
        "# Ages from 60 up to (but not including) 120 are categorized as 'elderly'.\n",
        "# Any age outside these ranges would not fall into any of these categories based on the given bins.\n",
        "\n",
        "labels = ['kids', 'adult', 'elderly'] # labels for the age group\n",
        "\n",
        "# Convert 'Age' column to categorical 'age_groups'\n",
        "df['age_groups'] = pd.cut(df['Age'], bins=bins, labels=labels, right=False)\n",
        "\n",
        "\n",
        "#df[['Name', 'Age', 'age_groups']]\n",
        "\n",
        "print(f\"Age group:\\n{df['age_groups']}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZsI-05LNMerb",
        "outputId": "8f930a59-4343-4471-bea4-9aebc3f11f5c"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Age group:\n",
            "0       kids\n",
            "1      adult\n",
            "2    elderly\n",
            "3      adult\n",
            "4    elderly\n",
            "5       kids\n",
            "Name: age_groups, dtype: category\n",
            "Categories (3, object): ['kids' < 'adult' < 'elderly']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##33. Write a Pandas program to append rows to an existing DataFrame and display the combined data.\n",
        "\n",
        "```\n",
        "Test Data:\n",
        "student_data1\n",
        "  student_id              name  marks\n",
        "0         S1  Danniella Fenton    200\n",
        "1         S2      Ryder Storey    210\n",
        "2         S3      Bryce Jensen    190\n",
        "3         S4         Ed Bernal    222\n",
        "4         S5       Kwame Morin    199\n",
        "\n",
        "\n",
        "New Row(s)\n",
        "student_id                  S6\n",
        "name          Scarlette Fisher\n",
        "marks                      205\n",
        "dtype: object\n",
        "```"
      ],
      "metadata": {
        "id": "MysCfPrKl1qk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# DataFrame\n",
        "student_data1 = pd.DataFrame({\n",
        "    'student_id': ['S1', 'S2', 'S3', 'S4', 'S5'],\n",
        "    'name': ['Danniella Fenton', 'Ryder Storey', 'Bryce Jensen', 'Ed Bernal', 'Kwame Morin'],\n",
        "    'marks': [200, 210, 190, 222, 199]\n",
        "})\n",
        "\n",
        "print(f\"Test Data:\\nstudent_data1\\n{student_data1}\\n\\n\")\n",
        "\n",
        "# New Row as a pd Series\n",
        "new_row = pd.Series(['S6', 'Scarlette Fisher', 205], index=['student_id', 'name', 'marks'])\n",
        "\n",
        "print(f\"New Row(s)\\n{new_row}\\n\\n\")\n",
        "\n",
        "\n",
        "# Append the new row to the existing DataFrame using concat\n",
        "student_data1 = pd.concat([student_data1, new_row.to_frame().T], ignore_index=True)\n",
        "\n",
        "#new_row is a pandas Series containing data for a new row that we want to append to the student_data1 DataFrame.\n",
        "#.to_frame() converts the Series new_row into a DataFrame. The resulting DataFrame has a single row with column names derived from the index of the Series.\n",
        "#.T transposes (flips) the DataFrame, making the row into a column. This step ensures that the new row is added as a single row DataFrame with columns aligned properly.\n",
        "\n",
        "#print(f\"new_row.to_frame()\\n{new_row.to_frame()}\")\n",
        "#print(f\"new_row.to_frame().T\\n{new_row.to_frame().T}\")\n",
        "\n",
        "# print the combined data\n",
        "print(f\"Combined DataFrame:\\n{student_data1}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "REP54Cwfl47s",
        "outputId": "ca8b44b3-0967-4f26-e196-2403560f7714"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Test Data:\n",
            "student_data1\n",
            "  student_id              name  marks\n",
            "0         S1  Danniella Fenton    200\n",
            "1         S2      Ryder Storey    210\n",
            "2         S3      Bryce Jensen    190\n",
            "3         S4         Ed Bernal    222\n",
            "4         S5       Kwame Morin    199\n",
            "\n",
            "\n",
            "New Row(s)\n",
            "student_id                  S6\n",
            "name          Scarlette Fisher\n",
            "marks                      205\n",
            "dtype: object\n",
            "\n",
            "\n",
            "Combined DataFrame:\n",
            "  student_id              name marks\n",
            "0         S1  Danniella Fenton   200\n",
            "1         S2      Ryder Storey   210\n",
            "2         S3      Bryce Jensen   190\n",
            "3         S4         Ed Bernal   222\n",
            "4         S5       Kwame Morin   199\n",
            "5         S6  Scarlette Fisher   205\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##34  Write a Pandas program to join the two given dataframes along rows and merge with another dataframe along the common column id.\n",
        "\n",
        "```\n",
        "Test Data:\n",
        "student_data1:\n",
        "  student_id              name  marks\n",
        "0         S1  Danniella Fenton    200\n",
        "1         S2      Ryder Storey    210\n",
        "2         S3      Bryce Jensen    190\n",
        "3         S4         Ed Bernal    222\n",
        "4         S5       Kwame Morin    199\n",
        "student_data2:\n",
        "  student_id              name  marks\n",
        "0         S4  Scarlette Fisher    201\n",
        "1         S5  Carla Williamson    200\n",
        "2         S6       Dante Morse    198\n",
        "3         S7    Kaiser William    219\n",
        "4         S8   Madeeha Preston    201\n",
        "```\n",
        "```\n",
        "\n",
        "exam_data:\n",
        "   student_id  exam_id\n",
        "0          S1       23\n",
        "1          S2       45\n",
        "2          S3       12\n",
        "3          S4       67\n",
        "4          S5       21\n",
        "5          S7       55\n",
        "6          S8       33\n",
        "7          S9       14\n",
        "8         S10       56\n",
        "9         S11       83\n",
        "10        S12       88\n",
        "11        S13       12\n",
        "```\n"
      ],
      "metadata": {
        "id": "OGTjjr6SssjJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Data frames\n",
        "student_data1 = pd.DataFrame({\n",
        "    'student_id': ['S1', 'S2', 'S3', 'S4', 'S5'],\n",
        "    'name': ['Danniella Fenton', 'Ryder Storey', 'Bryce Jensen', 'Ed Bernal', 'Kwame Morin'],\n",
        "    'marks': [200, 210, 190, 222, 199]\n",
        "})\n",
        "\n",
        "student_data2 = pd.DataFrame({\n",
        "    'student_id': ['S4', 'S5', 'S6', 'S7', 'S8'],\n",
        "    'name': ['Scarlette Fisher', 'Carla Williamson', 'Dante Morse', 'Kaiser William', 'Madeeha Preston'],\n",
        "    'marks': [201, 200, 198, 219, 201]\n",
        "})\n",
        "\n",
        "\n",
        "exam_data = pd.DataFrame({\n",
        "    'student_id': ['S1', 'S2', 'S3', 'S4', 'S5', 'S7', 'S8', 'S9', 'S10', 'S11', 'S12', 'S13'],\n",
        "    'exam_id': [23, 45, 12, 67, 21, 55, 33, 14, 56, 83, 88, 12]\n",
        "})\n",
        "\n",
        "# join the two given dataframes along rows\n",
        "dataframes_joined = pd.concat([student_data1, student_data2], ignore_index=True)\n",
        "\n",
        "# merge with another dataframe along the common column id 'student_id'. and print the output\n",
        "print(pd.merge(dataframes_joined, exam_data, on='student_id'))\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LavB0U1WstjJ",
        "outputId": "eaddd193-8fe0-4be1-9910-aae017967b2f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "  student_id              name  marks  exam_id\n",
            "0         S1  Danniella Fenton    200       23\n",
            "1         S2      Ryder Storey    210       45\n",
            "2         S3      Bryce Jensen    190       12\n",
            "3         S4         Ed Bernal    222       67\n",
            "4         S4  Scarlette Fisher    201       67\n",
            "5         S5       Kwame Morin    199       21\n",
            "6         S5  Carla Williamson    200       21\n",
            "7         S7    Kaiser William    219       55\n",
            "8         S8   Madeeha Preston    201       33\n"
          ]
        }
      ]
    }
  ]
}