Pandas.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "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/hussain0048/Python-Notes/blob/master/Pandas.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Pandas Table of Content**"
      ],
      "metadata": {
        "id": "0soBWzZi8rY9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1.   📚 *_[Installing Pandas](#installing_pandas)_*\n",
        "2.   📚 *_[Importing Pandas](#importing_pandas)_*\n",
        "3.   📚 *_[Pandas Data Structure](#pandas_data_structure)_*\n",
        "4.   📚 *_[Data Preparation using Pandas](#data_frame_functions)_*\n",
        "5.   📚 *_[Data Visualization using Pandas](#data_visualization)_*"
      ],
      "metadata": {
        "id": "ZnxedzjX85Ak"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  **Pandas(Beginer Level)**"
      ],
      "metadata": {
        "id": "8FcBowAEZN5e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#**Section-1- Installing Pandas**"
      ],
      "metadata": {
        "id": "r_gREz_oZeB6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "conda install pandas"
      ],
      "metadata": {
        "id": "F9_SDT9dZnsY",
        "collapsed": true,
        "outputId": "162b3ca0-14d2-4a9f-88d5-c124fdbcc949",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 321
        }
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ValueError",
          "evalue": "The python kernel does not appear to be a conda environment.  Please use ``%pip install`` instead.",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-6-9fe61f51f895>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mget_ipython\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun_line_magic\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'conda'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'install pandas'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/IPython/core/interactiveshell.py\u001b[0m in \u001b[0;36mrun_line_magic\u001b[0;34m(self, magic_name, line, _stack_depth)\u001b[0m\n\u001b[1;32m   2416\u001b[0m                 \u001b[0mkwargs\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'local_ns'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_local_scope\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstack_depth\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2417\u001b[0m             \u001b[0;32mwith\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbuiltin_trap\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2418\u001b[0;31m                 \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m   2419\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mresult\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m   2420\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m<decorator-gen-100>\u001b[0m in \u001b[0;36mconda\u001b[0;34m(self, line)\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/IPython/core/magic.py\u001b[0m in \u001b[0;36m<lambda>\u001b[0;34m(f, *a, **k)\u001b[0m\n\u001b[1;32m    185\u001b[0m     \u001b[0;31m# but it's overkill for just that one bit of state.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    186\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mmagic_deco\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 187\u001b[0;31m         \u001b[0mcall\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mk\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    188\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    189\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mcallable\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marg\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/IPython/core/magics/packaging.py\u001b[0m in \u001b[0;36mconda\u001b[0;34m(self, line)\u001b[0m\n\u001b[1;32m     84\u001b[0m         \"\"\"\n\u001b[1;32m     85\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0m_is_conda_environment\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 86\u001b[0;31m             raise ValueError(\"The python kernel does not appear to be a conda environment.  \"\n\u001b[0m\u001b[1;32m     87\u001b[0m                              \"Please use ``%pip install`` instead.\")\n\u001b[1;32m     88\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mValueError\u001b[0m: The python kernel does not appear to be a conda environment.  Please use ``%pip install`` instead."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install pandas"
      ],
      "metadata": {
        "id": "McLSSQsSZrFY",
        "outputId": "f7211795-e107-4b04-d02e-a6e168e5810b",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (2.1.4)\n",
            "Requirement already satisfied: numpy<2,>=1.22.4 in /usr/local/lib/python3.10/dist-packages (from pandas) (1.26.4)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas) (2024.1)\n",
            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas) (2024.1)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Section-2-Importing Pandas**"
      ],
      "metadata": {
        "id": "81yvE49DZ1Zj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "UtS8O87jaIww"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Section-3- Pandas Data Structures**\n"
      ],
      "metadata": {
        "id": "CdpSUCjmcb93"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Pandas** provides **two types** of classes for handling data.\n",
        "\n",
        "**1-Series:**\n",
        "\n",
        "A **one-dimensional labeled array** holding data of any type\n",
        "such as integers, strings, Python objects etc.\n",
        "\n",
        "**2-DataFrame:**\n",
        "\n",
        " A **two-dimensional data structure** that holds data like a two-dimension array or a table with **rows and columns.**"
      ],
      "metadata": {
        "id": "syXzjc1wBSQr"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **3.1- Series in Pandas**"
      ],
      "metadata": {
        "id": "DMZqc4-TcmDt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Basic Syntax**"
      ],
      "metadata": {
        "id": "pKskxNveF1ne"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries = pd.Series(data , index)"
      ],
      "metadata": {
        "id": "Vpp4lxljcwSt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "\n",
        "\n",
        "###**Let’s build a series from Python List:**\n",
        "\n"
      ],
      "metadata": {
        "id": "70aC5mvmdFLc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = ['Ahmad','Machine Learning', 20, 'Pakistan']\n",
        "labels = ['Name', 'Career', 'Age', 'Country']\n",
        "newSeries = pd.Series(mylist,labels)\n",
        "print(newSeries)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-wCCa-oHdQqs",
        "outputId": "77411f94-e126-4fdd-b88e-feae97991a4b"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Name                  Ahmad\n",
            "Career     Machine Learning\n",
            "Age                      20\n",
            "Country            Pakistan\n",
            "dtype: object\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "It is not necessary to add an index in a pandas Series. In that case, it will automatically start index from 0."
      ],
      "metadata": {
        "id": "SclW2Vx8durV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "mylist = ['Ahmad','Machine Learning', 20, 'Pakistan']\n",
        "newSeries = pd.Series(mylist)\n",
        "print(newSeries)"
      ],
      "metadata": {
        "id": "5ZccTmPAdmZk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Create a Series using a Python Dictionary**"
      ],
      "metadata": {
        "id": "V4I8ICSMd2YW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "myDict = {'Name': 'Ahmad',\n",
        "         'Career': 'Machine Learning',\n",
        "         'Age': 20,\n",
        "          'Country': 'Pakistan'}\n",
        "mySeries = pd.Series(myDict)\n",
        "print(mySeries)"
      ],
      "metadata": {
        "id": "u7O8w0ped-9V"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Create a Series From scalar value**"
      ],
      "metadata": {
        "id": "kTbRu8ikGpBi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "pd.Series(5.0, index=[\"a\", \"b\", \"c\", \"d\", \"e\"])\n",
        "Out[12]:\n",
        "a    5.0\n",
        "b    5.0\n",
        "c    5.0\n",
        "d    5.0\n",
        "e    5.0\n",
        "dtype: float64"
      ],
      "metadata": {
        "id": "kif4wLd2GyzA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###**Accessing data from Series**\n"
      ],
      "metadata": {
        "id": "G4WWSNfUeHy0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "seriesName['IndexName']"
      ],
      "metadata": {
        "id": "OPD613P-eNCL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(mySeries['Name'])\n",
        "print(mySeries['Age'])\n",
        "print(mySeries['Career'])"
      ],
      "metadata": {
        "id": "puzHiEo9eN-7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Series as ND Array**"
      ],
      "metadata": {
        "id": "5VkjcbNOYPGp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Series** acts very similarly to a **ndarray** and is a valid argument to most **NumPy functions**."
      ],
      "metadata": {
        "id": "MQF3SCHpYd7s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Create a Pandas Series\n",
        "s = pd.Series([10, 20, 30, 40], index=['a', 'b', 'c', 'd'])\n",
        "\n",
        "# Accessing elements using index labels\n",
        "print(\"Element at index 'b':\", s['b'])  # Output: 20\n",
        "\n",
        "# Arithmetic operation\n",
        "s_double = s * 2\n",
        "print(\"\\nSeries after doubling each element:\")\n",
        "print(s_double)\n",
        "\n",
        "# NumPy-like operations\n",
        "import numpy as np\n",
        "arr = np.sqrt(s)\n",
        "print(\"\\nSquare root of each element (NumPy array):\")\n",
        "print(arr)\n",
        "\n",
        "# Adding two Series based on index labels\n",
        "s2 = pd.Series([1, 2, 3, 4], index=['a', 'b', 'e', 'f'])\n",
        "sum_series = s + s2\n",
        "print(\"\\nSum of two Series (aligned based on index labels):\")\n",
        "print(sum_series)\n"
      ],
      "metadata": {
        "id": "2Lg8jYP8YZdz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Basic Operations on Pandas Series**\n"
      ],
      "metadata": {
        "id": "pklm2nU4eZxc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries = pd.Series([10,20,30,40],index=['LONDON','NEWYORK','Washington','Manchester'])\n",
        "newSeries1 = pd.Series([10,20,35,46],index=['LONDON','NEWYORK','Istanbul','Karachi'])\n",
        "print(newSeries,newSeries1,sep='\\n\\n')"
      ],
      "metadata": {
        "id": "dgp8QWUIegEk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Basic Arithmetic operations include +-*/ operations. These are done over-index, so let’s perform them."
      ],
      "metadata": {
        "id": "BEp-hGbjetHH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries + newSeries1"
      ],
      "metadata": {
        "id": "r4JAuVsheo3s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Here we can see that since London and NEWYORK index are present in both Series, so it has added the value of both and output of rest is NaN (Not a number)"
      ],
      "metadata": {
        "id": "2IhTAvBve2q7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries * newSeries1"
      ],
      "metadata": {
        "id": "6k0TtEQKgNjQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries / newSeries1"
      ],
      "metadata": {
        "id": "CNCwA3zDgR7q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Element Wise Operations/Broadcasting**\n"
      ],
      "metadata": {
        "id": "dnsF3wMUg0-t"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries + 5"
      ],
      "metadata": {
        "id": "jOp8JrauhAyD"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "newSeries ** 1/2"
      ],
      "metadata": {
        "id": "FovpUsgihYkU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **3.2-DataFrame in Pandas**"
      ],
      "metadata": {
        "id": "TycEViJnjw4e"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Ways to create Data Frame are:**\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "6YelgeNXkBQN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###  **DataFrame Creation using Python Dictionary**\n"
      ],
      "metadata": {
        "id": "tD1TZFnlkHgd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df1 = {\"Name\":[\"Ahmad\",\"Ali\",'Ismail',\"John\"],\"Age\":  [20,21,19,17],\"Height\":[5.1,5.6,6.1,5.7]}"
      ],
      "metadata": {
        "id": "SzsE9gBGkMUd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df1 = pd.DataFrame(df1)\n",
        "df1"
      ],
      "metadata": {
        "id": "tZf8qB4XkRGv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Getting Values from a Column**\n"
      ],
      "metadata": {
        "id": "azcIV9BEkZ8u"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df1['Age']\n",
        "#df1.columnname"
      ],
      "metadata": {
        "id": "cMMn1jy_kf7G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Both of these syntaxes are correct, but we have to be careful about choosing one. If our column name has space in it, then definitely we can not use the 2nd method. We have to use the first method. We can only use the 2nd method when there is no space in the column name."
      ],
      "metadata": {
        "id": "qeVU1pgEkzYH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df1.Name"
      ],
      "metadata": {
        "id": "PhiE1PeUk2ZH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Values of Multiple Columns**\n"
      ],
      "metadata": {
        "id": "_VPNy_vyk75U"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df1[[\"Name\",\"Age\"]]"
      ],
      "metadata": {
        "id": "tqI7IZ1Sk-3M"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **DataFrame Creation using Numpy array**"
      ],
      "metadata": {
        "id": "EtjAbWA6cO7v"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Creating a **DataFrame** by passing a **NumPy array** with a datetime index using ```date_range()``` and labeled columns:"
      ],
      "metadata": {
        "id": "688W4V5nctkV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dates = pd.date_range(\"20130101\", periods=6)\n",
        "dates\n"
      ],
      "metadata": {
        "id": "AW8KCtRccnrQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list(\"ABCD\"))\n",
        "df"
      ],
      "metadata": {
        "id": "Aw6lrfL2dK7d"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Section-4-Data Preparation using pandas**"
      ],
      "metadata": {
        "id": "pjwf1Np_lY5O"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4.1-Loading Libraries**"
      ],
      "metadata": {
        "id": "PvyJ5WEhmKmk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Import the required libraries\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "from sklearn.preprocessing import StandardScaler, LabelEncoder"
      ],
      "metadata": {
        "id": "rojRfyWzmRkh"
      },
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4.2-Loading DataSet**"
      ],
      "metadata": {
        "id": "wR2rsgKHrQue"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Built-in-DataSet**"
      ],
      "metadata": {
        "id": "5rMDuntqrcqe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Many Python libraries come with built-in datasets that are readily available for experimentation and learning. These datasets are often included to showcase library capabilities, serve as educational resources, or provide standard benchmarks for algorithms.\n",
        "\n",
        "Following are some examples of libraries that include dataset in them.\n",
        "\n",
        "\n",
        "1.   **Scikit-Learn**\n",
        "2.   **Seaborn**\n",
        "3.   **Matplotlib**\n",
        "4.   **TensorFlow**\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "qIau5Mxrsf52"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "df=sns.load_dataset('titanic')\n",
        "import numpy as np"
      ],
      "metadata": {
        "id": "8bkzYEYSkTJx"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn import datasets\n",
        "\n",
        "# Load a built-in dataset (e.g., Iris dataset)\n",
        "iris = datasets.load_iris()\n"
      ],
      "metadata": {
        "id": "s1Hi6jM1tGae"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import tensorflow_datasets as tfds\n",
        "\n",
        "# Load a built-in dataset (e.g., MNIST dataset)\n",
        "mnist_data = tfds.load('mnist')\n"
      ],
      "metadata": {
        "id": "TktjLPB7tQXp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **User-Defined DataSet**"
      ],
      "metadata": {
        "id": "wW-glohNtZZv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "User-defined datasets refer to datasets created by users or organizations for specific analysis, research, or applications. These datasets may be sourced from various sources, including surveys, experiments, data collection efforts, and public repositories.\n",
        "\n",
        "Following are some ways to collect the user-defined datasets.\n",
        "\n",
        "\n",
        "1.   **Local Files (CSV, Excel, JSON, etc.)**\n",
        "2.   **Database Queries**\n",
        "3.   **Web Scraping**\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "qv4Mm6iStinu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Basic Syntax\n",
        "pd.read_fileExtensionName(\"File Path\")"
      ],
      "metadata": {
        "id": "1qQ0Z-TSv4JT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Local Files\n",
        "import pandas as pd\n",
        "\n",
        "# Load a user-defined dataset from a CSV file\n",
        "df = pd.read_csv('data.csv')"
      ],
      "metadata": {
        "id": "KDJmB4b8ueEg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# From Database\n",
        "\n",
        "\n",
        "import pandas as pd\n",
        "import sqlite3\n",
        "\n",
        "# Connect to a SQLite database\n",
        "conn = sqlite3.connect('database.db')\n",
        "\n",
        "# Execute a SQL query to fetch data\n",
        "query = \"SELECT * FROM table_name\"\n",
        "df = pd.read_sql(query, conn)\n",
        "\n",
        "# Close the database connection\n",
        "conn.close()"
      ],
      "metadata": {
        "id": "e4b8vz_suhtR"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Using Web-Scrapping\n",
        "\n",
        "import pandas as pd\n",
        "import requests\n",
        "from bs4 import BeautifulSoup\n",
        "\n",
        "# Fetch data from a website\n",
        "url = 'https://example.com/data'\n",
        "response = requests.get(url)\n",
        "soup = BeautifulSoup(response.content, 'html.parser')\n",
        "\n",
        "# Parse HTML content to extract data\n",
        "# Example: Extracting tables using pandas read_html function\n",
        "dfs = pd.read_html(url)\n",
        "df = dfs[0]"
      ],
      "metadata": {
        "id": "Z9XNK1mfunMv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Here We will use Titanic DataSet for the refrence**"
      ],
      "metadata": {
        "id": "prJbSBTNvXOF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import seaborn as sns\n",
        "df=sns.load_dataset('titanic')"
      ],
      "metadata": {
        "id": "TDDKzMN-vZYj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4.3-Common Pandas Functions**"
      ],
      "metadata": {
        "id": "I5PBQZ0mw2Aw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Viewing DataSet**"
      ],
      "metadata": {
        "id": "kkMoz5NyxaSF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "```head()``` &```tail()```:\n",
        "View the first or last few rows of the dataset."
      ],
      "metadata": {
        "id": "vNqM-8u2xpT5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()  # View the first few rows\n",
        "df.tail()  # View the last few rows\n"
      ],
      "metadata": {
        "id": "yrffsjH6x6T1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "```info()```: Get a concise summary of the dataset, including data types and missing values."
      ],
      "metadata": {
        "id": "pUtXziO5x9yW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.info() # Give summary of the dataset"
      ],
      "metadata": {
        "id": "SCFB1zjPyF6s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "```describe()```: Get statistical information about numerical columns."
      ],
      "metadata": {
        "id": "EvHuwR4vyLBp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.describe() # Get statistical information about numerical columns"
      ],
      "metadata": {
        "id": "GSo5dmbPyTKN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Data Cleaning**"
      ],
      "metadata": {
        "id": "MuXN5aspyj-M"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Handling Missing Values**:"
      ],
      "metadata": {
        "id": "zMzzWNoByvjL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check for missing values\n",
        "df.isnull().sum()\n",
        "\n",
        "# Fill missing values in 'Age' column with median age\n",
        "median_age = df['Age'].median()\n",
        "df['Age'].fillna(median_age, inplace=True)\n",
        "\n",
        "# Fill missing values in 'Embarked' column with the most common value\n",
        "most_common_embarked = df['Embarked'].mode()[0]\n",
        "df['Embarked'].fillna(most_common_embarked, inplace=True)\n"
      ],
      "metadata": {
        "id": "tMkBep0Uy2A5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Removing Duplicates:**"
      ],
      "metadata": {
        "id": "5xcFaoFQzEZ8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check for duplicate rows\n",
        "df.duplicated().sum()\n",
        "\n",
        "# Drop duplicate rows\n",
        "df.drop_duplicates(inplace=True)"
      ],
      "metadata": {
        "id": "HS_HYGHKzIpj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Handling Categorical Variables:**"
      ],
      "metadata": {
        "id": "e8O3RSTjzTa0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Convert 'Sex' column to categorical data type\n",
        "df['Sex'] = df['Sex'].astype('category')\n",
        "\n",
        "# Convert 'Embarked' column to categorical data type\n",
        "df['Embarked'] = df['Embarked'].astype('category')"
      ],
      "metadata": {
        "id": "7G_HiggMzZtw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Handling Outliers:**"
      ],
      "metadata": {
        "id": "dZPaGTiQzf2_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Outliers can skew your data and affect the performance of your model."
      ],
      "metadata": {
        "id": "vZOLBp7Uvnwd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Detect Outliers\n",
        "sns.boxplot(x=df['Fare'])\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "h9MqQvAhwESL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing Outliers\n",
        "Q1 = df['Fare'].quantile(0.25)\n",
        "Q3 = df['Fare'].quantile(0.75)\n",
        "IQR = Q3 - Q1\n",
        "df = df[(df['Fare'] >= (Q1 - 1.5 * IQR)) & (df['Fare'] <= (Q3 + 1.5 * IQR))]\n"
      ],
      "metadata": {
        "id": "1LiTvX9-wH86"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Data Transformation**"
      ],
      "metadata": {
        "id": "hQYAOvYJwihH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Normalizing and Scaling**"
      ],
      "metadata": {
        "id": "gIILwRIewm7r"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "scaler = StandardScaler()\n",
        "df[['Age', 'Fare']] = scaler.fit_transform(df[['Age', 'Fare']])\n"
      ],
      "metadata": {
        "id": "-1hfZFqlwsVo"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Encoding categorical variables:**"
      ],
      "metadata": {
        "id": "ugPYNylWxacZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# One-hot encoding for 'Sex' and 'Embarked'\n",
        "df = pd.get_dummies(df, columns=['Sex', 'Embarked'])\n",
        "\n",
        "# Label encoding for 'Pclass'\n",
        "le = LabelEncoder()\n",
        "df['Pclass'] = le.fit_transform(df['Pclass'])\n"
      ],
      "metadata": {
        "id": "yw3rU1NQxW1y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Feature Engineering**"
      ],
      "metadata": {
        "id": "5VGVCrrcyr3h"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Creating New Features out of existing data**"
      ],
      "metadata": {
        "id": "Ss1UgchOy5fg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Creating a family size feature\n",
        "df['FamilySize'] = df['SibSp'] + df['Parch'] + 1"
      ],
      "metadata": {
        "id": "RHtG28Rq0SeW"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**pd.read_csv()**\n"
      ],
      "metadata": {
        "id": "lo43FhAdUo9a"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Filtering  the Data**"
      ],
      "metadata": {
        "id": "PgMSdBOY2dlB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Filter rows based on a condition\n",
        "filtered_data = data[data['column'] = value]"
      ],
      "metadata": {
        "id": "5e9XwyOX2iDK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Filter passengers who survived:\n",
        "survived_df = df[df['Survived'] == 1]\n",
        "print(survived_df.head())"
      ],
      "metadata": {
        "id": "3JSfxMYv2k3O"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Filter passengers who are female and survived:\n",
        "female_survived_df = df[(df['Survived'] == 1) & (df['Sex'] == 'female')]\n",
        "print(female_survived_df.head())"
      ],
      "metadata": {
        "id": "GDz71m7O2unt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Filter passengers who are male and paid a fare greater than $50:\n",
        "male_high_fare_df = df[(df['Sex'] == 'male') & (df['Fare'] > 50)]\n",
        "print(male_high_fare_df.head())\n"
      ],
      "metadata": {
        "id": "9UrVTgw720fl"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Subsetting the Data**"
      ],
      "metadata": {
        "id": "ZbUCV84P3Qk8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Subsetting involves selecting specific rows and columns."
      ],
      "metadata": {
        "id": "JPH9pcBm3frT"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Selecting by using Columns Names**"
      ],
      "metadata": {
        "id": "WD2-Zlj83jLB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subset_df = df[['Name', 'Sex', 'Age', 'Survived']]\n",
        "print(subset_df.head())"
      ],
      "metadata": {
        "id": "VskmQm0C3Tpv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Select rows by index:**"
      ],
      "metadata": {
        "id": "qtS0QmJS3zPQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subset_rows_df = df.iloc[0:10]  # First 10 rows\n",
        "print(subset_rows_df)"
      ],
      "metadata": {
        "id": "_yZNjCKa33W5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Select specific rows and columns:**"
      ],
      "metadata": {
        "id": "lNYc7HX_4sLw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "subset_rows_columns_df = df.loc[0:10, ['Name', 'Age', 'Survived']]  # First 11 rows and specific columns\n",
        "print(subset_rows_columns_df)"
      ],
      "metadata": {
        "id": "2_Db_cN74uyM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Read the CSV file into a DataFrame\n",
        "df = pd.read_csv('data.csv')\n",
        "\n",
        "# Print the DataFrame\n",
        "print(df)"
      ],
      "metadata": {
        "id": "vB_-Ifv0UrDw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###  **Grouping Data**"
      ],
      "metadata": {
        "id": "opvIzfa8DjhX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Grouping data involves splitting the data into groups based on some criteria."
      ],
      "metadata": {
        "id": "z7s3Ef4QDpDi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by a single column (e.g., 'Sex'):\n",
        "grouped_df = df.groupby('Sex')"
      ],
      "metadata": {
        "id": "Qejcs8djDxEO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Group by multiple columns (e.g., 'Sex' and 'Pclass'):\n",
        "grouped_df = df.groupby(['Sex', 'Pclass'])"
      ],
      "metadata": {
        "id": "uaMXqy1nD3GL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Aggregating Data**"
      ],
      "metadata": {
        "id": "VkkWc_wMD9ka"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate the mean age for each gender:\n",
        "mean_age_by_gender = df.groupby('Sex')['Age'].mean()\n",
        "print(mean_age_by_gender)"
      ],
      "metadata": {
        "id": "MUTksIaPEVXq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Aggregation involves computing a summary statistic for each group."
      ],
      "metadata": {
        "id": "0OIHWQ_GEKc9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate multiple aggregation functions (mean and median) for 'Fare' grouped by 'Pclass':\n",
        "aggregated_df = df.groupby('Pclass')['Fare'].agg(['mean', 'median'])\n",
        "print(aggregated_df)"
      ],
      "metadata": {
        "id": "tdhLdAxQEmEn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Calculate multiple aggregations for multiple columns:\n",
        "multi_agg_by_sex_pclass = grouped_by_sex_pclass.agg({\n",
        "    'Age': ['mean', 'max', 'min'],\n",
        "    'Fare': ['mean', 'sum']\n",
        "})\n",
        "print(multi_agg_by_sex_pclass)\n"
      ],
      "metadata": {
        "id": "wp6VvD2nEsal"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Merging and Joining Data**"
      ],
      "metadata": {
        "id": "6cmrHwzgLK1S"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Merging and joining are essential for combining multiple datasets."
      ],
      "metadata": {
        "id": "DY-aSptxLOtp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Load the Titanic dataset\n",
        "titanic_df = pd.read_csv('titanic.csv')\n",
        "\n",
        "# Create another DataFrame for demonstration\n",
        "additional_info = pd.DataFrame({\n",
        "    'PassengerId': [1, 2, 3, 4, 5],\n",
        "    'Embarkation_Port': ['Southampton', 'Cherbourg', 'Cherbourg', 'Southampton', 'Southampton'],\n",
        "    'Ticket_Price_Category': ['High', 'High', 'Medium', 'Low', 'Medium']\n",
        "})\n",
        "\n",
        "print(titanic_df.head())\n",
        "print(additional_info)\n"
      ],
      "metadata": {
        "id": "8C6ZDxQ5LUkO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Merge Two DataFrames on a Common Column**"
      ],
      "metadata": {
        "id": "eMA0fbZBLriK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# We will merge titanic_df and additional_info on the PassengerId column.\n",
        "merged_data = pd.merge(titanic_df, additional_info, on='PassengerId')\n",
        "print(merged_data.head())"
      ],
      "metadata": {
        "id": "EztC38t8LwSh"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Join Two DataFrames Based on Their Indexes**"
      ],
      "metadata": {
        "id": "_RalrKADL3R0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# First, we need to set the PassengerId as the index for both DataFrames. Then we will perform the join.\n",
        "# Set 'PassengerId' as the index\n",
        "titanic_df.set_index('PassengerId', inplace=True)\n",
        "additional_info.set_index('PassengerId', inplace=True)\n",
        "\n",
        "# Join DataFrames based on their indexes\n",
        "joined_data = titanic_df.join(additional_info, how='inner')\n",
        "print(joined_data.head())\n",
        "\n",
        "# Reset index if needed\n",
        "titanic_df.reset_index(inplace=True)\n",
        "additional_info.reset_index(inplace=True)\n"
      ],
      "metadata": {
        "id": "Sa_ufZYsL8S6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Cleaning Wrong Format Data**"
      ],
      "metadata": {
        "id": "CeshgBlqY7qk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ways to Clean wrong format data\n",
        "df['Age'] = pd.to_numeric(df['age'], errors='coerce')\n",
        "df['Fare'] = pd.to_numeric(df['fare'], errors='coerce')\n",
        "\n"
      ],
      "metadata": {
        "id": "o_kWXdBKZBRl"
      },
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Data Correlations**"
      ],
      "metadata": {
        "id": "hXSx8TaIb0a1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Finding Relationships between column in your dataset there number varies from -1 to 1 1 means there there is a 1 to 1 relationship( a perfect correlation)"
      ],
      "metadata": {
        "id": "6-i-GdWab5YJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Selecting columns with numeric datatype\n",
        "numeric_cols = df.select_dtypes(include=['number'])\n",
        "\n",
        "# Calculate the correlation matrix\n",
        "correlation_matrix = numeric_cols.corr()\n",
        "\n",
        "# Display the correlation matrix\n",
        "print(correlation_matrix)"
      ],
      "metadata": {
        "id": "ezZS576ib3-M",
        "outputId": "f9cc0ee4-ab87-4b88-e460-9cf3d4a0332f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        }
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "          survived    pclass       age     sibsp     parch      fare  \\\n",
            "survived  1.000000 -0.338481 -0.077221 -0.035322  0.081629  0.257307   \n",
            "pclass   -0.338481  1.000000 -0.369226  0.083081  0.018443 -0.549500   \n",
            "age      -0.077221 -0.369226  1.000000 -0.308247 -0.189119  0.096067   \n",
            "sibsp    -0.035322  0.083081 -0.308247  1.000000  0.414838  0.159651   \n",
            "parch     0.081629  0.018443 -0.189119  0.414838  1.000000  0.216225   \n",
            "fare      0.257307 -0.549500  0.096067  0.159651  0.216225  1.000000   \n",
            "Age      -0.077221 -0.369226  1.000000 -0.308247 -0.189119  0.096067   \n",
            "Fare      0.257307 -0.549500  0.096067  0.159651  0.216225  1.000000   \n",
            "\n",
            "               Age      Fare  \n",
            "survived -0.077221  0.257307  \n",
            "pclass   -0.369226 -0.549500  \n",
            "age       1.000000  0.096067  \n",
            "sibsp    -0.308247  0.159651  \n",
            "parch    -0.189119  0.216225  \n",
            "fare      0.096067  1.000000  \n",
            "Age       1.000000  0.096067  \n",
            "Fare      0.096067  1.000000  \n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        " **Correlation Coefficient Range**:\n",
        "+1: Perfect positive correlation\n",
        "\n",
        "0: No correlation\n",
        "\n",
        "-1: Perfect negative correlation\n",
        "\n",
        "**Strong Correlation**: Typically, values above 0.7 or below -0.7 indicate a strong correlation.\n",
        "\n",
        "**Moderate Correlation**: Values between 0.3 and 0.7 (positive or negative) indicate a moderate correlation.\n",
        "\n",
        "**Weak Correlation**: Values below 0.3 indicate a weak correlation"
      ],
      "metadata": {
        "id": "cLPC4JJqcbqi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**pd.read_table()**"
      ],
      "metadata": {
        "id": "OpA5qfli0_w-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Adding Columns in DataFrame**"
      ],
      "metadata": {
        "id": "jwnCyun7dEQH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Adding new column in dataset\n",
        "df['col'] = 5\n",
        "df"
      ],
      "metadata": {
        "id": "XoiharfrdLPR",
        "outputId": "9784e5a4-ac74-46f2-f117-03bef195d8fb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 424
        }
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "     survived  pclass     sex   age  sibsp  parch     fare embarked   class  \\\n",
              "0           0       3    male  22.0      1      0   7.2500        S   Third   \n",
              "1           1       1  female  38.0      1      0  71.2833        C   First   \n",
              "2           1       3  female  26.0      0      0   7.9250        S   Third   \n",
              "3           1       1  female  35.0      1      0  53.1000        S   First   \n",
              "4           0       3    male  35.0      0      0   8.0500        S   Third   \n",
              "..        ...     ...     ...   ...    ...    ...      ...      ...     ...   \n",
              "886         0       2    male  27.0      0      0  13.0000        S  Second   \n",
              "887         1       1  female  19.0      0      0  30.0000        S   First   \n",
              "888         0       3  female   NaN      1      2  23.4500        S   Third   \n",
              "889         1       1    male  26.0      0      0  30.0000        C   First   \n",
              "890         0       3    male  32.0      0      0   7.7500        Q   Third   \n",
              "\n",
              "       who  adult_male deck  embark_town alive  alone   Age     Fare  col  \n",
              "0      man        True  NaN  Southampton    no  False  22.0   7.2500    5  \n",
              "1    woman       False    C    Cherbourg   yes  False  38.0  71.2833    5  \n",
              "2    woman       False  NaN  Southampton   yes   True  26.0   7.9250    5  \n",
              "3    woman       False    C  Southampton   yes  False  35.0  53.1000    5  \n",
              "4      man        True  NaN  Southampton    no   True  35.0   8.0500    5  \n",
              "..     ...         ...  ...          ...   ...    ...   ...      ...  ...  \n",
              "886    man        True  NaN  Southampton    no   True  27.0  13.0000    5  \n",
              "887  woman       False    B  Southampton   yes   True  19.0  30.0000    5  \n",
              "888  woman       False  NaN  Southampton    no  False   NaN  23.4500    5  \n",
              "889    man        True    C    Cherbourg   yes   True  26.0  30.0000    5  \n",
              "890    man        True  NaN   Queenstown    no   True  32.0   7.7500    5  \n",
              "\n",
              "[891 rows x 18 columns]"
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-09f9f202-1f67-4949-97d9-a4ecf767014b\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>survived</th>\n",
              "      <th>pclass</th>\n",
              "      <th>sex</th>\n",
              "      <th>age</th>\n",
              "      <th>sibsp</th>\n",
              "      <th>parch</th>\n",
              "      <th>fare</th>\n",
              "      <th>embarked</th>\n",
              "      <th>class</th>\n",
              "      <th>who</th>\n",
              "      <th>adult_male</th>\n",
              "      <th>deck</th>\n",
              "      <th>embark_town</th>\n",
              "      <th>alive</th>\n",
              "      <th>alone</th>\n",
              "      <th>Age</th>\n",
              "      <th>Fare</th>\n",
              "      <th>col</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>male</td>\n",
              "      <td>22.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>7.2500</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>False</td>\n",
              "      <td>22.0</td>\n",
              "      <td>7.2500</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>female</td>\n",
              "      <td>38.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>71.2833</td>\n",
              "      <td>C</td>\n",
              "      <td>First</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>C</td>\n",
              "      <td>Cherbourg</td>\n",
              "      <td>yes</td>\n",
              "      <td>False</td>\n",
              "      <td>38.0</td>\n",
              "      <td>71.2833</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>1</td>\n",
              "      <td>3</td>\n",
              "      <td>female</td>\n",
              "      <td>26.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>7.9250</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>yes</td>\n",
              "      <td>True</td>\n",
              "      <td>26.0</td>\n",
              "      <td>7.9250</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>female</td>\n",
              "      <td>35.0</td>\n",
              "      <td>1</td>\n",
              "      <td>0</td>\n",
              "      <td>53.1000</td>\n",
              "      <td>S</td>\n",
              "      <td>First</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>C</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>yes</td>\n",
              "      <td>False</td>\n",
              "      <td>35.0</td>\n",
              "      <td>53.1000</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>male</td>\n",
              "      <td>35.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>8.0500</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>True</td>\n",
              "      <td>35.0</td>\n",
              "      <td>8.0500</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>...</th>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "      <td>...</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>886</th>\n",
              "      <td>0</td>\n",
              "      <td>2</td>\n",
              "      <td>male</td>\n",
              "      <td>27.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>13.0000</td>\n",
              "      <td>S</td>\n",
              "      <td>Second</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>True</td>\n",
              "      <td>27.0</td>\n",
              "      <td>13.0000</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>887</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>female</td>\n",
              "      <td>19.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>30.0000</td>\n",
              "      <td>S</td>\n",
              "      <td>First</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>B</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>yes</td>\n",
              "      <td>True</td>\n",
              "      <td>19.0</td>\n",
              "      <td>30.0000</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>888</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>female</td>\n",
              "      <td>NaN</td>\n",
              "      <td>1</td>\n",
              "      <td>2</td>\n",
              "      <td>23.4500</td>\n",
              "      <td>S</td>\n",
              "      <td>Third</td>\n",
              "      <td>woman</td>\n",
              "      <td>False</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Southampton</td>\n",
              "      <td>no</td>\n",
              "      <td>False</td>\n",
              "      <td>NaN</td>\n",
              "      <td>23.4500</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>889</th>\n",
              "      <td>1</td>\n",
              "      <td>1</td>\n",
              "      <td>male</td>\n",
              "      <td>26.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>30.0000</td>\n",
              "      <td>C</td>\n",
              "      <td>First</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>C</td>\n",
              "      <td>Cherbourg</td>\n",
              "      <td>yes</td>\n",
              "      <td>True</td>\n",
              "      <td>26.0</td>\n",
              "      <td>30.0000</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>890</th>\n",
              "      <td>0</td>\n",
              "      <td>3</td>\n",
              "      <td>male</td>\n",
              "      <td>32.0</td>\n",
              "      <td>0</td>\n",
              "      <td>0</td>\n",
              "      <td>7.7500</td>\n",
              "      <td>Q</td>\n",
              "      <td>Third</td>\n",
              "      <td>man</td>\n",
              "      <td>True</td>\n",
              "      <td>NaN</td>\n",
              "      <td>Queenstown</td>\n",
              "      <td>no</td>\n",
              "      <td>True</td>\n",
              "      <td>32.0</td>\n",
              "      <td>7.7500</td>\n",
              "      <td>5</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "<p>891 rows × 18 columns</p>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-09f9f202-1f67-4949-97d9-a4ecf767014b')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-09f9f202-1f67-4949-97d9-a4ecf767014b button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-09f9f202-1f67-4949-97d9-a4ecf767014b');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-13873bda-351a-44d7-93bd-29d2a2800f38\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-13873bda-351a-44d7-93bd-29d2a2800f38')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-13873bda-351a-44d7-93bd-29d2a2800f38 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "  <div id=\"id_fde93290-7bd5-46ec-883b-6658fd1f2d3c\">\n",
              "    <style>\n",
              "      .colab-df-generate {\n",
              "        background-color: #E8F0FE;\n",
              "        border: none;\n",
              "        border-radius: 50%;\n",
              "        cursor: pointer;\n",
              "        display: none;\n",
              "        fill: #1967D2;\n",
              "        height: 32px;\n",
              "        padding: 0 0 0 0;\n",
              "        width: 32px;\n",
              "      }\n",
              "\n",
              "      .colab-df-generate:hover {\n",
              "        background-color: #E2EBFA;\n",
              "        box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "        fill: #174EA6;\n",
              "      }\n",
              "\n",
              "      [theme=dark] .colab-df-generate {\n",
              "        background-color: #3B4455;\n",
              "        fill: #D2E3FC;\n",
              "      }\n",
              "\n",
              "      [theme=dark] .colab-df-generate:hover {\n",
              "        background-color: #434B5C;\n",
              "        box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "        filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "        fill: #FFFFFF;\n",
              "      }\n",
              "    </style>\n",
              "    <button class=\"colab-df-generate\" onclick=\"generateWithVariable('df')\"\n",
              "            title=\"Generate code using this dataframe.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "       width=\"24px\">\n",
              "    <path d=\"M7,19H8.4L18.45,9,17,7.55,7,17.6ZM5,21V16.75L18.45,3.32a2,2,0,0,1,2.83,0l1.4,1.43a1.91,1.91,0,0,1,.58,1.4,1.91,1.91,0,0,1-.58,1.4L9.25,21ZM18.45,9,17,7.55Zm-12,3A5.31,5.31,0,0,0,4.9,8.1,5.31,5.31,0,0,0,1,6.5,5.31,5.31,0,0,0,4.9,4.9,5.31,5.31,0,0,0,6.5,1,5.31,5.31,0,0,0,8.1,4.9,5.31,5.31,0,0,0,12,6.5,5.46,5.46,0,0,0,6.5,12Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "    <script>\n",
              "      (() => {\n",
              "      const buttonEl =\n",
              "        document.querySelector('#id_fde93290-7bd5-46ec-883b-6658fd1f2d3c button.colab-df-generate');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      buttonEl.onclick = () => {\n",
              "        google.colab.notebook.generateWithVariable('df');\n",
              "      }\n",
              "      })();\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "variable_name": "df",
              "summary": "{\n  \"name\": \"df\",\n  \"rows\": 891,\n  \"fields\": [\n    {\n      \"column\": \"survived\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 1,\n        \"num_unique_values\": 2,\n        \"samples\": [\n          1,\n          0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"pclass\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 1,\n        \"max\": 3,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          3,\n          1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"sex\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"female\",\n          \"male\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"age\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 14.526497332334042,\n        \"min\": 0.42,\n        \"max\": 80.0,\n        \"num_unique_values\": 88,\n        \"samples\": [\n          0.75,\n          22.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"sibsp\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 1,\n        \"min\": 0,\n        \"max\": 8,\n        \"num_unique_values\": 7,\n        \"samples\": [\n          1,\n          0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"parch\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 0,\n        \"max\": 6,\n        \"num_unique_values\": 7,\n        \"samples\": [\n          0,\n          1\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"fare\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 49.6934285971809,\n        \"min\": 0.0,\n        \"max\": 512.3292,\n        \"num_unique_values\": 248,\n        \"samples\": [\n          11.2417,\n          51.8625\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"embarked\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"S\",\n          \"C\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"class\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"Third\",\n          \"First\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"who\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"man\",\n          \"woman\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"adult_male\",\n      \"properties\": {\n        \"dtype\": \"boolean\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          false,\n          true\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"deck\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 7,\n        \"samples\": [\n          \"C\",\n          \"E\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"embark_town\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"Southampton\",\n          \"Cherbourg\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"alive\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"yes\",\n          \"no\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"alone\",\n      \"properties\": {\n        \"dtype\": \"boolean\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          true,\n          false\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Age\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 14.526497332334042,\n        \"min\": 0.42,\n        \"max\": 80.0,\n        \"num_unique_values\": 88,\n        \"samples\": [\n          0.75,\n          22.0\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Fare\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 49.6934285971809,\n        \"min\": 0.0,\n        \"max\": 512.3292,\n        \"num_unique_values\": 248,\n        \"samples\": [\n          11.2417,\n          51.8625\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"col\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 0,\n        \"min\": 5,\n        \"max\": 5,\n        \"num_unique_values\": 1,\n        \"samples\": [\n          5\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Column Deletion in Dataframe**"
      ],
      "metadata": {
        "id": "N1rLmM1_deSS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.drop(columns=['col'],inplace=True)"
      ],
      "metadata": {
        "id": "ivHpULf8di0_"
      },
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Row Addition in DataFrame**"
      ],
      "metadata": {
        "id": "BAFcXCBzduqy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# row addition in dataframe\n",
        "new_row = pd.DataFrame({'col1': [10], 'col2': [20]})\n",
        "df = pd.concat([df, new_row], ignore_index=True)"
      ],
      "metadata": {
        "id": "8wViNvNbd6jr"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Row Deletion in DataFrame**"
      ],
      "metadata": {
        "id": "M7mgoxL9eMeU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Row Deletion\n",
        "df.drop(0, inplace =True)"
      ],
      "metadata": {
        "id": "Jy6DmgTYeQo0"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **Saving Prepared Data**\n"
      ],
      "metadata": {
        "id": "LPi7OMAieccV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Save the DataFrame to a CSV file\n",
        "df.to_csv('prepared_data.csv', index=False)\n",
        "# Save the DataFrame to an Excel file\n",
        "df.to_excel('prepared_data.xlsx', index=False)"
      ],
      "metadata": {
        "id": "zWQgvJQnegFd"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**pd.read_excel()**\n"
      ],
      "metadata": {
        "id": "gAyD8MLJ3TuB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Read the Excel file into a DataFrame\n",
        "df = pd.read_excel('data.xlsx')\n",
        "\n",
        "# Print the DataFrame\n",
        "print(df)"
      ],
      "metadata": {
        "id": "IUDBynUK4IcC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**pd.readl_sql()**\n"
      ],
      "metadata": {
        "id": "QrsrbtXv9Nvb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import sqlite3\n",
        "\n",
        "# Create a connection to the database\n",
        "conn = sqlite3.connect('my_database.db')\n",
        "\n",
        "# Read the SQL query into a DataFrame\n",
        "df = pd.read_sql('SELECT * FROM users', conn)\n",
        "\n",
        "# Print the DataFrame\n",
        "print(df)"
      ],
      "metadata": {
        "id": "awdvq66-9m_T"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**pd.read_json()**\n"
      ],
      "metadata": {
        "id": "UWmzZAs3_lbv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "\n",
        "# Read the JSON file into a DataFrame\n",
        "df = pd.read_json('data.json')\n",
        "\n",
        "# Print the DataFrame\n",
        "print(df)"
      ],
      "metadata": {
        "id": "6k__j-CP_zZj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4.4-Data Statistics**"
      ],
      "metadata": {
        "id": "eLX-EUxMVo6P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**head()**\n"
      ],
      "metadata": {
        "id": "n7TS_Rr5WQy3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()"
      ],
      "metadata": {
        "id": "JLU_xWHQWVfv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**tail()**\n"
      ],
      "metadata": {
        "id": "HWIabHcgbP2I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.tail(5)"
      ],
      "metadata": {
        "id": "ErNChFSsbT2a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**shape()**\n"
      ],
      "metadata": {
        "id": "1vLm1i-pdMEG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.shape()"
      ],
      "metadata": {
        "id": "sNhGl5y2dQGP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**isnull()**\n"
      ],
      "metadata": {
        "id": "r2KbAVZxlLSY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.isnull().head()"
      ],
      "metadata": {
        "id": "__1ktE5VlFzx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**sum()**\n"
      ],
      "metadata": {
        "id": "FqwDwOKtlwsH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.isnull().sum()"
      ],
      "metadata": {
        "id": "stzmARX_lsu2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**info()**\n"
      ],
      "metadata": {
        "id": "cl-5gpFNrBF0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.info()"
      ],
      "metadata": {
        "id": "tlj4AAarrF77"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**describe()**\n"
      ],
      "metadata": {
        "id": "42YPI_QKrL2C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.describe()"
      ],
      "metadata": {
        "id": "Mm78GzBFrNoS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**mean()**"
      ],
      "metadata": {
        "id": "NG7kxaegvdI3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.mean()"
      ],
      "metadata": {
        "id": "qPXWhAh3vh9q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**median()**"
      ],
      "metadata": {
        "id": "cu-7f6co1tic"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.median()"
      ],
      "metadata": {
        "id": "W-n_sKqa1rCM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**std()**"
      ],
      "metadata": {
        "id": "iNy_ME3A5Hb0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.std()"
      ],
      "metadata": {
        "id": "oSak7V-V19KU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Count()**"
      ],
      "metadata": {
        "id": "6VbxfpSBC1wK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.count()"
      ],
      "metadata": {
        "id": "kuJ3L42b5BlL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Max()**"
      ],
      "metadata": {
        "id": "yKY1_wBSYMGb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.max()"
      ],
      "metadata": {
        "id": "4ZQ6a7VcYILT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Min()**"
      ],
      "metadata": {
        "id": "7kQtDE4Lkcfp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.min()"
      ],
      "metadata": {
        "id": "vL-0CwhLkW4i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Check if the data has any duplicate values using duplicated(). The sum() gives you the number of duplicate rows in the data frame"
      ],
      "metadata": {
        "id": "dYLWFTwdgLkP"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In order to see the duplicate rows, we can store the duplicated values inside a data frame."
      ],
      "metadata": {
        "id": "RKv3NX2FgQW4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "duplicate_rows = df[df.duplicated()]\n",
        "duplicate_rows"
      ],
      "metadata": {
        "id": "XlyXvu5ggRyf"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Duplicate values can be removed using drop_duplicates()"
      ],
      "metadata": {
        "id": "Uh-dxfWuinLW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "data = df.drop_duplicates(ignore_index=True)\n",
        "# ignore_index=True so that the index is relabeled"
      ],
      "metadata": {
        "id": "xhYJ_NmAipc-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4.5-Data Sorting**"
      ],
      "metadata": {
        "id": "KNgEuz_ziGF_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**df.sort_values()**"
      ],
      "metadata": {
        "id": "LW-f-NiztgGK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code sorts the DataFrame by the A column in ascending order:\n",
        "\n"
      ],
      "metadata": {
        "id": "VLQizPbItotx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()"
      ],
      "metadata": {
        "id": "lz07JANjtu6a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        " df = df.sort_values('sex')\n"
      ],
      "metadata": {
        "id": "BlyyYG2rtXxZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df"
      ],
      "metadata": {
        "id": "s3-Z6v-kt1pr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "The following code sorts the DataFrame by the B column in descending order:\n",
        "\n"
      ],
      "metadata": {
        "id": "wPrAwd2Kt9xb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df = df.sort_values('sex', ascending=False)\n"
      ],
      "metadata": {
        "id": "InxAZMpHt875"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **4.6- Inconsistent Data**"
      ],
      "metadata": {
        "id": "teu9rMFKmhCm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df.head()"
      ],
      "metadata": {
        "id": "3C_nyEj5CA_2"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['who'].unique()\n"
      ],
      "metadata": {
        "id": "eAirVg3QB4EG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "df['who'] = df['who'].str.lower()\n",
        "df['who'].unique()"
      ],
      "metadata": {
        "id": "vbEfnp0hCNVu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Whitespace issues:**"
      ],
      "metadata": {
        "id": "M6TlgUrVP0h8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "titanic_df['Name'] = titanic_df['Name'].str.strip()\n",
        "titanic_df['Name'].head()"
      ],
      "metadata": {
        "id": "jBereEVXPwAJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Inconsistent spelling:**"
      ],
      "metadata": {
        "id": "UpUgnL2rP5fY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's create a column with some inconsistencies for demonstration purposes\n",
        "titanic_df['Embarked'] = titanic_df['Embarked'].replace(['C', 'Q', 'S'], ['cherbourg', 'queenstown', 'southampton'])\n",
        "print(titanic_df['Embarked'].unique())"
      ],
      "metadata": {
        "id": "UN7Mx_DqP_Fs"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Fix Inconsistent Spelling**"
      ],
      "metadata": {
        "id": "pLyLBwXCQBYM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Standardize 'Embarked' column\n",
        "standardize_mapping = {\n",
        "    'cherbourg': 'Cherbourg',\n",
        "    'queenstown': 'Queenstown',\n",
        "    'southampton': 'Southampton'\n",
        "}\n",
        "titanic_df['Embarked'] = titanic_df['Embarked'].replace(standardize_mapping)\n",
        "print(titanic_df['Embarked'].unique())\n"
      ],
      "metadata": {
        "id": "sGPscxoNQJSG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Section-5 Data Visualization Using Pandas**"
      ],
      "metadata": {
        "id": "2GbwPtoKQjPS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "In the world of data science, visualization is key to understanding and communicating insights. One of the most powerful tools for data visualization in Python is Pandas."
      ],
      "metadata": {
        "id": "sYOaH5ZCQvvW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **5.1-Importing Libraries and Loading DataSet**"
      ],
      "metadata": {
        "id": "5hl-r-kzR1rW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Load the Titanic dataset\n",
        "titanic= sns.load_dataset('titanic')\n"
      ],
      "metadata": {
        "id": "tgKH-L_wR3pE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### **5.2-Basic Plotting with Pandas**"
      ],
      "metadata": {
        "id": "8nT2QVDiSMI6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Pandas has built-in plotting capabilities using Matplotlib"
      ],
      "metadata": {
        "id": "k-MH6T-bS4Ly"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Line Plot**"
      ],
      "metadata": {
        "id": "XfCNPgRVS41R"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A line plot is useful for visualizing trends over time. Suppose we want to visualize car sales over the years:"
      ],
      "metadata": {
        "id": "tLkMf08gTF19"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting average age by passenger class\n",
        "titanic.groupby('pclass')['age'].mean().plot(kind='line', title='Average Age by Passenger Class')\n",
        "plt.xlabel('Passenger Class')\n",
        "plt.ylabel('Average Age')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "i4KgPXvnTIR3"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "titanic['fare'].plot(kind='line', figsize=(10, 6))\n",
        "plt.title('Fare Prices')\n",
        "plt.xlabel('Passenger Index')\n",
        "plt.ylabel('Fare')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "dV93qMgZTX4g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Bar Plot**\n",
        "\n",
        "```\n",
        "# This is formatted as code\n",
        "```\n",
        "\n"
      ],
      "metadata": {
        "id": "x0rrXbz_TnZn"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Bar plots are great for comparing categorical data."
      ],
      "metadata": {
        "id": "NycsC_a7Tulq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting the number of survivors vs non-survivors\n",
        "titanic['survived'].value_counts().plot(kind='bar', title='Survival Counts', color=['skyblue', 'salmon'])\n",
        "plt.xlabel('Survived')\n",
        "plt.ylabel('Count')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "0QNLVj9RTtt1"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Bar Plot of Passenger Class Distribution\n",
        "titanic_df['pclass'].value_counts().plot(kind='bar', color='skyblue')\n",
        "plt.title('Passenger Class Distribution')\n",
        "plt.xlabel('Class')\n",
        "plt.ylabel('Number of Passengers')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "lMtAKmK-T61m"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Histogram**"
      ],
      "metadata": {
        "id": "0sgdSzeGUHkH"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Histograms are useful for understanding the distribution of a numerical variable."
      ],
      "metadata": {
        "id": "PX5EeF4yULVn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting the distribution of passenger age\n",
        "titanic['age'].plot(kind='hist', title='Distribution of Passenger Age', bins=20, color='skyblue')\n",
        "plt.xlabel('Age')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "kgosPIvdUUSb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Scatter Plot**"
      ],
      "metadata": {
        "id": "cIR7isd5UkPV"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Scatter plots help in identifying relationships between two numerical variables"
      ],
      "metadata": {
        "id": "4cBNhnQLUn4b"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Plotting the relationship between fare and age\n",
        "titanic.plot(kind='scatter', x='fare', y='age', title='Fare vs Age')\n",
        "plt.xlabel('Fare')\n",
        "plt.ylabel('Age')\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "TnJJnd0fUp2D"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Area Plot**"
      ],
      "metadata": {
        "id": "JrFxFLMgUzfZ"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Area plots are useful for showing cumulative totals over time."
      ],
      "metadata": {
        "id": "2qSNeK31U4Yu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Select numerical columns\n",
        "numerical_cols = ['age', 'fare', 'pclass']\n",
        "\n",
        "# Drop rows with missing values in these columns to avoid plotting issues\n",
        "titanic_numerical = titanic[numerical_cols].dropna()\n",
        "\n",
        "# Create the area plot\n",
        "titanic_numerical.plot.area(alpha=0.5)\n",
        "plt.title('Area Plot of Selected Numerical Features')\n",
        "plt.xlabel('Index')\n",
        "plt.ylabel('Value')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "itPxWRjgU65E"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Box Plot**"
      ],
      "metadata": {
        "id": "HlXDU7j2VtEM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Box plots are useful for showing the distribution of data based on a five-number summary."
      ],
      "metadata": {
        "id": "c3SkIWcTVw2D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "titanic.plot.box()"
      ],
      "metadata": {
        "id": "NL73S0raV2KN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### **Hexagonal binning Plot**"
      ],
      "metadata": {
        "id": "u71eJgiwWBHl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Hexbin plots are useful for visualizing the density of points in a scatter plot"
      ],
      "metadata": {
        "id": "Fh2m3OuiWC1c"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Ensure the columns 'Age' and 'Fare' have no missing values for the plot\n",
        "titanic= titanic[['age', 'fare']].dropna()\n",
        "\n",
        "# Create the hexbin plot\n",
        "titanic_df.plot.hexbin(x='age', y='fare', gridsize=30, cmap='viridis')\n",
        "plt.title('Hexbin Plot of Age vs Fare')\n",
        "plt.xlabel('Age')\n",
        "plt.ylabel('Fare')\n",
        "plt.show()\n"
      ],
      "metadata": {
        "id": "zsg_uqlOWLcV"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}