{ "cells": [ { "cell_type": "markdown", "metadata": { "id": "rQ8UhzFpgRra" }, "source": [ "# ਡਾਟਾ ਤਿਆਰੀ\n", "\n", "[ਅਸਲ ਨੋਟਬੁੱਕ ਸਰੋਤ *ਡਾਟਾ ਸਾਇੰਸ: ਪਾਇਥਨ ਅਤੇ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਸਟੂਡੀਓ ਲਈ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਦਾ ਪਰਿਚਯ ਲੀ ਸਟੌਟ ਦੁਆਰਾ*](https://github.com/leestott/intro-Datascience/blob/master/Course%20Materials/4-Cleaning_and_Manipulating-Reference.ipynb)\n", "\n", "## `DataFrame` ਜਾਣਕਾਰੀ ਦੀ ਖੋਜ\n", "\n", "> **ਸਿੱਖਣ ਦਾ ਉਦੇਸ਼:** ਇਸ ਉਪਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਸੀਂ pandas DataFrames ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਡਾਟਾ ਬਾਰੇ ਆਮ ਜਾਣਕਾਰੀ ਲੱਭਣ ਵਿੱਚ ਸਹੂਲਤ ਮਹਿਸੂਸ ਕਰੋਗੇ।\n", "\n", "ਜਦੋਂ ਤੁਸੀਂ pandas ਵਿੱਚ ਆਪਣਾ ਡਾਟਾ ਲੋਡ ਕਰ ਲੈਂਦੇ ਹੋ, ਤਾਂ ਇਹ ਜ਼ਿਆਦਾਤਰ `DataFrame` ਵਿੱਚ ਹੋਵੇਗਾ। ਹਾਲਾਂਕਿ, ਜੇ ਤੁਹਾਡੇ `DataFrame` ਵਿੱਚ 60,000 ਪੰਕਤਾਂ ਅਤੇ 400 ਕਾਲਮ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਸ਼ੁਰੂਆਤ ਕਿਵੇਂ ਕਰਦੇ ਹੋ? ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, pandas ਕੁਝ ਸਹੂਲਤਮੰਦ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ `DataFrame` ਬਾਰੇ ਕੁੱਲ ਜਾਣਕਾਰੀ ਦੇਖਣ ਦੇ ਨਾਲ-साथ ਪਹਿਲੀਆਂ ਕੁਝ ਅਤੇ ਆਖਰੀ ਕੁਝ ਪੰਕਤਾਂ ਨੂੰ ਤੇਜ਼ੀ ਨਾਲ ਦੇਖਣ ਦੀ ਸਹੂਲਤ ਦਿੰਦੇ ਹਨ।\n", "\n", "ਇਸ ਫੰਕਸ਼ਨਲਿਟੀ ਦੀ ਖੋਜ ਕਰਨ ਲਈ, ਅਸੀਂ ਪਾਇਥਨ scikit-learn ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਇੰਪੋਰਟ ਕਰਾਂਗੇ ਅਤੇ ਇੱਕ ਪ੍ਰਸਿੱਧ ਡਾਟਾਸੈਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ ਜੋ ਹਰ ਡਾਟਾ ਸਾਇੰਟਿਸਟ ਨੇ ਸੈਂਕੜੇ ਵਾਰ ਦੇਖਿਆ ਹੈ: ਬ੍ਰਿਟਿਸ਼ ਜੀਵ ਵਿਗਿਆਨੀ ਰੋਨਾਲਡ ਫਿਸ਼ਰ ਦਾ *Iris* ਡਾਟਾ ਸੈੱਟ ਜੋ ਉਸਦੇ 1936 ਦੇ ਪੇਪਰ \"The use of multiple measurements in taxonomic problems\" ਵਿੱਚ ਵਰਤਿਆ ਗਿਆ ਸੀ:\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "collapsed": true, "id": "hB1RofhdgRrp", "trusted": false }, "outputs": [], "source": [ "import pandas as pd\n", "from sklearn.datasets import load_iris\n", "\n", "iris = load_iris()\n", "iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])" ] }, { "cell_type": "markdown", "metadata": { "id": "AGA0A_Y8hMdz" }, "source": [ "### `DataFrame.shape`\n", "ਅਸੀਂ `iris_df` ਵਿੱਚ ਆਇਰਿਸ ਡੇਟਾਸੈੱਟ ਲੋਡ ਕੀਤਾ ਹੈ। ਡੇਟਾ ਵਿੱਚ ਡੁੱਬਣ ਤੋਂ ਪਹਿਲਾਂ, ਇਹ ਜਾਣਨਾ ਮੁਲਵਾਨ ਹੋਵੇਗਾ ਕਿ ਸਾਡੇ ਕੋਲ ਕਿੰਨੇ ਡੇਟਾਪੋਇੰਟ ਹਨ ਅਤੇ ਡੇਟਾਸੈੱਟ ਦਾ ਕੁੱਲ ਆਕਾਰ ਕੀ ਹੈ। ਇਹ ਦੇਖਣਾ ਲਾਭਦਾਇਕ ਹੈ ਕਿ ਅਸੀਂ ਕਿੰਨੇ ਡੇਟਾ ਦੀ ਮਾਤਰਾ ਨਾਲ ਨਿਪਟ ਰਹੇ ਹਾਂ।\n" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LOe5jQohhulf", "outputId": "fb0577ac-3b4a-4623-cb41-20e1b264b3e9" }, "outputs": [ { "data": { "text/plain": [ "(150, 4)" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.shape" ] }, { "cell_type": "markdown", "metadata": { "id": "smE7AGzOhxk2" }, "source": [ "ਅਸੀਂ 150 ਪੰਗਤਾਂ ਅਤੇ 4 ਕਤਾਰਾਂ ਦੇ ਡਾਟਾ ਨਾਲ ਨਿਪਟ ਰਹੇ ਹਾਂ। ਹਰ ਪੰਗਤੀ ਇੱਕ ਡਾਟਾਪੌਇੰਟ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਅਤੇ ਹਰ ਕਤਾਰ ਡਾਟਾ ਫਰੇਮ ਨਾਲ ਜੁੜੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ। ਇਸ ਲਈ, ਮੁਢਲੇ ਤੌਰ 'ਤੇ 150 ਡਾਟਾਪੌਇੰਟ ਹਨ, ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਹਰ ਇੱਕ ਵਿੱਚ 4 ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ।\n", "\n", "`shape` ਇੱਥੇ ਡਾਟਾ ਫਰੇਮ ਦਾ ਇੱਕ ਗੁਣ ਹੈ ਅਤੇ ਇੱਕ ਫੰਕਸ਼ਨ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਇਹ ਇੱਕ ਜੋੜੇ ਕੋਠੇ ਨਾਲ ਖਤਮ ਨਹੀਂ ਹੁੰਦਾ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "d3AZKs0PinGP" }, "source": [ "### `DataFrame.columns`\n", "ਹੁਣ ਆਓ ਡਾਟਾ ਦੀਆਂ 4 ਕਾਲਮਾਂ ਵੱਲ ਧਿਆਨ ਦਈਏ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਹਰ ਇੱਕ ਕਾਲਮ ਕੀ ਦਰਸਾਉਂਦੀ ਹੈ? `columns` ਐਟ੍ਰਿਬਿਊਟ ਸਾਨੂੰ ਡਾਟਾਫ੍ਰੇਮ ਵਿੱਚ ਕਾਲਮਾਂ ਦੇ ਨਾਮ ਦਿਖਾਏਗੀ।\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "YPGh_ziji-CY", "outputId": "74e7a43a-77cc-4c80-da56-7f50767c37a0" }, "outputs": [ { "data": { "text/plain": [ "Index(['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)',\n", " 'petal width (cm)'],\n", " dtype='object')" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.columns" ] }, { "cell_type": "markdown", "metadata": { "id": "TsobcU_VjCC_" }, "source": [ "ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਇੱਥੇ ਚਾਰ (4) ਕਾਲਮ ਹਨ। `columns` ਗੁਣਵੱਤਾ ਸਾਨੂੰ ਕਾਲਮਾਂ ਦੇ ਨਾਮ ਦੱਸਦੀ ਹੈ ਅਤੇ ਮੁਢਲੀ ਤੌਰ 'ਤੇ ਹੋਰ ਕੁਝ ਨਹੀਂ। ਇਹ ਗੁਣਵੱਤਾ ਉਸ ਸਮੇਂ ਮਹੱਤਵਪੂਰਨ ਹੋ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਅਸੀਂ ਪਤਾ ਲਗਾਉਣਾ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਇੱਕ ਡਾਟਾਸੈੱਟ ਵਿੱਚ ਕਿਹੜੇ ਫੀਚਰ ਹਨ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "2UTlvkjmgRrs" }, "source": [ "### `DataFrame.info`\n", "ਡਾਟਾ ਦੀ ਮਾਤਰਾ (`shape` ਗੁਣ) ਅਤੇ ਫੀਚਰਾਂ ਜਾਂ ਕਾਲਮਾਂ ਦੇ ਨਾਮ (`columns` ਗੁਣ) ਸਾਨੂੰ ਡਾਟਾਸੈੱਟ ਬਾਰੇ ਕੁਝ ਦੱਸਦੇ ਹਨ। ਹੁਣ, ਅਸੀਂ ਡਾਟਾਸੈੱਟ ਵਿੱਚ ਹੋਰ ਗਹਿਰਾਈ ਨਾਲ ਜਾਣਾ ਚਾਹੁੰਦੇ ਹਾਂ। `DataFrame.info()` ਫੰਕਸ਼ਨ ਇਸ ਲਈ ਕਾਫੀ ਲਾਭਦਾਇਕ ਹੈ।\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "dHHRyG0_gRrt", "outputId": "d8fb0c40-4f18-4e19-da48-c8db77d1d3a5", "trusted": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "RangeIndex: 150 entries, 0 to 149\n", "Data columns (total 4 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 sepal length (cm) 150 non-null float64\n", " 1 sepal width (cm) 150 non-null float64\n", " 2 petal length (cm) 150 non-null float64\n", " 3 petal width (cm) 150 non-null float64\n", "dtypes: float64(4)\n", "memory usage: 4.8 KB\n" ] } ], "source": [ "iris_df.info()" ] }, { "cell_type": "markdown", "metadata": { "id": "1XgVMpvigRru" }, "source": [ "ਇਥੋਂ, ਅਸੀਂ ਕੁਝ ਨਿਰੀਖਣ ਕਰ ਸਕਦੇ ਹਾਂ: \n", "1. ਹਰ ਕਾਲਮ ਦਾ ਡਾਟਾ ਟਾਈਪ: ਇਸ ਡਾਟਾਸੈੱਟ ਵਿੱਚ, ਸਾਰਾ ਡਾਟਾ 64-ਬਿਟ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਨੰਬਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈ। \n", "2. ਨਾਨ-ਨੱਲ ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ: ਨੱਲ ਮੁੱਲਾਂ ਨਾਲ ਨਜਿੱਠਣਾ ਡਾਟਾ ਤਿਆਰੀ ਵਿੱਚ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ। ਇਸ ਨਾਲ ਨੋਟਬੁੱਕ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਨਜਿੱਠਿਆ ਜਾਵੇਗਾ। \n" ] }, { "cell_type": "markdown", "metadata": { "id": "IYlyxbpWFEF4" }, "source": [ "### DataFrame.describe()\n", "ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਡਾਟਾਸੈਟ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਸੰਖਿਆਤਮਕ ਡਾਟਾ ਹੈ। ਹਰ ਕਾਲਮ 'ਤੇ ਵੱਖ-ਵੱਖ ਤਰ੍ਹਾਂ ਦੇ ਅੰਕਗਣਿਤ ਗਣਨਾ ਜਿਵੇਂ ਕਿ ਔਸਤ, ਮੱਧਕ, ਚੌਥਾਈ ਆਦਿ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। `DataFrame.describe()` ਫੰਕਸ਼ਨ ਸਾਨੂੰ ਡਾਟਾਸੈਟ ਦੇ ਸੰਖਿਆਤਮਕ ਕਾਲਮਾਂ ਦੀ ਅੰਕਗਣਿਤ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 297 }, "id": "tWV-CMstFIRA", "outputId": "4fc49941-bc13-4b0c-a412-cb39e7d3f289" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
count150.000000150.000000150.000000150.000000
mean5.8433333.0573333.7580001.199333
std0.8280660.4358661.7652980.762238
min4.3000002.0000001.0000000.100000
25%5.1000002.8000001.6000000.300000
50%5.8000003.0000004.3500001.300000
75%6.4000003.3000005.1000001.800000
max7.9000004.4000006.9000002.500000
\n", "
" ], "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "count 150.000000 150.000000 150.000000 150.000000\n", "mean 5.843333 3.057333 3.758000 1.199333\n", "std 0.828066 0.435866 1.765298 0.762238\n", "min 4.300000 2.000000 1.000000 0.100000\n", "25% 5.100000 2.800000 1.600000 0.300000\n", "50% 5.800000 3.000000 4.350000 1.300000\n", "75% 6.400000 3.300000 5.100000 1.800000\n", "max 7.900000 4.400000 6.900000 2.500000" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.describe()" ] }, { "cell_type": "markdown", "metadata": { "id": "zjjtW5hPGMuM" }, "source": [ "ਉਪਰੋਕਤ ਆਉਟਪੁੱਟ ਹਰ ਕਾਲਮ ਦੇ ਕੁੱਲ ਡਾਟਾ ਪੌਇੰਟਸ, ਔਸਤ, ਮਿਆਰੀ ਵਿਸਥਾਪਨ, ਘੱਟੋ-ਘੱਟ, ਹੇਠਲਾ ਚੌਥਾਈ (25%), ਮੱਧ (50%), ਉੱਪਰਲਾ ਚੌਥਾਈ (75%) ਅਤੇ ਵੱਧ ਤੋਂ ਵੱਧ ਮੁੱਲ ਦਿਖਾਉਂਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "-lviAu99gRrv" }, "source": [ "### `DataFrame.head`\n", "ਉਪਰੋਕਤ ਸਾਰੇ ਫੰਕਸ਼ਨ ਅਤੇ ਗੁਣਾਂ ਨਾਲ, ਸਾਨੂੰ ਡਾਟਾਸੈਟ ਦੀ ਇੱਕ ਉੱਚ ਪੱਧਰੀ ਝਲਕ ਮਿਲ ਗਈ ਹੈ। ਸਾਨੂੰ ਪਤਾ ਹੈ ਕਿ ਕਿੰਨੇ ਡਾਟਾ ਪੌਇੰਟ ਹਨ, ਕਿੰਨੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ, ਹਰ ਵਿਸ਼ੇਸ਼ਤਾ ਦਾ ਡਾਟਾ ਟਾਈਪ ਕੀ ਹੈ ਅਤੇ ਹਰ ਵਿਸ਼ੇਸ਼ਤਾ ਲਈ ਗੈਰ-ਨੱਲ ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ ਕੀ ਹੈ।\n", "\n", "ਹੁਣ ਸਮਾਂ ਹੈ ਕਿ ਅਸਲ ਡਾਟਾ ਨੂੰ ਦੇਖਣ ਦਾ। ਆਓ ਵੇਖੀਏ ਕਿ ਸਾਡੇ `DataFrame` ਦੀਆਂ ਪਹਿਲੀਆਂ ਕੁਝ ਪੰਗਤਾਂ (ਪਹਿਲੇ ਕੁਝ ਡਾਟਾ ਪੌਇੰਟ) ਕਿਵੇਂ ਦਿਖਦੀਆਂ ਹਨ:\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "DZMJZh0OgRrw", "outputId": "d9393ee5-c106-4797-f815-218f17160e00", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
05.13.51.40.2
14.93.01.40.2
24.73.21.30.2
34.63.11.50.2
45.03.61.40.2
\n", "
" ], "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "0 5.1 3.5 1.4 0.2\n", "1 4.9 3.0 1.4 0.2\n", "2 4.7 3.2 1.3 0.2\n", "3 4.6 3.1 1.5 0.2\n", "4 5.0 3.6 1.4 0.2" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.head()" ] }, { "cell_type": "markdown", "metadata": { "id": "EBHEimZuEFQK" }, "source": [ "ਜਿਵੇਂ ਕਿ ਇੱਥੇ ਆਉਟਪੁੱਟ ਵਿੱਚ, ਅਸੀਂ ਡੇਟਾਸੈੱਟ ਦੇ ਪੰਜ (5) ਐਂਟਰੀਜ਼ ਦੇਖ ਸਕਦੇ ਹਾਂ। ਜੇ ਅਸੀਂ ਖੱਬੇ ਪਾਸੇ ਇੰਡੈਕਸ ਨੂੰ ਵੇਖੀਏ, ਤਾਂ ਪਤਾ ਲਗਦਾ ਹੈ ਕਿ ਇਹ ਪਹਿਲੀਆਂ ਪੰਜ ਪੰਗਤਾਂ ਹਨ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "oj7GkrTdgRry" }, "source": [ "### ਕਸਰਤ:\n", "\n", "ਉਪਰ ਦਿੱਤੇ ਉਦਾਹਰਨ ਤੋਂ ਸਪਸ਼ਟ ਹੈ ਕਿ ਮੂਲ ਰੂਪ ਵਿੱਚ, `DataFrame.head` ਇੱਕ `DataFrame` ਦੇ ਪਹਿਲੇ ਪੰਜ ਪੰਨੇ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਹੇਠਾਂ ਦਿੱਤੇ ਕੋਡ ਸੈਲ ਵਿੱਚ, ਕੀ ਤੁਸੀਂ ਪੰਜ ਤੋਂ ਵੱਧ ਪੰਨਿਆਂ ਨੂੰ ਦਿਖਾਉਣ ਦਾ ਕੋਈ ਤਰੀਕਾ ਲੱਭ ਸਕਦੇ ਹੋ?\n" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "collapsed": true, "id": "EKRmRFFegRrz", "trusted": false }, "outputs": [], "source": [ "# Hint: Consult the documentation by using iris_df.head?" ] }, { "cell_type": "markdown", "metadata": { "id": "BJ_cpZqNgRr1" }, "source": [ "### `DataFrame.tail`\n", "ਡਾਟਾ ਨੂੰ ਦੇਖਣ ਦਾ ਇੱਕ ਹੋਰ ਤਰੀਕਾ ਅੰਤ ਤੋਂ ਹੋ ਸਕਦਾ ਹੈ (ਸ਼ੁਰੂਆਤ ਦੀ ਬਜਾਏ)। `DataFrame.head` ਦਾ ਉਲਟ `DataFrame.tail` ਹੈ, ਜੋ ਕਿ `DataFrame` ਦੀਆਂ ਆਖਰੀ ਪੰਜ ਪੰਗਤਾਂ ਵਾਪਸ ਕਰਦਾ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 0 }, "id": "heanjfGWgRr2", "outputId": "6ae09a21-fe09-4110-b0d7-1a1fbf34d7f3", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
sepal length (cm)sepal width (cm)petal length (cm)petal width (cm)
1456.73.05.22.3
1466.32.55.01.9
1476.53.05.22.0
1486.23.45.42.3
1495.93.05.11.8
\n", "
" ], "text/plain": [ " sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)\n", "145 6.7 3.0 5.2 2.3\n", "146 6.3 2.5 5.0 1.9\n", "147 6.5 3.0 5.2 2.0\n", "148 6.2 3.4 5.4 2.3\n", "149 5.9 3.0 5.1 1.8" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris_df.tail()" ] }, { "cell_type": "markdown", "metadata": { "id": "31kBWfyLgRr3" }, "source": [ "ਅਮਲ ਵਿੱਚ, ਇਹ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਕਿ `DataFrame` ਦੇ ਪਹਿਲੇ ਕੁ ਪੰਨਿਆਂ ਜਾਂ ਆਖਰੀ ਕੁ ਪੰਨਿਆਂ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਦੇਖਿਆ ਜਾ ਸਕੇ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਤੁਸੀਂ ਕ੍ਰਮਬੱਧ ਡਾਟਾਸੈਟ ਵਿੱਚ ਅਸਧਾਰਨ ਮੁੱਲਾਂ ਦੀ ਭਾਲ ਕਰ ਰਹੇ ਹੋ। \n", "\n", "ਉਪਰ ਦਿੱਤੇ ਸਾਰੇ ਫੰਕਸ਼ਨ ਅਤੇ ਗੁਣ, ਜਿਨ੍ਹਾਂ ਨੂੰ ਕੋਡ ਉਦਾਹਰਣਾਂ ਦੀ ਮਦਦ ਨਾਲ ਦਰਸਾਇਆ ਗਿਆ ਹੈ, ਸਾਨੂੰ ਡਾਟਾ ਦੇ ਦ੍ਰਿਸ਼ ਅਤੇ ਅਹਿਸਾਸ ਪ੍ਰਾਪਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ। \n", "\n", "> **ਮੁੱਖ ਗੱਲ:** ਸਿਰਫ `DataFrame` ਵਿੱਚ ਮੌਜੂਦ ਜਾਣਕਾਰੀ ਬਾਰੇ ਮੈਟਾਡਾਟਾ ਜਾਂ ਪਹਿਲੇ ਅਤੇ ਆਖਰੀ ਕੁ ਮੁੱਲਾਂ ਨੂੰ ਦੇਖ ਕੇ ਹੀ, ਤੁਸੀਂ ਉਸ ਡਾਟਾ ਦੇ ਆਕਾਰ, ਰੂਪ ਅਤੇ ਸਮੱਗਰੀ ਬਾਰੇ ਤੁਰੰਤ ਧਾਰਨਾ ਲਗਾ ਸਕਦੇ ਹੋ ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਨਿਪਟ ਰਹੇ ਹੋ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "TvurZyLSDxq_" }, "source": [ "### ਗੁੰਮ ਡਾਟਾ\n", "ਆਓ ਗੁੰਮ ਡਾਟਾ ਬਾਰੇ ਜਾਣਕਾਰੀ ਲਵਾਂ। ਗੁੰਮ ਡਾਟਾ ਉਹਨਾਂ ਹਾਲਾਤਾਂ ਵਿੱਚ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਕੁਝ ਕਾਲਮਾਂ ਵਿੱਚ ਕੋਈ ਵੀ ਮੁੱਲ ਸਟੋਰ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ।\n", "\n", "ਆਓ ਇੱਕ ਉਦਾਹਰਨ ਲਵਾਂ: ਮੰਨੋ ਕਿ ਕੋਈ ਵਿਅਕਤੀ ਆਪਣੇ ਵਜ਼ਨ ਨੂੰ ਲੈ ਕੇ ਚਿੰਤਤ ਹੈ ਅਤੇ ਸਰਵੇ ਵਿੱਚ ਵਜ਼ਨ ਵਾਲਾ ਖੇਤਰ ਨਹੀਂ ਭਰਦਾ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਉਸ ਵਿਅਕਤੀ ਲਈ ਵਜ਼ਨ ਦਾ ਮੁੱਲ ਗੁੰਮ ਹੋਵੇਗਾ।\n", "\n", "ਅਕਸਰ, ਅਸਲ ਦੁਨੀਆ ਦੇ ਡਾਟਾਸੈਟਾਂ ਵਿੱਚ, ਗੁੰਮ ਮੁੱਲ ਮਿਲਦੇ ਹਨ।\n", "\n", "**Pandas ਗੁੰਮ ਡਾਟਾ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦਾ ਹੈ**\n", "\n", "Pandas ਗੁੰਮ ਮੁੱਲਾਂ ਨੂੰ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ। ਪਹਿਲਾ ਤਰੀਕਾ, ਜਿਸਨੂੰ ਤੁਸੀਂ ਪਹਿਲੇ ਸੈਕਸ਼ਨਾਂ ਵਿੱਚ ਦੇਖਿਆ ਹੈ: `NaN`, ਜਾਂ Not a Number। ਇਹ ਵਾਸਤਵ ਵਿੱਚ IEEE ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਸਪੈਸਿਫਿਕੇਸ਼ਨ ਦਾ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਹੈ ਅਤੇ ਇਹ ਸਿਰਫ ਗੁੰਮ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।\n", "\n", "ਫਲੋਟਾਂ ਤੋਂ ਇਲਾਵਾ ਗੁੰਮ ਮੁੱਲਾਂ ਲਈ, pandas Python ਦੇ `None` ਆਬਜੈਕਟ ਨੂੰ ਵਰਤਦਾ ਹੈ। ਜਦੋਂ ਕਿ ਇਹ ਥੋੜਾ ਜਿਹਾ ਗੁੰਝਲਦਾਰ ਲੱਗ ਸਕਦਾ ਹੈ ਕਿ ਤੁਹਾਨੂੰ ਦੋ ਵੱਖ-ਵੱਖ ਕਿਸਮ ਦੇ ਮੁੱਲ ਮਿਲਣਗੇ ਜੋ ਅਸਲ ਵਿੱਚ ਇੱਕੋ ਹੀ ਗੱਲ ਕਹਿੰਦੇ ਹਨ, ਇਸ ਡਿਜ਼ਾਈਨ ਚੋਣ ਦੇ ਪਿੱਛੇ ਵਾਜਬ ਕਾਰਨ ਹਨ। ਅਮਲ ਵਿੱਚ, ਇਸ ਤਰੀਕੇ ਨਾਲ pandas ਨੂੰ ਜ਼ਿਆਦਾਤਰ ਹਾਲਾਤਾਂ ਲਈ ਇੱਕ ਵਧੀਆ ਸਮਝੌਤਾ ਪੇਸ਼ ਕਰਨ ਦੀ ਯੋਗਤਾ ਮਿਲਦੀ ਹੈ। ਇਸਦੇ ਬਾਵਜੂਦ, `None` ਅਤੇ `NaN` ਦੋਵੇਂ ਵਿੱਚ ਕੁਝ ਪਾਬੰਦੀਆਂ ਹੁੰਦੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਹਾਨੂੰ ਇਹ ਸਮਝਣ ਦੀ ਲੋੜ ਹੈ ਕਿ ਇਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "lOHqUlZFgRr5" }, "source": [ "### `None`: ਗੈਰ-ਫਲੋਟ ਗੁੰਮ ਹੋਇਆ ਡਾਟਾ\n", "ਕਿਉਂਕਿ `None` ਪਾਇਥਨ ਤੋਂ ਆਉਂਦਾ ਹੈ, ਇਸਨੂੰ NumPy ਅਤੇ pandas ਐਰੇਜ਼ ਵਿੱਚ ਵਰਤਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਜੋ ਡਾਟਾ ਟਾਈਪ `'object'` ਨਹੀਂ ਹਨ। ਯਾਦ ਰੱਖੋ, NumPy ਐਰੇਜ਼ (ਅਤੇ pandas ਵਿੱਚ ਡਾਟਾ ਸਟ੍ਰਕਚਰ) ਸਿਰਫ ਇੱਕ ਹੀ ਕਿਸਮ ਦੇ ਡਾਟਾ ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹਨ। ਇਹੀ ਗੁਣ ਉਨ੍ਹਾਂ ਨੂੰ ਵੱਡੇ ਪੱਧਰ ਦੇ ਡਾਟਾ ਅਤੇ ਗਣਨਾਤਮਕ ਕੰਮ ਲਈ ਬੇਹਤਰੀਨ ਤਾਕਤ ਦਿੰਦਾ ਹੈ, ਪਰ ਇਹ ਉਨ੍ਹਾਂ ਦੀ ਲਚਕਤਾ ਨੂੰ ਵੀ ਸੀਮਿਤ ਕਰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਦੇ ਐਰੇਜ਼ ਨੂੰ \"ਸਭ ਤੋਂ ਘੱਟ ਸਾਂਝੇ ਗੁਣਕ\" ਵੱਲ ਅਪਕਾਸਟ ਕਰਨਾ ਪੈਂਦਾ ਹੈ, ਜੋ ਡਾਟਾ ਟਾਈਪ ਐਰੇ ਵਿੱਚ ਹਰ ਚੀਜ਼ ਨੂੰ ਸ਼ਾਮਲ ਕਰ ਸਕੇ। ਜਦੋਂ `None` ਐਰੇ ਵਿੱਚ ਹੁੰਦਾ ਹੈ, ਇਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਪਾਇਥਨ ਆਬਜੈਕਟਸ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ।\n", "\n", "ਇਸਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖਣ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਉਦਾਹਰਨ ਐਰੇ ਨੂੰ ਵੇਖੋ (ਇਸਦਾ `dtype` ਨੋਟ ਕਰੋ):\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "QIoNdY4ngRr7", "outputId": "92779f18-62f4-4a03-eca2-e9a101604336", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "array([2, None, 6, 8], dtype=object)" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "\n", "example1 = np.array([2, None, 6, 8])\n", "example1" ] }, { "cell_type": "markdown", "metadata": { "id": "pdlgPNbhgRr7" }, "source": [ "ਅੱਪਕਾਸਟ ਡਾਟਾ ਟਾਈਪਸ ਦੀ ਹਕੀਕਤ ਨਾਲ ਦੋ ਪਾਸੇ ਪ੍ਰਭਾਵ ਜੁੜੇ ਹੋਏ ਹਨ। ਪਹਿਲਾਂ, ਕਾਰਵਾਈਆਂ ਵਿਆਖਿਆ ਕੀਤੇ ਗਏ Python ਕੋਡ ਦੇ ਪੱਧਰ 'ਤੇ ਕੀਤੀਆਂ ਜਾਣਗੀਆਂ, ਨਾ ਕਿ ਕੰਪਾਇਲ ਕੀਤੇ NumPy ਕੋਡ ਦੇ ਪੱਧਰ 'ਤੇ। ਅਸਲ ਵਿੱਚ, ਇਸਦਾ ਮਤਲਬ ਇਹ ਹੈ ਕਿ ਜੇ `Series` ਜਾਂ `DataFrames` ਵਿੱਚ `None` ਸ਼ਾਮਲ ਹੈ, ਤਾਂ ਉਨ੍ਹਾਂ ਨਾਲ ਜੁੜੀਆਂ ਕਾਰਵਾਈਆਂ ਹੌਲੀ ਹੋਣਗੀਆਂ। ਹਾਲਾਂਕਿ ਤੁਸੀਂ ਸ਼ਾਇਦ ਇਸ ਪ੍ਰਦਰਸ਼ਨ ਵਿੱਚ ਘਾਟ ਨੂੰ ਮਹਿਸੂ ਨਾ ਕਰੋ, ਵੱਡੇ ਡਾਟਾਸੈਟਸ ਲਈ ਇਹ ਇੱਕ ਸਮੱਸਿਆ ਬਣ ਸਕਦੀ ਹੈ।\n", "\n", "ਦੂਜਾ ਪਾਸਾ ਪ੍ਰਭਾਵ ਪਹਿਲੇ ਤੋਂ ਉਤਪੰਨ ਹੁੰਦਾ ਹੈ। ਕਿਉਂਕਿ `None` ਅਸਲ ਵਿੱਚ `Series` ਜਾਂ `DataFrame`s ਨੂੰ ਵੈਨਿਲਾ Python ਦੀ ਦੁਨੀਆ ਵਿੱਚ ਵਾਪਸ ਖਿੱਚ ਲੈਂਦਾ ਹੈ, ਇਸ ਲਈ ਜੇਕਰ NumPy/pandas ਐਗਰੀਗੇਸ਼ਨ ਜਿਵੇਂ ਕਿ `sum()` ਜਾਂ `min()` ਨੂੰ ਉਹਨਾਂ ਐਰੇਜ਼ 'ਤੇ ਲਾਗੂ ਕੀਤਾ ਜਾਵੇ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ``None`` ਮੁੱਲ ਸ਼ਾਮਲ ਹੈ, ਤਾਂ ਆਮ ਤੌਰ 'ਤੇ ਇੱਕ ਗਲਤੀ ਪੈਦਾ ਹੋਵੇਗੀ:\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 292 }, "id": "gWbx-KB9gRr8", "outputId": "ecba710a-22ec-41d5-a39c-11f67e645b50", "trusted": false }, "outputs": [ { "ename": "TypeError", "evalue": "ignored", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mexample1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;32m/usr/local/lib/python3.7/dist-packages/numpy/core/_methods.py\u001b[0m in \u001b[0;36m_sum\u001b[0;34m(a, axis, dtype, out, keepdims, initial, where)\u001b[0m\n\u001b[1;32m 45\u001b[0m def _sum(a, axis=None, dtype=None, out=None, keepdims=False,\n\u001b[1;32m 46\u001b[0m initial=_NoValue, where=True):\n\u001b[0;32m---> 47\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mumr_sum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mout\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkeepdims\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minitial\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwhere\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 48\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m def _prod(a, axis=None, dtype=None, out=None, keepdims=False,\n", "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'NoneType'" ] } ], "source": [ "example1.sum()" ] }, { "cell_type": "markdown", "metadata": { "id": "LcEwO8UogRr9" }, "source": [ "**ਮੁੱਖ ਨਿਸ਼ਕਰਸ਼**: ਪੂਰਨ ਅੰਕਾਂ ਅਤੇ `None` ਮੁੱਲਾਂ ਦੇ ਵਿਚਕਾਰ ਜੋੜ (ਅਤੇ ਹੋਰ ਕਿਰਿਆਵਾਂ) ਅਨਿਰਧਾਰਿਤ ਹੈ, ਜੋ ਉਹਨਾਂ ਡੇਟਾਸੈਟਾਂ ਨਾਲ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਕੰਮਾਂ ਨੂੰ ਸੀਮਿਤ ਕਰ ਸਕਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "pWvVHvETgRr9" }, "source": [ "### `NaN`: ਗੁੰਮ ਹੋਏ ਫਲੋਟ ਮੁੱਲ\n", "\n", "`None` ਦੇ ਵਿਰੁੱਧ, NumPy (ਅਤੇ ਇਸ ਲਈ pandas) ਆਪਣੇ ਤੇਜ਼, ਵੇਕਟਰਾਈਜ਼ਡ ਓਪਰੇਸ਼ਨ ਅਤੇ ufuncs ਲਈ `NaN` ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਖਰਾਬ ਖਬਰ ਇਹ ਹੈ ਕਿ `NaN` 'ਤੇ ਕੀਤੇ ਗਏ ਕਿਸੇ ਵੀ ਅੰਕਗਣਿਤ ਕਾਰਜ ਦਾ ਨਤੀਜਾ ਹਮੇਸ਼ਾ `NaN` ਹੀ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਣ ਲਈ:\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "rcFYfMG9gRr9", "outputId": "699e81b7-5c11-4b46-df1d-06071768690f", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.nan + 1" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "BW3zQD2-gRr-", "outputId": "4525b6c4-495d-4f7b-a979-efce1dae9bd0", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "nan" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.nan * 0" ] }, { "cell_type": "markdown", "metadata": { "id": "fU5IPRcCgRr-" }, "source": [ "ਚੰਗੀ ਖਬਰ: ਜਿਨ੍ਹਾਂ ਐਰੇਜ਼ ਵਿੱਚ `NaN` ਹੁੰਦਾ ਹੈ, ਉਨ੍ਹਾਂ 'ਤੇ ਚਲਣ ਵਾਲੀਆਂ ਐਗਰੀਗੇਸ਼ਨਜ਼ ਵਿੱਚ ਗਲਤੀਆਂ ਨਹੀਂ ਆਉਂਦੀਆਂ। ਮੰਦੀ ਖਬਰ: ਨਤੀਜੇ ਸਾਰਿਆਂ ਲਈ ਇੱਕੋ ਜਿਹੇ ਲਾਭਦਾਇਕ ਨਹੀਂ ਹੁੰਦੇ:\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "LCInVgSSgRr_", "outputId": "fa06495a-0930-4867-87c5-6023031ea8b5", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "(nan, nan, nan)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example2 = np.array([2, np.nan, 6, 8]) \n", "example2.sum(), example2.min(), example2.max()" ] }, { "cell_type": "markdown", "metadata": { "id": "nhlnNJT7gRr_" }, "source": [ "### ਕਸਰਤ:\n" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "collapsed": true, "id": "yan3QRaOgRr_", "trusted": false }, "outputs": [], "source": [ "# What happens if you add np.nan and None together?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "_iDvIRC8gRsA" }, "source": [ "ਯਾਦ ਰੱਖੋ: `NaN` ਸਿਰਫ ਗੁੰਮ ਹੋਈਆਂ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਮੁੱਲਾਂ ਲਈ ਹੈ; ਪੂਰਨਾਂ, ਸਤਰਾਂ ਜਾਂ ਬੂਲੀਅਨ ਲਈ ਕੋਈ `NaN` ਸਮਕਾਲੀ ਨਹੀਂ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "kj6EKdsAgRsA" }, "source": [ "### `NaN` ਅਤੇ `None`: pandas ਵਿੱਚ null ਮੁੱਲ\n", "\n", "ਹਾਲਾਂਕਿ `NaN` ਅਤੇ `None` ਕੁਝ ਹੱਦ ਤੱਕ ਵੱਖਰੇ ਤਰੀਕੇ ਨਾਲ ਵਰਤਾਰਾ ਕਰ ਸਕਦੇ ਹਨ, pandas ਫਿਰ ਵੀ ਇਨ੍ਹਾਂ ਨੂੰ ਇੱਕੋ ਜਿਹਾ ਸੰਭਾਲਣ ਲਈ ਬਣਾਇਆ ਗਿਆ ਹੈ। ਇਸ ਗੱਲ ਨੂੰ ਸਮਝਣ ਲਈ, ਆਓ ਇੱਕ integers ਦੀ `Series` ਦੇਖੀਏ:\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "Nji-KGdNgRsA", "outputId": "36aa14d2-8efa-4bfd-c0ed-682991288822", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 1\n", "1 2\n", "2 3\n", "dtype: int64" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "int_series = pd.Series([1, 2, 3], dtype=int)\n", "int_series" ] }, { "cell_type": "markdown", "metadata": { "id": "WklCzqb8gRsB" }, "source": [ "### ਕਸਰਤ:\n" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "collapsed": true, "id": "Cy-gqX5-gRsB", "trusted": false }, "outputs": [], "source": [ "# Now set an element of int_series equal to None.\n", "# How does that element show up in the Series?\n", "# What is the dtype of the Series?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "WjMQwltNgRsB" }, "source": [ "ਡਾਟਾ ਦੀ ਸਮਰੂਪਤਾ ਸਥਾਪਿਤ ਕਰਨ ਲਈ `Series` ਅਤੇ `DataFrame`s ਵਿੱਚ ਡਾਟਾ ਟਾਈਪਸ ਨੂੰ ਉੱਚੇ ਪੱਧਰ 'ਤੇ ਲਿਜਾਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਵਿੱਚ, pandas ਬਿਨਾਂ ਕਿਸੇ ਹਿਚਕਚਾਹਟ ਦੇ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ `None` ਅਤੇ `NaN` ਦੇ ਵਿਚਕਾਰ ਬਦਲ ਸਕਦਾ ਹੈ। ਇਸ ਡਿਜ਼ਾਈਨ ਵਿਸ਼ੇਸ਼ਤਾ ਦੇ ਕਾਰਨ, pandas ਵਿੱਚ `None` ਅਤੇ `NaN` ਨੂੰ \"null\" ਦੇ ਦੋ ਵੱਖ-ਵੱਖ ਰੂਪਾਂ ਵਜੋਂ ਸੋਚਣਾ ਸਹੀ ਹੋ ਸਕਦਾ ਹੈ। ਦਰਅਸਲ, pandas ਵਿੱਚ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨਾਲ ਨਿਪਟਣ ਲਈ ਤੁਸੀਂ ਵਰਤਦੇ ਕੁਝ ਮੁੱਖ ਤਰੀਕੇ ਇਸ ਵਿਚਾਰ ਨੂੰ ਆਪਣੇ ਨਾਮਾਂ ਵਿੱਚ ਦਰਸਾਉਂਦੇ ਹਨ:\n", "\n", "- `isnull()`: ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਵਾਲਾ ਬੂਲੀਅਨ ਮਾਸਕ ਬਣਾਉਂਦਾ ਹੈ\n", "- `notnull()`: `isnull()` ਦਾ ਉਲਟ\n", "- `dropna()`: ਡਾਟਾ ਦਾ ਇੱਕ ਫਿਲਟਰ ਕੀਤਾ ਸੰਸਕਰਣ ਵਾਪਸ ਕਰਦਾ ਹੈ\n", "- `fillna()`: ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਭਰ ਕੇ ਜਾਂ ਅਨੁਮਾਨ ਲਗਾ ਕੇ ਡਾਟਾ ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ\n", "\n", "ਇਹ ਤਰੀਕੇ ਸਿੱਖਣ ਅਤੇ ਆਰਾਮਦਾਇਕ ਹੋਣ ਲਈ ਬਹੁਤ ਮਹੱਤਵਪੂਰਨ ਹਨ, ਇਸ ਲਈ ਆਓ ਇਨ੍ਹਾਂ ਨੂੰ ਵੱਖ-ਵੱਖ ਗਹਿਰਾਈ ਨਾਲ ਸਮਝੀਏ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "Yh5ifd9FgRsB" }, "source": [ "### ਨੱਲ ਮੁੱਲਾਂ ਦੀ ਪਹਿਚਾਣ ਕਰਨਾ\n", "\n", "ਹੁਣ ਜਦੋਂ ਅਸੀਂ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਦੀ ਮਹੱਤਤਾ ਨੂੰ ਸਮਝ ਲਿਆ ਹੈ, ਤਾਂ ਅਸੀਂ ਆਪਣੇ ਡਾਟਾਸੈਟ ਵਿੱਚ ਉਨ੍ਹਾਂ ਦੀ ਪਹਿਚਾਣ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਇਸ ਨਾਲ ਨਜਿੱਠਣ ਤੋਂ ਪਹਿਲਾਂ। \n", "`isnull()` ਅਤੇ `notnull()` ਦੋਵੇਂ ਨੱਲ ਡਾਟਾ ਦੀ ਪਹਿਚਾਣ ਕਰਨ ਲਈ ਤੁਹਾਡੇ ਮੁੱਖ ਤਰੀਕੇ ਹਨ। ਦੋਵੇਂ ਤੁਹਾਡੇ ਡਾਟੇ 'ਤੇ ਬੂਲੀਅਨ ਮਾਸਕ ਵਾਪਸ ਕਰਦੇ ਹਨ।\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "collapsed": true, "id": "e-vFp5lvgRsC", "trusted": false }, "outputs": [], "source": [ "example3 = pd.Series([0, np.nan, '', None])" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "1XdaJJ7PgRsC", "outputId": "92fc363a-1874-471f-846d-f4f9ce1f51d0", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 False\n", "1 True\n", "2 False\n", "3 True\n", "dtype: bool" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example3.isnull()" ] }, { "cell_type": "markdown", "metadata": { "id": "PaSZ0SQygRsC" }, "source": [ "ਧਿਆਨ ਨਾਲ ਨਤੀਜੇ ਨੂੰ ਦੇਖੋ। ਕੀ ਇਸ ਵਿੱਚੋਂ ਕੋਈ ਚੀਜ਼ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਕਰਦੀ ਹੈ? ਜਦੋਂ ਕਿ `0` ਇੱਕ ਗਣਿਤਕ null ਹੈ, ਇਹ ਫਿਰ ਵੀ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਪੂਰਨ ਅੰਕ ਹੈ ਅਤੇ pandas ਇਸਨੂੰ ਇਸੇ ਤਰ੍ਹਾਂ ਮੰਨਦਾ ਹੈ। `''` ਕੁਝ ਹੱਦ ਤੱਕ ਜ਼ਿਆਦਾ ਸੁਖਮ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਇਸਨੂੰ ਭਾਗ 1 ਵਿੱਚ ਖਾਲੀ ਸਤਰ ਦੀ ਮੂਲਤਾ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਸੀ, ਇਹ ਫਿਰ ਵੀ ਇੱਕ ਸਤਰ ਵਸਤੂ ਹੈ ਅਤੇ pandas ਦੇ ਹਿਸਾਬ ਨਾਲ null ਦੀ ਨੁਮਾਇੰਦਗੀ ਨਹੀਂ ਹੈ।\n", "\n", "ਹੁਣ, ਆਓ ਇਸਨੂੰ ਵਿਰੋਧੀ ਦਿਸ਼ਾ ਵਿੱਚ ਮੋੜੀਏ ਅਤੇ ਇਹਨਾਂ ਤਰੀਕਿਆਂ ਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਵਰਤਾਂਗੇ ਜਿਵੇਂ ਤੁਸੀਂ ਅਮਲ ਵਿੱਚ ਇਹਨਾਂ ਨੂੰ ਵਰਤੋਂਗੇ। ਤੁਸੀਂ Boolean masks ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ``Series`` ਜਾਂ ``DataFrame`` ਇੰਡੈਕਸ ਵਜੋਂ ਵਰਤ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਖਾਸ ਤੌਰ 'ਤੇ ਗੁੰਮ ਹੋਈਆਂ (ਜਾਂ ਮੌਜੂਦ) ਮੁੱਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ।\n", "\n", "ਜੇਕਰ ਅਸੀਂ ਗੁੰਮ ਹੋਈਆਂ ਮੁੱਲਾਂ ਦੀ ਕੁੱਲ ਗਿਣਤੀ ਚਾਹੁੰਦੇ ਹਾਂ, ਤਾਂ ਅਸੀਂ ਸਿਰਫ `isnull()` ਤਰੀਕੇ ਦੁਆਰਾ ਬਣਾਈ ਗਈ mask 'ਤੇ ਇੱਕ ਜੋੜ ਕਰ ਸਕਦੇ ਹਾਂ।\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "JCcQVoPkHDUv", "outputId": "001daa72-54f8-4bd5-842a-4df627a79d4d" }, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example3.isnull().sum()" ] }, { "cell_type": "markdown", "metadata": { "id": "PlBqEo3mgRsC" }, "source": [ "### ਕਸਰਤ:\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "collapsed": true, "id": "ggDVf5uygRsD", "trusted": false }, "outputs": [], "source": [ "# Try running example3[example3.notnull()].\n", "# Before you do so, what do you expect to see?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "D_jWN7mHgRsD" }, "source": [ "**ਮੁੱਖ ਨਿਸ਼ਕਰਸ਼**: ਦੋਵੇਂ `isnull()` ਅਤੇ `notnull()` ਵਿਧੀਆਂ ਸਮਾਨ ਨਤੀਜੇ ਪੈਦਾ ਕਰਦੀਆਂ ਹਨ ਜਦੋਂ ਤੁਸੀਂ ਉਨ੍ਹਾਂ ਨੂੰ ਡਾਟਾ ਫਰੇਮਜ਼ ਵਿੱਚ ਵਰਤਦੇ ਹੋ: ਇਹ ਨਤੀਜੇ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਇੰਡੈਕਸ ਦਿਖਾਉਂਦੀਆਂ ਹਨ, ਜੋ ਤੁਹਾਡੀ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਨ ਦੌਰਾਨ ਤੁਹਾਡੀ ਬਹੁਤ ਮਦਦ ਕਰਨਗੀਆਂ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "BvnoojWsgRr4" }, "source": [ "### ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਨਾਲ ਨਿਪਟਣਾ\n", "\n", "> **ਸਿੱਖਣ ਦਾ ਉਦੇਸ਼:** ਇਸ ਉਪਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਸੀਂ ਜਾਣ ਸਕੋਗੇ ਕਿ DataFrames ਵਿੱਚ null ਮੁੱਲਾਂ ਨੂੰ ਕਿਵੇਂ ਅਤੇ ਕਦੋਂ ਬਦਲਣਾ ਜਾਂ ਹਟਾਉਣਾ ਹੈ।\n", "\n", "Machine Learning ਮਾਡਲ ਆਪਣੇ ਆਪ ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਨਾਲ ਨਿਪਟ ਨਹੀਂ ਕਰ ਸਕਦੇ। ਇਸ ਲਈ, ਮਾਡਲ ਵਿੱਚ ਡਾਟਾ ਪਾਸ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਸਾਨੂੰ ਇਨ੍ਹਾਂ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨਾਲ ਨਿਪਟਣਾ ਪਵੇਗਾ।\n", "\n", "ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਨਾਲ ਨਰਮ-ਨਰਮ ਤਰੱਕੀਆਂ ਜੁੜੀਆਂ ਹੁੰਦੀਆਂ ਹਨ, ਜੋ ਤੁਹਾਡੇ ਅੰਤਿਮ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਹਕੀਕਤੀ-ਜਗਤ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦੀਆਂ ਹਨ।\n", "\n", "ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਨਾਲ ਨਿਪਟਣ ਦੇ ਮੁੱਖ ਤੌਰ 'ਤੇ ਦੋ ਤਰੀਕੇ ਹਨ:\n", "\n", "1. ਗੁੰਮ ਹੋਏ ਮੁੱਲ ਵਾਲੀ ਪੰਕਤੀ ਨੂੰ ਹਟਾਓ\n", "2. ਗੁੰਮ ਹੋਏ ਮੁੱਲ ਨੂੰ ਕਿਸੇ ਹੋਰ ਮੁੱਲ ਨਾਲ ਬਦਲੋ\n", "\n", "ਅਸੀਂ ਦੋਵੇਂ ਤਰੀਕਿਆਂ ਅਤੇ ਉਨ੍ਹਾਂ ਦੇ ਫਾਇਦੇ ਅਤੇ ਨੁਕਸਾਨਾਂ ਨੂੰ ਵਿਸਥਾਰ ਵਿੱਚ ਚਰਚਾ ਕਰਾਂਗੇ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "3VaYC1TvgRsD" }, "source": [ "### ਨਲ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣਾ\n", "\n", "ਜਿੰਨੀ ਡਾਟਾ ਅਸੀਂ ਆਪਣੇ ਮਾਡਲ ਨੂੰ ਪਾਸ ਕਰਦੇ ਹਾਂ, ਉਸਦਾ ਸਿੱਧਾ ਅਸਰ ਇਸਦੀ ਕਾਰਗੁਜ਼ਾਰੀ 'ਤੇ ਪੈਂਦਾ ਹੈ। ਨਲ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣ ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਅਸੀਂ ਡਾਟਾਪੌਇੰਟਸ ਦੀ ਗਿਣਤੀ ਘਟਾ ਰਹੇ ਹਾਂ, ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਡਾਟਾਸੈਟ ਦਾ ਆਕਾਰ ਘਟਾ ਰਹੇ ਹਾਂ। ਇਸ ਲਈ, ਜਦੋਂ ਡਾਟਾਸੈਟ ਕਾਫੀ ਵੱਡਾ ਹੋਵੇ, ਤਾਂ ਨਲ ਮੁੱਲਾਂ ਵਾਲੀਆਂ ਪੰਗਤਾਂ ਨੂੰ ਹਟਾਉਣਾ ਸਲਾਹਯੋਗ ਹੈ।\n", "\n", "ਇਕ ਹੋਰ ਹਾਲਾਤ ਇਹ ਹੋ ਸਕਦੀ ਹੈ ਕਿ ਕਿਸੇ ਖਾਸ ਪੰਗਤੀ ਜਾਂ ਕਾਲਮ ਵਿੱਚ ਬਹੁਤ ਸਾਰੇ ਮੁੱਲ ਗੁੰਮ ਹੋਣ। ਫਿਰ, ਉਹਨਾਂ ਨੂੰ ਹਟਾਇਆ ਜਾ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹ ਸਾਡੇ ਵਿਸ਼ਲੇਸ਼ਣ ਵਿੱਚ ਜ਼ਿਆਦਾ ਮੂਲ ਨਹੀਂ ਜੋੜਦੇ, ਕਿਉਂਕਿ ਉਸ ਪੰਗਤੀ/ਕਾਲਮ ਲਈ ਜ਼ਿਆਦਾਤਰ ਡਾਟਾ ਗੁੰਮ ਹੈ।\n", "\n", "ਨਲ ਮੁੱਲਾਂ ਦੀ ਪਹਿਚਾਣ ਤੋਂ ਇਲਾਵਾ, pandas `Series` ਅਤੇ `DataFrame`s ਤੋਂ ਨਲ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਇੱਕ ਸੁਵਿਧਾਜਨਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਇਸਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖਣ ਲਈ, ਆਓ `example3` ਵੱਲ ਵਾਪਸ ਚਲਦੇ ਹਾਂ। `DataFrame.dropna()` ਫੰਕਸ਼ਨ ਨਲ ਮੁੱਲਾਂ ਵਾਲੀਆਂ ਪੰਗਤਾਂ ਨੂੰ ਹਟਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।\n" ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "7uIvS097gRsD", "outputId": "c13fc117-4ca1-4145-a0aa-42ac89e6e218", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 0\n", "2 \n", "dtype: object" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example3 = example3.dropna()\n", "example3" ] }, { "cell_type": "markdown", "metadata": { "id": "hil2cr64gRsD" }, "source": [ "ਇਹ ਗੌਰ ਕਰੋ ਕਿ ਇਹ ਤੁਹਾਡੇ `example3[example3.notnull()]` ਦੇ ਆਉਟਪੁੱਟ ਵਰਗਾ ਹੀ ਦਿਖਾਈ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਥੇ ਫਰਕ ਇਹ ਹੈ ਕਿ, ਸਿਰਫ ਮਾਸਕ ਕੀਤੇ ਗਏ ਮੁੱਲਾਂ 'ਤੇ ਇੰਡੈਕਸਿੰਗ ਕਰਨ ਦੀ ਬਜਾਇ, `dropna` ਨੇ `Series` `example3` ਤੋਂ ਉਹ ਗੁੰਮ ਹੋਏ ਮੁੱਲ ਹਟਾ ਦਿੱਤੇ ਹਨ।\n", "\n", "ਕਿਉਂਕਿ DataFrames ਵਿੱਚ ਦੋ ਮਾਪ ਹੁੰਦੇ ਹਨ, ਇਹ ਡਾਟਾ ਹਟਾਉਣ ਲਈ ਹੋਰ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "an-l74sPgRsE", "outputId": "340876a0-63ad-40f6-bd54-6240cdae50ab", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
01.0NaN7
12.05.08
2NaN6.09
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1.0 NaN 7\n", "1 2.0 5.0 8\n", "2 NaN 6.0 9" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4 = pd.DataFrame([[1, np.nan, 7], \n", " [2, 5, 8], \n", " [np.nan, 6, 9]])\n", "example4" ] }, { "cell_type": "markdown", "metadata": { "id": "66wwdHZrgRsE" }, "source": [ "(ਕੀ ਤੁਸੀਂ ਧਿਆਨ ਦਿੱਤਾ ਕਿ pandas ਨੇ `NaN`s ਨੂੰ ਸਮਝਣ ਲਈ ਦੋ ਕਾਲਮਾਂ ਨੂੰ floats ਵਿੱਚ ਬਦਲ ਦਿੱਤਾ?)\n", "\n", "ਤੁਸੀਂ `DataFrame` ਵਿੱਚੋਂ ਇੱਕ ਹੀ ਮੁੱਲ ਨਹੀਂ ਹਟਾ ਸਕਦੇ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਪੂਰੀਆਂ ਪੰਗਤਾਂ ਜਾਂ ਕਾਲਮਾਂ ਨੂੰ ਹਟਾਉਣਾ ਪਵੇਗਾ। ਜੋ ਕੁਝ ਤੁਸੀਂ ਕਰ ਰਹੇ ਹੋ, ਉਸ ਦੇ ਆਧਾਰ 'ਤੇ ਤੁਸੀਂ ਇੱਕ ਜਾਂ ਦੂਜਾ ਚੋਣ ਕਰ ਸਕਦੇ ਹੋ, ਅਤੇ ਇਸ ਲਈ pandas ਤੁਹਾਨੂੰ ਦੋਵੇਂ ਲਈ ਵਿਕਲਪ ਦਿੰਦਾ ਹੈ। ਕਿਉਂਕਿ ਡਾਟਾ ਸਾਇੰਸ ਵਿੱਚ, ਕਾਲਮ ਆਮ ਤੌਰ 'ਤੇ ਵੈਰੀਏਬਲਾਂ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ ਅਤੇ ਪੰਗਤਾਂ ਅਵਲੋਕਨ ਨੂੰ ਦਰਸਾਉਂਦੀਆਂ ਹਨ, ਤੁਸੀਂ ਡਾਟਾ ਦੀਆਂ ਪੰਗਤਾਂ ਨੂੰ ਹਟਾਉਣ ਦੀ ਸੰਭਾਵਨਾ ਵਧੇਰੇ ਰੱਖਦੇ ਹੋ; `dropna()` ਲਈ ਡਿਫਾਲਟ ਸੈਟਿੰਗ ਇਹ ਹੈ ਕਿ ਉਹ ਸਾਰੀਆਂ ਪੰਗਤਾਂ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਕੋਈ ਵੀ null ਮੁੱਲ ਹੁੰਦਾ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 80 }, "id": "jAVU24RXgRsE", "outputId": "0b5e5aee-7187-4d3f-b583-a44136ae5f80", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
12.05.08
\n", "
" ], "text/plain": [ " 0 1 2\n", "1 2.0 5.0 8" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.dropna()" ] }, { "cell_type": "markdown", "metadata": { "id": "TrQRBuTDgRsE" }, "source": [ "ਜੇ ਜ਼ਰੂਰੀ ਹੋਵੇ, ਤਾਂ ਤੁਸੀਂ ਕਾਲਮਾਂ ਤੋਂ NA ਮੁੱਲਾਂ ਨੂੰ ਹਟਾ ਸਕਦੇ ਹੋ। ਇਸ ਲਈ `axis=1` ਦੀ ਵਰਤੋਂ ਕਰੋ:\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "GrBhxu9GgRsE", "outputId": "ff4001f3-2e61-4509-d60e-0093d1068437", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
2
07
18
29
\n", "
" ], "text/plain": [ " 2\n", "0 7\n", "1 8\n", "2 9" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.dropna(axis='columns')" ] }, { "cell_type": "markdown", "metadata": { "id": "KWXiKTfMgRsF" }, "source": [ "ਧਿਆਨ ਦਿਓ ਕਿ ਇਸ ਨਾਲ ਕਈ ਡਾਟਾ ਖਤਮ ਹੋ ਸਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਖਾਸ ਕਰਕੇ ਛੋਟੇ ਡਾਟਾਸੈਟ ਵਿੱਚ। ਕੀ ਹੋਵੇ ਜੇ ਤੁਸੀਂ ਸਿਰਫ ਉਹ ਪੰਗਤਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਕਈ ਜਾਂ ਸਾਰੇ null ਮੁੱਲ ਹਨ? ਤੁਸੀਂ ਇਹ ਸੈਟਿੰਗ `dropna` ਵਿੱਚ `how` ਅਤੇ `thresh` ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।\n", "\n", "ਡਿਫਾਲਟ ਰੂਪ ਵਿੱਚ, `how='any'` ਹੁੰਦਾ ਹੈ (ਜੇ ਤੁਸੀਂ ਖੁਦ ਜਾਂਚਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਾਂ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਸ ਮੈਥਡ ਵਿੱਚ ਹੋਰ ਕਿਹੜੇ ਪੈਰਾਮੀਟਰ ਹਨ, ਤਾਂ ਕੋਡ ਸੈਲ ਵਿੱਚ `example4.dropna?` ਚਲਾਓ)। ਤੁਸੀਂ ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ `how='all'` ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਸਿਰਫ ਉਹ ਪੰਗਤਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਏ ਜਾਣ ਜੋ ਸਾਰੇ null ਮੁੱਲ ਰੱਖਦੇ ਹਨ। ਆਓ ਅਗਲੇ ਅਭਿਆਸ ਵਿੱਚ ਇਸ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖਣ ਲਈ ਆਪਣੇ ਉਦਾਹਰਨ `DataFrame` ਨੂੰ ਵਧਾਉਣ।\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "Bcf_JWTsgRsF", "outputId": "72e0b1b8-52fa-4923-98ce-b6fbed6e44b1", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.0NaN7NaN
12.05.08NaN
2NaN6.09NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 NaN 7 NaN\n", "1 2.0 5.0 8 NaN\n", "2 NaN 6.0 9 NaN" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4[3] = np.nan\n", "example4" ] }, { "cell_type": "markdown", "metadata": { "id": "pNZer7q9JPNC" }, "source": [ "> ਮੁੱਖ ਗੱਲਾਂ:\n", "1. ਨੱਲ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣਾ ਸਿਰਫ ਉਸੇ ਵੇਲੇ ਵਧੀਆ ਹੈ ਜਦੋਂ ਡੇਟਾਸੈੱਟ ਕਾਫੀ ਵੱਡਾ ਹੋਵੇ।\n", "2. ਪੂਰੀਆਂ ਪੰਗਤਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਏ ਜਾ ਸਕਦੇ ਹਨ ਜੇ ਉਹਨਾਂ ਵਿੱਚ ਜ਼ਿਆਦਾਤਰ ਡੇਟਾ ਗੁੰਮ ਹੋਵੇ।\n", "3. `DataFrame.dropna(axis=)` ਵਿਧੀ ਨੱਲ ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ। `axis` ਦਲੀਲ ਦਰਸਾਉਂਦੀ ਹੈ ਕਿ ਪੰਗਤਾਂ ਹਟਾਈਆਂ ਜਾਣਗੀਆਂ ਜਾਂ ਕਾਲਮ।\n", "4. `how` ਦਲੀਲ ਵੀ ਵਰਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਮੂਲ ਰੂਪ ਵਿੱਚ ਇਹ `any` 'ਤੇ ਸੈਟ ਹੁੰਦੀ ਹੈ। ਇਸ ਲਈ, ਇਹ ਸਿਰਫ ਉਹਨਾਂ ਪੰਗਤਾਂ/ਕਾਲਮਾਂ ਨੂੰ ਹਟਾਉਂਦੀ ਹੈ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਕੋਈ ਵੀ ਨੱਲ ਮੁੱਲ ਹੁੰਦਾ ਹੈ। ਇਸਨੂੰ `all` 'ਤੇ ਸੈਟ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸ ਨਾਲ ਸਿਰਫ ਉਹਨਾਂ ਪੰਗਤਾਂ/ਕਾਲਮਾਂ ਨੂੰ ਹਟਾਇਆ ਜਾਵੇਗਾ ਜਿੱਥੇ ਸਾਰੇ ਮੁੱਲ ਨੱਲ ਹਨ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "oXXSfQFHgRsF" }, "source": [ "### ਕਸਰਤ:\n" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "collapsed": true, "id": "ExUwQRxpgRsF", "trusted": false }, "outputs": [], "source": [ "# How might you go about dropping just column 3?\n", "# Hint: remember that you will need to supply both the axis parameter and the how parameter.\n" ] }, { "cell_type": "markdown", "metadata": { "id": "38kwAihWgRsG" }, "source": [ "`thresh` ਪੈਰਾਮੀਟਰ ਤੁਹਾਨੂੰ ਵਧੀਆ-ਦਰਜੇ ਦਾ ਕੰਟਰੋਲ ਦਿੰਦਾ ਹੈ: ਤੁਸੀਂ ਗੈਰ-ਨਲ ਮੁੱਲਾਂ ਦੀ ਗਿਣਤੀ ਸੈਟ ਕਰਦੇ ਹੋ ਜੋ ਇੱਕ ਪੰਕਤੀ ਜਾਂ ਕਾਲਮ ਨੂੰ ਰੱਖਣ ਲਈ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 80 }, "id": "M9dCNMaagRsG", "outputId": "8093713a-54d2-4e54-c73f-4eea315cb6f2", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
12.05.08NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "1 2.0 5.0 8 NaN" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.dropna(axis='rows', thresh=3)" ] }, { "cell_type": "markdown", "metadata": { "id": "fmSFnzZegRsG" }, "source": [ "ਇੱਥੇ, ਪਹਿਲੀ ਅਤੇ ਆਖਰੀ ਪੰਗਤੀ ਨੂੰ ਹਟਾ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਕਿਉਂਕਿ ਉਹਨਾਂ ਵਿੱਚ ਸਿਰਫ ਦੋ ਗੈਰ-ਨੱਲ ਮੁੱਲ ਹਨ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "mCcxLGyUgRsG" }, "source": [ "### ਨਲ ਮੁੱਲਾਂ ਨੂੰ ਭਰਨਾ\n", "\n", "ਕਈ ਵਾਰ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਉਹਨਾਂ ਨਾਲ ਭਰਨਾ ਸਹੀ ਹੁੰਦਾ ਹੈ ਜੋ ਵੈਧ ਹੋ ਸਕਦੇ ਹਨ। ਨਲ ਮੁੱਲਾਂ ਨੂੰ ਭਰਨ ਦੇ ਕੁਝ ਤਰੀਕੇ ਹਨ। ਪਹਿਲਾ ਤਰੀਕਾ ਹੈ ਡੋਮੇਨ ਨੋਲਿਜ (ਜਿਸ ਵਿਸ਼ੇ 'ਤੇ ਡੇਟਾਸੈਟ ਆਧਾਰਿਤ ਹੈ ਉਸ ਦਾ ਗਿਆਨ) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਣਾ। \n", "\n", "ਤੁਸੀਂ ਇਸ ਨੂੰ `isnull` ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਿੱਧੇ ਹੀ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਥੋੜਾ ਔਖਾ ਹੋ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ ਜੇ ਤੁਹਾਡੇ ਕੋਲ ਭਰਨ ਲਈ ਕਾਫ਼ੀ ਸਾਰੇ ਮੁੱਲ ਹਨ। ਕਿਉਂਕਿ ਇਹ ਡੇਟਾ ਸਾਇੰਸ ਵਿੱਚ ਇੱਕ ਆਮ ਕੰਮ ਹੈ, pandas `fillna` ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ `Series` ਜਾਂ `DataFrame` ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਗੁੰਮ ਹੋਏ ਮੁੱਲ ਤੁਹਾਡੇ ਚੋਣੇ ਹੋਏ ਮੁੱਲਾਂ ਨਾਲ ਬਦਲੇ ਜਾਂਦੇ ਹਨ। ਆਓ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ `Series` ਬਣਾਈਏ ਤਾਂ ਜੋ ਦੇਖ ਸਕੀਏ ਕਿ ਇਹ ਅਮਲ ਵਿੱਚ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "CE8S7louLezV" }, "source": [ "### ਸ਼੍ਰੇਣੀਬੱਧ ਡਾਟਾ (ਗੈਰ-ਸੰਖਿਆਤਮਕ)\n", "ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਆਓ ਗੈਰ-ਸੰਖਿਆਤਮਕ ਡਾਟਾ ਦੇਖੀਏ। ਡਾਟਾਸੈਟ ਵਿੱਚ ਸਾਡੇ ਕੋਲ ਸ਼੍ਰੇਣੀਬੱਧ ਡਾਟਾ ਵਾਲੇ ਕਾਲਮ ਹੁੰਦੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ, ਲਿੰਗ, ਸੱਚ ਜਾਂ ਝੂਠ ਆਦਿ।\n", "\n", "ਇਨ੍ਹਾਂ ਵਿੱਚੋਂ ਜ਼ਿਆਦਾਤਰ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਅਸੀਂ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਕਾਲਮ ਦੇ `mode` ਨਾਲ ਬਦਲ ਦਿੰਦੇ ਹਾਂ। ਮੰਨੋ, ਸਾਡੇ ਕੋਲ 100 ਡਾਟਾ ਪੌਇੰਟ ਹਨ ਅਤੇ 90 ਨੇ ਸੱਚ ਕਿਹਾ ਹੈ, 8 ਨੇ ਝੂਠ ਕਿਹਾ ਹੈ ਅਤੇ 2 ਨੇ ਨਹੀਂ ਭਰਿਆ। ਫਿਰ, ਅਸੀਂ ਉਹ 2 ਨੂੰ ਸੱਚ ਨਾਲ ਭਰ ਸਕਦੇ ਹਾਂ, ਪੂਰੇ ਕਾਲਮ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹੋਏ।\n", "\n", "ਇੱਥੇ ਵੀ ਅਸੀਂ ਡੋਮੇਨ ਗਿਆਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ। ਆਓ `mode` ਨਾਲ ਭਰਨ ਦਾ ਇੱਕ ਉਦਾਹਰਣ ਵੇਖੀਏ।\n" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "MY5faq4yLdpQ", "outputId": "19ab472e-1eed-4de8-f8a7-db2a3af3cb1a" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
012True
134None
256False
378True
4910True
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1 2 True\n", "1 3 4 None\n", "2 5 6 False\n", "3 7 8 True\n", "4 9 10 True" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mode = pd.DataFrame([[1,2,\"True\"],\n", " [3,4,None],\n", " [5,6,\"False\"],\n", " [7,8,\"True\"],\n", " [9,10,\"True\"]])\n", "\n", "fill_with_mode" ] }, { "cell_type": "markdown", "metadata": { "id": "MLAoMQOfNPlA" }, "source": [ "ਹੁਣ, ਪਹਿਲਾਂ ਮੋਡ ਲੱਭਦੇ ਹਾਂ ਜਦੋਂ ਕਿ `None` ਮੁੱਲ ਨੂੰ ਮੋਡ ਨਾਲ ਭਰਨਾ ਹੈ।\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "WKy-9Y2tN5jv", "outputId": "8da9fa16-e08c-447e-dea1-d4b1db2feebf" }, "outputs": [ { "data": { "text/plain": [ "True 3\n", "False 1\n", "Name: 2, dtype: int64" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mode[2].value_counts()" ] }, { "cell_type": "markdown", "metadata": { "id": "6iNz_zG_OKrx" }, "source": [ "ਤਾਂਕਿ ਅਸੀਂ None ਨੂੰ True ਨਾਲ ਬਦਲਾਂਗੇ।\n" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "id": "TxPKteRvNPOs" }, "outputs": [], "source": [ "fill_with_mode[2].fillna('True',inplace=True)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "tvas7c9_OPWE", "outputId": "ec3c8e44-d644-475e-9e22-c65101965850" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
012True
134True
256False
378True
4910True
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1 2 True\n", "1 3 4 True\n", "2 5 6 False\n", "3 7 8 True\n", "4 9 10 True" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mode" ] }, { "cell_type": "markdown", "metadata": { "id": "SktitLxxOR16" }, "source": [ "ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਨੱਲ ਮੁੱਲ ਦੀ ਜਗ੍ਹਾ ਲੈ ਲਈ ਗਈ ਹੈ। ਬੇਸ਼ੱਕ, ਅਸੀਂ `'True'` ਦੀ ਜਗ੍ਹਾ ਕੁਝ ਵੀ ਲਿਖ ਸਕਦੇ ਸੀ ਅਤੇ ਇਹ ਸਥਾਨਾਪਨ ਹੋ ਜਾਂਦਾ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "heYe1I0dOmQ_" }, "source": [ "### ਗਿਣਤੀ ਡਾਟਾ \n", "ਹੁਣ, ਗਿਣਤੀ ਡਾਟਾ ਵੱਲ ਆਉਂਦੇ ਹਾਂ। ਇੱਥੇ, ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਭਰਣ ਦੇ ਦੋ ਆਮ ਤਰੀਕੇ ਹਨ: \n", "\n", "1. ਕਤਾਰ ਦੇ ਮੀਡੀਅਨ ਨਾਲ ਭਰੋ \n", "2. ਕਤਾਰ ਦੇ ਮੀਨ ਨਾਲ ਭਰੋ \n", "\n", "ਅਸੀਂ ਮੀਡੀਅਨ ਨਾਲ ਭਰਦੇ ਹਾਂ, ਜੇ ਡਾਟਾ ਵਿੱਚ ਆਉਟਲਾਇਰਸ ਨਾਲ ਤਿਰਛਾ ਹੋਵੇ। ਇਹ ਇਸ ਲਈ ਕਿ ਮੀਡੀਅਨ ਆਉਟਲਾਇਰਸ ਲਈ ਮਜ਼ਬੂਤ ਹੁੰਦੀ ਹੈ। \n", "\n", "ਜਦੋਂ ਡਾਟਾ ਨਾਰਮਲਾਈਜ਼ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਸੀਂ ਮੀਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ, ਕਿਉਂਕਿ ਉਸ ਸਥਿਤੀ ਵਿੱਚ ਮੀਨ ਅਤੇ ਮੀਡੀਅਨ ਕਾਫ਼ੀ ਨੇੜੇ ਹੁੰਦੇ ਹਨ। \n", "\n", "ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਕਾਲਮ ਲਵਾਂ ਜੋ ਨਾਰਮਲ ਡਿਸਟ੍ਰਿਬਿਊਟ ਕੀਤਾ ਹੋਇਆ ਹੈ ਅਤੇ ਉਸ ਵਿੱਚ ਗੁੰਮ ਹੋਏ ਮੁੱਲ ਨੂੰ ਕਾਲਮ ਦੇ ਮੀਨ ਨਾਲ ਭਰਦੇ ਹਾਂ। \n" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "09HM_2feOj5Y", "outputId": "7e309013-9acb-411c-9b06-4de795bbeeff" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-2.001
1-1.023
2NaN45
31.067
42.089
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2.0 0 1\n", "1 -1.0 2 3\n", "2 NaN 4 5\n", "3 1.0 6 7\n", "4 2.0 8 9" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mean = pd.DataFrame([[-2,0,1],\n", " [-1,2,3],\n", " [np.nan,4,5],\n", " [1,6,7],\n", " [2,8,9]])\n", "\n", "fill_with_mean" ] }, { "cell_type": "markdown", "metadata": { "id": "ka7-wNfzSxbx" }, "source": [ "ਕਾਲਮ ਦਾ ਔਸਤ ਹੈ\n" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "XYtYEf5BSxFL", "outputId": "68a78d18-f0e5-4a9a-a959-2c3676a57c70" }, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.mean(fill_with_mean[0])" ] }, { "cell_type": "markdown", "metadata": { "id": "oBSRGxKRS39K" }, "source": [ "ਮਤਲਬ ਨਾਲ ਭਰਨਾ\n" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "FzncQLmuS5jh", "outputId": "00f74fff-01f4-4024-c261-796f50f01d2e" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-2.001
1-1.023
20.045
31.067
42.089
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2.0 0 1\n", "1 -1.0 2 3\n", "2 0.0 4 5\n", "3 1.0 6 7\n", "4 2.0 8 9" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_mean[0].fillna(np.mean(fill_with_mean[0]),inplace=True)\n", "fill_with_mean" ] }, { "cell_type": "markdown", "metadata": { "id": "CwpVFCrPTC5z" }, "source": [ "ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਗੁੰਮ ਹੋਈ ਮੁੱਲ ਨੂੰ ਇਸਦੇ ਔਸਤ ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "jIvF13a1i00Z" }, "source": [ "ਹੁਣ ਆਓ ਅਸੀਂ ਇੱਕ ਹੋਰ ਡਾਟਾਫਰੇਮ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੀਏ, ਅਤੇ ਇਸ ਵਾਰ ਅਸੀਂ None ਮੁੱਲਾਂ ਨੂੰ ਕਾਲਮ ਦੇ ਮੀਡੀਅਨ ਨਾਲ ਬਦਲਾਂਗੇ।\n" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "DA59Bqo3jBYZ", "outputId": "85dae6ec-7394-4c36-fda0-e04769ec4a32" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-20.01
1-12.03
20NaN5
316.07
428.09
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2 0.0 1\n", "1 -1 2.0 3\n", "2 0 NaN 5\n", "3 1 6.0 7\n", "4 2 8.0 9" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_median = pd.DataFrame([[-2,0,1],\n", " [-1,2,3],\n", " [0,np.nan,5],\n", " [1,6,7],\n", " [2,8,9]])\n", "\n", "fill_with_median" ] }, { "cell_type": "markdown", "metadata": { "id": "mM1GpXYmjHnc" }, "source": [ "ਦੂਜੇ ਕਤਾਰ ਦਾ ਮੱਧਿਕ ਕੀ ਹੈ\n" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "uiDy5v3xjHHX", "outputId": "564b6b74-2004-4486-90d4-b39330a64b88" }, "outputs": [ { "data": { "text/plain": [ "4.0" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_median[1].median()" ] }, { "cell_type": "markdown", "metadata": { "id": "z9PLF75Jj_1s" }, "source": [ "ਮੱਧ ਨਾਲ ਭਰਨ\n" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "lFKbOxCMkBbg", "outputId": "a8bd18fb-2765-47d4-e5fe-e965f57ed1f4" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
012
0-20.01
1-12.03
204.05
316.07
428.09
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 -2 0.0 1\n", "1 -1 2.0 3\n", "2 0 4.0 5\n", "3 1 6.0 7\n", "4 2 8.0 9" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "fill_with_median[1].fillna(fill_with_median[1].median(),inplace=True)\n", "fill_with_median" ] }, { "cell_type": "markdown", "metadata": { "id": "8JtQ53GSkKWC" }, "source": [ "ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, NaN ਮੁੱਲ ਨੂੰ ਕਾਲਮ ਦੇ ਮੀਡੀਆਨ ਨਾਲ ਬਦਲ ਦਿੱਤਾ ਗਿਆ ਹੈ।\n" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "0ybtWLDdgRsG", "outputId": "b8c238ef-6024-4ee2-be2b-aa1f0fcac61d", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b NaN\n", "c 2.0\n", "d NaN\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))\n", "example5" ] }, { "cell_type": "markdown", "metadata": { "id": "yrsigxRggRsH" }, "source": [ "ਤੁਸੀਂ ਸਾਰੇ ਖਾਲੀ ਐਂਟਰੀਆਂ ਨੂੰ ਇੱਕ ਹੀ ਮੁੱਲ ਨਾਲ ਭਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ ਕਿ `0`:\n" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "KXMIPsQdgRsH", "outputId": "aeedfa0a-a421-4c2f-cb0d-183ce8f0c91d", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b 0.0\n", "c 2.0\n", "d 0.0\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5.fillna(0)" ] }, { "cell_type": "markdown", "metadata": { "id": "RRlI5f_hkfKe" }, "source": [ "> ਮੁੱਖ ਗੱਲਾਂ:\n", "1. ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਭਰਨਾ ਉਸ ਸਮੇਂ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਜਦੋਂ ਡਾਟਾ ਘੱਟ ਹੋਵੇ ਜਾਂ ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਨੂੰ ਭਰਨ ਲਈ ਕੋਈ ਰਣਨੀਤੀ ਹੋਵੇ।\n", "2. ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਅਨੁਮਾਨ ਲਗਾ ਕੇ ਭਰਨ ਲਈ ਡੋਮੇਨ ਗਿਆਨ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।\n", "3. ਸ਼੍ਰੇਣੀਬੱਧ ਡਾਟਾ ਲਈ, ਜ਼ਿਆਦਾਤਰ ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਕਾਲਮ ਦੇ ਮੋਡ ਨਾਲ ਬਦਲਿਆ ਜਾਂਦਾ ਹੈ।\n", "4. ਸੰਖਿਆਤਮਕ ਡਾਟਾ ਲਈ, ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਕਾਲਮ ਦੇ ਮੀਨ (ਸਧਾਰਨ ਡਾਟਾਸੈਟ ਲਈ) ਜਾਂ ਮੀਡਿਅਨ ਨਾਲ ਭਰਿਆ ਜਾਂਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "FI9MmqFJgRsH" }, "source": [ "### ਕਸਰਤ:\n" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "collapsed": true, "id": "af-ezpXdgRsH", "trusted": false }, "outputs": [], "source": [ "# What happens if you try to fill null values with a string, like ''?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "kq3hw1kLgRsI" }, "source": [ "ਤੁਸੀਂ **ਫਾਰਵਰਡ-ਫਿਲ** ਨਲ ਮੁੱਲਾਂ ਨੂੰ ਭਰ ਸਕਦੇ ਹੋ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਪਿਛਲੇ ਵੈਧ ਮੁੱਲ ਨੂੰ ਨਲ ਨੂੰ ਭਰਨ ਲਈ ਵਰਤਣਾ:\n" ] }, { "cell_type": "code", "execution_count": 41, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "vO3BuNrggRsI", "outputId": "e2bc591b-0b48-4e88-ee65-754f2737c196", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b 1.0\n", "c 2.0\n", "d 2.0\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5.fillna(method='ffill')" ] }, { "cell_type": "markdown", "metadata": { "id": "nDXeYuHzgRsI" }, "source": [ "ਤੁਸੀਂ ਅਗਲੇ ਵੈਧ ਮੁੱਲ ਨੂੰ ਪਿੱਛੇ ਵੱਲ ਫੈਲਾਉਣ ਲਈ **ਬੈਕ-ਫਿਲ** ਵੀ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਨੱਲ ਨੂੰ ਭਰਿਆ ਜਾ ਸਕੇ:\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "4M5onHcEgRsI", "outputId": "8f32b185-40dd-4a9f-bd85-54d6b6a414fe", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "a 1.0\n", "b 2.0\n", "c 2.0\n", "d 3.0\n", "e 3.0\n", "dtype: float64" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example5.fillna(method='bfill')" ] }, { "cell_type": "markdown", "metadata": { "collapsed": true, "id": "MbBzTom5gRsI" }, "source": [ "ਜਿਵੇਂ ਤੁਸੀਂ ਅਨੁਮਾਨ ਲਗਾ ਸਕਦੇ ਹੋ, ਇਹ DataFrames ਨਾਲ ਵੀ ਇਸੇ ਤਰੀਕੇ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ null ਮੁੱਲਾਂ ਨੂੰ ਭਰਣ ਲਈ ਇੱਕ `axis` ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ:\n" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "aRpIvo4ZgRsI", "outputId": "905a980a-a808-4eca-d0ba-224bd7d85955", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.0NaN7NaN
12.05.08NaN
2NaN6.09NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 NaN 7 NaN\n", "1 2.0 5.0 8 NaN\n", "2 NaN 6.0 9 NaN" ] }, "execution_count": 43, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "VM1qtACAgRsI", "outputId": "71f2ad28-9b4e-4ff4-f5c3-e731eb489ade", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.01.07.07.0
12.05.08.08.0
2NaN6.09.09.0
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 1.0 7.0 7.0\n", "1 2.0 5.0 8.0 8.0\n", "2 NaN 6.0 9.0 9.0" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.fillna(method='ffill', axis=1)" ] }, { "cell_type": "markdown", "metadata": { "id": "ZeMc-I1EgRsI" }, "source": [ "ਧਿਆਨ ਦਿਓ ਕਿ ਜਦੋਂ ਅੱਗੇ ਭਰਨ ਲਈ ਪਿਛਲਾ ਮੁੱਲ ਉਪਲਬਧ ਨਹੀਂ ਹੁੰਦਾ, ਤਾਂ ਨਲ ਮੁੱਲ ਜਿਵੇਂ ਦਾ ਤਿਵੇਂ ਰਹਿੰਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "eeAoOU0RgRsJ" }, "source": [ "### ਕਸਰਤ:\n" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "collapsed": true, "id": "e8S-CjW8gRsJ", "trusted": false }, "outputs": [], "source": [ "# What output does example4.fillna(method='bfill', axis=1) produce?\n", "# What about example4.fillna(method='ffill') or example4.fillna(method='bfill')?\n", "# Can you think of a longer code snippet to write that can fill all of the null values in example4?\n" ] }, { "cell_type": "markdown", "metadata": { "id": "YHgy0lIrgRsJ" }, "source": [ "ਤੁਸੀਂ `fillna` ਦੇ ਉਪਯੋਗ ਬਾਰੇ ਰਚਨਾਤਮਕ ਹੋ ਸਕਦੇ ਹੋ। ਉਦਾਹਰਣ ਲਈ, ਆਓ `example4` ਨੂੰ ਫਿਰ ਤੋਂ ਵੇਖੀਏ, ਪਰ ਇਸ ਵਾਰ ਚਲੋ ਗੁੰਮ ਹੋਈਆਂ ਮੁੱਲਾਂ ਨੂੰ `DataFrame` ਵਿੱਚ ਸਾਰੀਆਂ ਮੁੱਲਾਂ ਦੇ ਔਸਤ ਨਾਲ ਭਰਦੇ ਹਾਂ:\n" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "OtYVErEygRsJ", "outputId": "708b1e67-45ca-44bf-a5ee-8b2de09ece73", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
0123
01.05.57NaN
12.05.08NaN
21.56.09NaN
\n", "
" ], "text/plain": [ " 0 1 2 3\n", "0 1.0 5.5 7 NaN\n", "1 2.0 5.0 8 NaN\n", "2 1.5 6.0 9 NaN" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example4.fillna(example4.mean())" ] }, { "cell_type": "markdown", "metadata": { "id": "zpMvCkLSgRsJ" }, "source": [ "ਧਿਆਨ ਦਿਓ ਕਿ ਕਾਲਮ 3 ਅਜੇ ਵੀ ਖਾਲੀ ਹੈ: ਡਿਫਾਲਟ ਦਿਸ਼ਾ ਪੰਗਤਾਂ ਦੇ ਅਨੁਸਾਰ ਮੁੱਲ ਭਰਨ ਦੀ ਹੈ।\n", "\n", "> **ਸਿੱਖਣ ਵਾਲੀ ਗੱਲ:** ਆਪਣੇ ਡਾਟਾਸੈਟ ਵਿੱਚ ਗੁੰਮ ਮੁੱਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ। ਤੁਸੀਂ ਜੋ ਖਾਸ ਰਣਨੀਤੀ ਵਰਤਦੇ ਹੋ (ਉਨ੍ਹਾਂ ਨੂੰ ਹਟਾਉਣਾ, ਬਦਲਣਾ, ਜਾਂ ਕਿਵੇਂ ਬਦਲਣਾ) ਉਹ ਡਾਟਾ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਜਿਵੇਂ ਜਿਵੇਂ ਤੁਸੀਂ ਡਾਟਾਸੈਟਸ ਨਾਲ ਵਧੇਰੇ ਕੰਮ ਕਰਦੇ ਹੋ ਅਤੇ ਉਨ੍ਹਾਂ ਨਾਲ ਸੰਚਾਰ ਕਰਦੇ ਹੋ, ਤੁਸੀਂ ਗੁੰਮ ਮੁੱਲਾਂ ਨਾਲ ਨਜਿੱਠਣ ਦਾ ਬਿਹਤਰ ਅਹਿਸਾਸ ਵਿਕਸਿਤ ਕਰੋਗੇ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "bauDnESIl9FH" }, "source": [ "### ਸ਼੍ਰੇਣੀਬੱਧ ਡਾਟਾ ਨੂੰ ਕੋਡ ਕਰਨਾ\n", "\n", "ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਮਾਡਲ ਸਿਰਫ਼ ਗਿਣਤੀ ਅਤੇ ਕਿਸੇ ਵੀ ਤਰ੍ਹਾਂ ਦੇ ਗਿਣਤੀ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ। ਇਹ \"ਹਾਂ\" ਅਤੇ \"ਨਹੀਂ\" ਵਿੱਚ ਫਰਕ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਪਰ ਇਹ 0 ਅਤੇ 1 ਵਿੱਚ ਅੰਤਰ ਕਰ ਸਕਦੇ ਹਨ। ਇਸ ਲਈ, ਗੁੰਮ ਹੋਏ ਮੁੱਲਾਂ ਨੂੰ ਭਰਨ ਤੋਂ ਬਾਅਦ, ਸਾਨੂੰ ਮਾਡਲ ਨੂੰ ਸਮਝਣ ਲਈ ਸ਼੍ਰੇਣੀਬੱਧ ਡਾਟਾ ਨੂੰ ਕੁਝ ਗਿਣਤੀ ਰੂਪ ਵਿੱਚ ਕੋਡ ਕਰਨਾ ਪਵੇਗਾ।\n", "\n", "ਕੋਡਿੰਗ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਅਸੀਂ ਅਗਲੇ ਹਿੱਸੇ ਵਿੱਚ ਇਹਨਾਂ ਬਾਰੇ ਚਰਚਾ ਕਰਾਂਗੇ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "uDq9SxB7mu5i" }, "source": [ "**ਲੇਬਲ ਐਨਕੋਡਿੰਗ**\n", "\n", "ਲੇਬਲ ਐਨਕੋਡਿੰਗ ਮੂਲ ਤੌਰ 'ਤੇ ਹਰ ਸ਼੍ਰੇਣੀ ਨੂੰ ਇੱਕ ਨੰਬਰ ਵਿੱਚ ਬਦਲਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਹੈ। ਉਦਾਹਰਨ ਵਜੋਂ, ਮੰਨ ਲਓ ਕਿ ਸਾਡੇ ਕੋਲ ਏਅਰਲਾਈਨ ਯਾਤਰੀਆਂ ਦਾ ਡਾਟਾਸੈਟ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਇੱਕ ਕਾਲਮ ਹੈ ਜੋ ਉਨ੍ਹਾਂ ਦੀ ਕਲਾਸ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ ['ਬਿਜ਼ਨਸ ਕਲਾਸ', 'ਇਕਨਾਮੀ ਕਲਾਸ', 'ਫਰਸਟ ਕਲਾਸ'] ਵਿੱਚੋਂ। ਜੇ ਇਸ 'ਤੇ ਲੇਬਲ ਐਨਕੋਡਿੰਗ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਇਹ [0,1,2] ਵਿੱਚ ਬਦਲ ਜਾਵੇਗੀ। ਆਓ ਇਸ ਨੂੰ ਕੋਡ ਦੇ ਜਰੀਏ ਇੱਕ ਉਦਾਹਰਨ ਦੇ ਨਾਲ ਵੇਖੀਏ। ਕਿਉਂਕਿ ਅਸੀਂ ਅਗਲੇ ਨੋਟਬੁੱਕਸ ਵਿੱਚ `scikit-learn` ਸਿੱਖਣ ਜਾ ਰਹੇ ਹਾਂ, ਇਸ ਲਈ ਅਸੀਂ ਇਸਨੂੰ ਇੱਥੇ ਵਰਤਾਂਗੇ ਨਹੀਂ।\n" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "1vGz7uZyoWHL", "outputId": "9e252855-d193-4103-a54d-028ea7787b34" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
010business class
120first class
230economy class
340economy class
450economy class
560business class
\n", "
" ], "text/plain": [ " ID class\n", "0 10 business class\n", "1 20 first class\n", "2 30 economy class\n", "3 40 economy class\n", "4 50 economy class\n", "5 60 business class" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "label = pd.DataFrame([\n", " [10,'business class'],\n", " [20,'first class'],\n", " [30, 'economy class'],\n", " [40, 'economy class'],\n", " [50, 'economy class'],\n", " [60, 'business class']\n", "],columns=['ID','class'])\n", "label" ] }, { "cell_type": "markdown", "metadata": { "id": "IDHnkwTYov-h" }, "source": [ "ਪਹਿਲੇ ਕਾਲਮ 'ਤੇ ਲੇਬਲ ਐਨਕੋਡਿੰਗ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਪਹਿਲਾਂ ਹਰ ਕਲਾਸ ਤੋਂ ਇੱਕ ਨੰਬਰ ਤੱਕ ਮੈਪਿੰਗ ਦਾ ਵਰਣਨ ਕਰਨਾ ਪਵੇਗਾ, ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਬਦਲਿਆ ਜਾਵੇ।\n" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "ZC5URJG3o1ES", "outputId": "aab0f1e7-e0f3-4c14-8459-9f9168c85437" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
0100
1202
2301
3401
4501
5600
\n", "
" ], "text/plain": [ " ID class\n", "0 10 0\n", "1 20 2\n", "2 30 1\n", "3 40 1\n", "4 50 1\n", "5 60 0" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "class_labels = {'business class':0,'economy class':1,'first class':2}\n", "label['class'] = label['class'].replace(class_labels)\n", "label" ] }, { "cell_type": "markdown", "metadata": { "id": "ftnF-TyapOPt" }, "source": [ "ਜਿਵੇਂ ਕਿ ਅਸੀਂ ਦੇਖ ਸਕਦੇ ਹਾਂ, ਨਤੀਜਾ ਉਹੀ ਹੈ ਜੋ ਅਸੀਂ ਸੋਚਿਆ ਸੀ। ਤਾਂ, ਲੇਬਲ ਐਨਕੋਡਿੰਗ ਕਦੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ? ਲੇਬਲ ਐਨਕੋਡਿੰਗ ਹੇਠਾਂ ਦਿੱਤੇ ਦੋਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਜਾਂ ਦੋਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ:\n", "1. ਜਦੋਂ ਸ਼੍ਰੇਣੀਆਂ ਦੀ ਗਿਣਤੀ ਵੱਡੀ ਹੁੰਦੀ ਹੈ\n", "2. ਜਦੋਂ ਸ਼੍ਰੇਣੀਆਂ ਕ੍ਰਮ ਵਿੱਚ ਹੁੰਦੀਆਂ ਹਨ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "eQPAPVwsqWT7" }, "source": [ "**ਵਨ ਹਾਟ ਐਨਕੋਡਿੰਗ**\n", "\n", "ਵਨ ਹਾਟ ਐਨਕੋਡਿੰਗ ਇੱਕ ਹੋਰ ਕਿਸਮ ਦੀ ਐਨਕੋਡਿੰਗ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਦੀ ਐਨਕੋਡਿੰਗ ਵਿੱਚ, ਕਾਲਮ ਦੀ ਹਰ ਸ਼੍ਰੇਣੀ ਨੂੰ ਇੱਕ ਵੱਖਰੇ ਕਾਲਮ ਵਜੋਂ ਸ਼ਾਮਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਹਰ ਡੇਟਾਪੌਇੰਟ ਨੂੰ 0 ਜਾਂ 1 ਮਿਲਦਾ ਹੈ ਇਸ ਅਧਾਰ 'ਤੇ ਕਿ ਉਹ ਸ਼੍ਰੇਣੀ ਸ਼ਾਮਲ ਹੈ ਜਾਂ ਨਹੀਂ। ਇਸ ਲਈ, ਜੇ n ਵੱਖ-ਵੱਖ ਸ਼੍ਰੇਣੀਆਂ ਹਨ, ਤਾਂ n ਕਾਲਮ ਡੇਟਾਫਰੇਮ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਣਗੇ।\n", "\n", "ਉਦਾਹਰਨ ਵਜੋਂ, ਆਓ ਉਹੀ ਹਵਾਈ ਜਹਾਜ਼ ਕਲਾਸ ਦੀ ਉਦਾਹਰਨ ਲਵਾਂ। ਸ਼੍ਰੇਣੀਆਂ ਸਨ: ['ਬਿਜ਼ਨਸ ਕਲਾਸ', 'ਇਕਾਨਮੀ ਕਲਾਸ', 'ਫਰਸਟ ਕਲਾਸ']। ਇਸ ਲਈ, ਜੇ ਅਸੀਂ ਵਨ ਹਾਟ ਐਨਕੋਡਿੰਗ ਕਰਦੇ ਹਾਂ, ਤਾਂ ਡੇਟਾਸੈਟ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਤਿੰਨ ਕਾਲਮ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਣਗੇ: ['class_business class', 'class_economy class', 'class_first class']।\n" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "ZM0eVh0ArKUL", "outputId": "83238a76-b3a5-418d-c0b6-605b02b6891b" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass
010business class
120first class
230economy class
340economy class
450economy class
560business class
\n", "
" ], "text/plain": [ " ID class\n", "0 10 business class\n", "1 20 first class\n", "2 30 economy class\n", "3 40 economy class\n", "4 50 economy class\n", "5 60 business class" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "one_hot = pd.DataFrame([\n", " [10,'business class'],\n", " [20,'first class'],\n", " [30, 'economy class'],\n", " [40, 'economy class'],\n", " [50, 'economy class'],\n", " [60, 'business class']\n", "],columns=['ID','class'])\n", "one_hot" ] }, { "cell_type": "markdown", "metadata": { "id": "aVnZ7paDrWmb" }, "source": [ "ਆਓ ਪਹਿਲੇ ਕਾਲਮ 'ਤੇ ਇੱਕ ਹਾਟ ਕੋਡਿੰਗ ਕਰੀਏ।\n" ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "id": "RUPxf7egrYKr" }, "outputs": [], "source": [ "one_hot_data = pd.get_dummies(one_hot,columns=['class'])" ] }, { "cell_type": "code", "execution_count": 51, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 235 }, "id": "TM37pHsFr4ge", "outputId": "7be15f53-79b2-447a-979c-822658339a9e" }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
IDclass_business classclass_economy classclass_first class
010100
120001
230010
340010
450010
560100
\n", "
" ], "text/plain": [ " ID class_business class class_economy class class_first class\n", "0 10 1 0 0\n", "1 20 0 0 1\n", "2 30 0 1 0\n", "3 40 0 1 0\n", "4 50 0 1 0\n", "5 60 1 0 0" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "one_hot_data" ] }, { "cell_type": "markdown", "metadata": { "id": "_zXRLOjXujdA" }, "source": [ "ਹਰ ਇੱਕ ਹੌਟ ਐਨਕੋਡ ਕੀਤੀ ਕਾਲਮ ਵਿੱਚ 0 ਜਾਂ 1 ਹੁੰਦਾ ਹੈ, ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਉਹ ਸ਼੍ਰੇਣੀ ਉਸ ਡੇਟਾਪੌਇੰਟ ਲਈ ਮੌਜੂਦ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "bDnC4NQOu0qr" }, "source": [ "ਜਦੋਂ ਅਸੀਂ ਇੱਕ-ਹਾਟ ਐਨਕੋਡਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ? ਇੱਕ-ਹਾਟ ਐਨਕੋਡਿੰਗ ਦੀ ਵਰਤੋਂ ਹੇਠਾਂ ਦਿੱਤੇ ਦੋਨਾਂ ਵਿੱਚੋਂ ਕਿਸੇ ਇੱਕ ਜਾਂ ਦੋਨਾਂ ਹਾਲਤਾਂ ਵਿੱਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ:\n", "\n", "1. ਜਦੋਂ ਸ਼੍ਰੇਣੀਆਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਡਾਟਾਸੈੱਟ ਦਾ ਆਕਾਰ ਛੋਟਾ ਹੁੰਦਾ ਹੈ।\n", "2. ਜਦੋਂ ਸ਼੍ਰੇਣੀਆਂ ਕਿਸੇ ਖਾਸ ਕ੍ਰਮ ਦੀ ਪਾਲਣਾ ਨਹੀਂ ਕਰਦੀਆਂ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "XnUmci_4uvyu" }, "source": [ "> ਮੁੱਖ ਗੱਲਾਂ:\n", "1. ਐਨਕੋਡਿੰਗ ਗੈਰ-ਸੰਖਿਆਤਮਕ ਡਾਟਾ ਨੂੰ ਸੰਖਿਆਤਮਕ ਡਾਟਾ ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।\n", "2. ਐਨਕੋਡਿੰਗ ਦੇ ਦੋ ਪ੍ਰਕਾਰ ਹਨ: ਲੇਬਲ ਐਨਕੋਡਿੰਗ ਅਤੇ ਵਨ ਹਾਟ ਐਨਕੋਡਿੰਗ, ਜੋ ਡਾਟਾਸੈੱਟ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਦੇ ਅਧਾਰ 'ਤੇ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "K8UXOJYRgRsJ" }, "source": [ "## ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਹਟਾਉਣਾ\n", "\n", "> **ਸਿੱਖਣ ਦਾ ਉਦੇਸ਼:** ਇਸ ਉਪਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਸੀਂ DataFrames ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਦੀ ਪਹਿਚਾਣ ਅਤੇ ਹਟਾਉਣ ਵਿੱਚ ਸਹੀ ਹੋ ਜਾਣਗੇ।\n", "\n", "ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਅਕਸਰ ਅਸਲ-ਜਗਤ ਦੇ ਡਾਟਾਸੈਟਸ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, pandas ਡੁਪਲੀਕੇਟ ਐਂਟਰੀਜ਼ ਦੀ ਪਹਿਚਾਣ ਅਤੇ ਹਟਾਉਣ ਦਾ ਇੱਕ ਆਸਾਨ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।\n" ] }, { "cell_type": "markdown", "metadata": { "id": "qrEG-Wa0gRsJ" }, "source": [ "### ਨਕਲੀਆਂ ਪਛਾਣਣਾ: `duplicated`\n", "\n", "ਤੁਸੀਂ pandas ਵਿੱਚ `duplicated` ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਨਕਲੀਆਂ ਮੁੱਲਾਂ ਨੂੰ ਪਛਾਣ ਸਕਦੇ ਹੋ, ਜੋ ਇੱਕ ਬੂਲੀਅਨ ਮਾਸਕ ਵਾਪਸ ਕਰਦੀ ਹੈ ਜੋ ਦੱਸਦੀ ਹੈ ਕਿ ਕੀ `DataFrame` ਵਿੱਚ ਕੋਈ ਐਨਟਰੀ ਪਹਿਲਾਂ ਦੀ ਨਕਲ ਹੈ। ਆਓ ਇਸਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖਣ ਲਈ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ `DataFrame` ਬਣਾਈਏ।\n" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 204 }, "id": "ZLu6FEnZgRsJ", "outputId": "376512d1-d842-4db1-aea3-71052aeeecaf", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
2A1
3B3
4B3
\n", "
" ], "text/plain": [ " letters numbers\n", "0 A 1\n", "1 B 2\n", "2 A 1\n", "3 B 3\n", "4 B 3" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],\n", " 'numbers': [1, 2, 1, 3, 3]})\n", "example6" ] }, { "cell_type": "code", "execution_count": 53, "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "cIduB5oBgRsK", "outputId": "3da27b3d-4d69-4e1d-bb52-0af21bae87f2", "trusted": false }, "outputs": [ { "data": { "text/plain": [ "0 False\n", "1 False\n", "2 True\n", "3 False\n", "4 True\n", "dtype: bool" ] }, "execution_count": 53, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6.duplicated()" ] }, { "cell_type": "markdown", "metadata": { "id": "0eDRJD4SgRsK" }, "source": [ "### ਡੁਪਲੀਕੇਟ ਹਟਾਉਣਾ: `drop_duplicates`\n", "`drop_duplicates` ਸਿਰਫ ਉਸ ਡਾਟਾ ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਰੇ `duplicated` ਮੁੱਲ `False` ਹਨ:\n" ] }, { "cell_type": "code", "execution_count": 54, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 142 }, "id": "w_YPpqIqgRsK", "outputId": "ac66bd2f-8671-4744-87f5-8b8d96553dea", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
3B3
\n", "
" ], "text/plain": [ " letters numbers\n", "0 A 1\n", "1 B 2\n", "3 B 3" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6.drop_duplicates()" ] }, { "cell_type": "markdown", "metadata": { "id": "69AqoCZAgRsK" }, "source": [ "ਦੋਵੇਂ `duplicated` ਅਤੇ `drop_duplicates` ਮੂਲ ਰੂਪ ਵਿੱਚ ਸਾਰੇ ਕਾਲਮਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਦੇ ਹਨ ਪਰ ਤੁਸੀਂ ਨਿਰਧਾਰਿਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਉਹ ਤੁਹਾਡੇ `DataFrame` ਵਿੱਚ ਸਿਰਫ਼ ਕਾਲਮਾਂ ਦੇ ਇੱਕ ਉਪਸੈੱਟ ਦੀ ਜਾਂਚ ਕਰਨ:\n" ] }, { "cell_type": "code", "execution_count": 55, "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 111 }, "id": "BILjDs67gRsK", "outputId": "ef6dcc08-db8b-4352-c44e-5aa9e2bec0d3", "trusted": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
lettersnumbers
0A1
1B2
\n", "
" ], "text/plain": [ " letters numbers\n", "0 A 1\n", "1 B 2" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "example6.drop_duplicates(['letters'])" ] }, { "cell_type": "markdown", "metadata": { "id": "GvX4og1EgRsL" }, "source": [ "> **ਮੁੱਖ ਗੱਲ:** ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਨੂੰ ਹਟਾਉਣਾ ਲਗਭਗ ਹਰ ਡਾਟਾ-ਸਾਇੰਸ ਪ੍ਰੋਜੈਕਟ ਦਾ ਇੱਕ ਅਹਿਮ ਹਿੱਸਾ ਹੈ। ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਤੁਹਾਡੇ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਨਤੀਜੇ ਬਦਲ ਸਕਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਗਲਤ ਨਤੀਜੇ ਦੇ ਸਕਦਾ ਹੈ!\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ਅਸਲ-ਦੁਨੀਆ ਦੇ ਡਾਟਾ ਗੁਣਵੱਤਾ ਚੈੱਕ\n", "\n", "> **ਸਿੱਖਣ ਦਾ ਉਦੇਸ਼:** ਇਸ ਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਸੀਂ ਅਸਲ-ਦੁਨੀਆ ਦੇ ਡਾਟਾ ਗੁਣਵੱਤਾ ਦੇ ਆਮ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਪਛਾਣਨ ਅਤੇ ਠੀਕ ਕਰਨ ਵਿੱਚ ਸਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਅਸੰਗਤ ਸ਼੍ਰੇਣੀਮਾਨ ਮੁੱਲ, ਅਸਧਾਰਨ ਸੰਖਿਆਵਾਂ (ਆਊਟਲਾਇਰ), ਅਤੇ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਦੁਹਰਾਏ ਗਏ ਇਕਾਈਆਂ ਸ਼ਾਮਲ ਹਨ।\n", "\n", "ਜਦੋਂ ਕਿ ਗੁੰਮ ਹੋਏ ਮੁੱਲ ਅਤੇ ਸਹੀ ਦੁਹਰਾਏ ਗਏ ਡਾਟਾ ਆਮ ਸਮੱਸਿਆਵਾਂ ਹਨ, ਅਸਲ-ਦੁਨੀਆ ਦੇ ਡਾਟਾਸੈਟ ਵਿੱਚ ਅਕਸਰ ਹੋਰ ਸੁਖਮ ਸਮੱਸਿਆਵਾਂ ਹੁੰਦੀਆਂ ਹਨ:\n", "\n", "1. **ਅਸੰਗਤ ਸ਼੍ਰੇਣੀਮਾਨ ਮੁੱਲ**: ਇੱਕੋ ਸ਼੍ਰੇਣੀ ਨੂੰ ਵੱਖ-ਵੱਖ ਤਰੀਕਿਆਂ ਨਾਲ ਲਿਖਿਆ ਗਿਆ (ਜਿਵੇਂ, \"USA\", \"U.S.A\", \"United States\")\n", "2. **ਅਸਧਾਰਨ ਸੰਖਿਆਵਾਂ**: ਬਹੁਤ ਜ਼ਿਆਦਾ ਆਊਟਲਾਇਰ ਜੋ ਡਾਟਾ ਐਂਟਰੀ ਦੀ ਗਲਤੀ ਦਰਸਾਉਂਦੇ ਹਨ (ਜਿਵੇਂ, ਉਮਰ = 999)\n", "3. **ਨਜ਼ਦੀਕੀ-ਦੁਹਰਾਏ ਗਏ ਪੰਨੇ**: ਰਿਕਾਰਡ ਜੋ ਇੱਕੋ ਹੀ ਇਕਾਈ ਨੂੰ ਦਰਸਾਉਂਦੇ ਹਨ ਪਰ ਥੋੜ੍ਹੇ ਬਦਲਾਅ ਨਾਲ\n", "\n", "ਆਓ, ਇਨ੍ਹਾਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਪਛਾਣਨ ਅਤੇ ਹੱਲ ਕਰਨ ਦੇ ਤਰੀਕਿਆਂ ਦੀ ਜਾਂਚ ਕਰੀਏ।\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### \"ਗੰਦੇ\" ਡਾਟਾਸੈੱਟ ਬਣਾਉਣਾ\n", "\n", "ਸਭ ਤੋਂ ਪਹਿਲਾਂ, ਆਓ ਇੱਕ ਨਮੂਨਾ ਡਾਟਾਸੈੱਟ ਬਣਾਈਏ ਜਿਸ ਵਿੱਚ ਉਹ ਸਮੱਸਿਆਵਾਂ ਸ਼ਾਮਲ ਹਨ ਜੋ ਅਸੀਂ ਅਕਸਰ ਅਸਲ-ਦੁਨੀਆ ਦੇ ਡਾਟਾ ਵਿੱਚ ਵੇਖਦੇ ਹਾਂ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", "\n", "# Create a sample dataset with quality issues\n", "dirty_data = pd.DataFrame({\n", " 'customer_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12],\n", " 'name': ['John Smith', 'Jane Doe', 'John Smith', 'Bob Johnson', \n", " 'Alice Williams', 'Charlie Brown', 'John Smith', 'Eva Martinez',\n", " 'Bob Johnson', 'Diana Prince', 'Frank Castle', 'Alice Williams'],\n", " 'age': [25, 32, 25, 45, 28, 199, 25, 31, 45, 27, -5, 28],\n", " 'country': ['USA', 'UK', 'U.S.A', 'Canada', 'USA', 'United Kingdom',\n", " 'United States', 'Mexico', 'canada', 'USA', 'UK', 'usa'],\n", " 'purchase_amount': [100.50, 250.00, 105.00, 320.00, 180.00, 90.00,\n", " 102.00, 275.00, 325.00, 195.00, 410.00, 185.00]\n", "})\n", "\n", "print(\"Sample 'Dirty' Dataset:\")\n", "print(dirty_data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 1. ਅਸੰਗਤ ਸ਼੍ਰੇਣੀਮਾਨ ਮੁੱਲਾਂ ਦੀ ਪਹਿਚਾਣ\n", "\n", "ਧਿਆਨ ਦਿਓ ਕਿ `country` ਕਾਲਮ ਵਿੱਚ ਇੱਕੋ ਦੇਸ਼ਾਂ ਲਈ ਕਈ ਵੱਖ-ਵੱਖ ਪ੍ਰਸਤੁਤੀਆਂ ਹਨ। ਆਓ ਇਨ੍ਹਾਂ ਅਸੰਗਤਤਾਵਾਂ ਦੀ ਪਹਿਚਾਣ ਕਰੀਏ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Check unique values in the country column\n", "print(\"Unique country values:\")\n", "print(dirty_data['country'].unique())\n", "print(f\"\\nTotal unique values: {dirty_data['country'].nunique()}\")\n", "\n", "# Count occurrences of each variation\n", "print(\"\\nValue counts:\")\n", "print(dirty_data['country'].value_counts())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### ਸ਼੍ਰੇਣੀਬੱਧ ਮੁੱਲਾਂ ਨੂੰ ਮਿਆਰੀਕਰਣ\n", "\n", "ਅਸੀਂ ਇਨ੍ਹਾਂ ਮੁੱਲਾਂ ਨੂੰ ਮਿਆਰੀਕਰਣ ਲਈ ਇੱਕ ਮੈਪਿੰਗ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦੇ ਹਾਂ। ਇੱਕ ਸਧਾਰਨ ਤਰੀਕਾ ਇਹ ਹੈ ਕਿ ਮੁੱਲਾਂ ਨੂੰ ਛੋਟੇ ਅੱਖਰਾਂ ਵਿੱਚ ਬਦਲਿਆ ਜਾਵੇ ਅਤੇ ਇੱਕ ਮੈਪਿੰਗ ਡਿਕਸ਼ਨਰੀ ਬਣਾਈ ਜਾਵੇ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Create a standardization mapping\n", "country_mapping = {\n", " 'usa': 'USA',\n", " 'u.s.a': 'USA',\n", " 'united states': 'USA',\n", " 'uk': 'UK',\n", " 'united kingdom': 'UK',\n", " 'canada': 'Canada',\n", " 'mexico': 'Mexico'\n", "}\n", "\n", "# Standardize the country column\n", "dirty_data['country_clean'] = dirty_data['country'].str.lower().map(country_mapping)\n", "\n", "print(\"Before standardization:\")\n", "print(dirty_data['country'].value_counts())\n", "print(\"\\nAfter standardization:\")\n", "print(dirty_data[['country_clean']].value_counts())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**ਵਿਕਲਪ: ਫਜ਼ੀ ਮੈਚਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਨਾ**\n", "\n", "ਜਟਿਲ ਮਾਮਲਿਆਂ ਲਈ, ਅਸੀਂ `rapidfuzz` ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਫਜ਼ੀ ਸਟ੍ਰਿੰਗ ਮੈਚਿੰਗ ਕਰ ਸਕਦੇ ਹਾਂ, ਜੋ ਸਵੈਚਾਲਿਤ ਤੌਰ 'ਤੇ ਸਮਾਨ ਸਟ੍ਰਿੰਗਾਂ ਦੀ ਪਛਾਣ ਕਰਦੀ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " from rapidfuzz import process, fuzz\n", "except ImportError:\n", " print(\"rapidfuzz is not installed. Please install it with 'pip install rapidfuzz' to use fuzzy matching.\")\n", " process = None\n", " fuzz = None\n", "\n", "# Get unique countries\n", "unique_countries = dirty_data['country'].unique()\n", "\n", "# For each country, find similar matches\n", "if process is not None and fuzz is not None:\n", " print(\"Finding similar country names (similarity > 70%):\")\n", " for country in unique_countries:\n", " matches = process.extract(country, unique_countries, scorer=fuzz.ratio, limit=3)\n", " # Filter matches with similarity > 70 and not identical\n", " similar = [m for m in matches if m[1] > 70 and m[0] != country]\n", " if similar:\n", " print(f\"\\n'{country}' is similar to:\")\n", " for match, score, _ in similar:\n", " print(f\" - '{match}' (similarity: {score}%)\")\n", "else:\n", " print(\"Skipping fuzzy matching because rapidfuzz is not available.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 2. ਅਸਧਾਰਨ ਗਿਣਤੀ ਮੁੱਲਾਂ (ਆਊਟਲਾਇਰ) ਦੀ ਪਹਿਚਾਣ\n", "\n", "`age` ਕਾਲਮ ਨੂੰ ਦੇਖਦੇ ਹੋਏ, ਸਾਡੇ ਕੋਲ ਕੁਝ ਸ਼ੱਕੀ ਮੁੱਲ ਹਨ ਜਿਵੇਂ 199 ਅਤੇ -5। ਆਓ, ਇਨ੍ਹਾਂ ਆਊਟਲਾਇਰਾਂ ਦੀ ਪਹਿਚਾਣ ਕਰਨ ਲਈ ਸਾਂਖਿਆਕੀ ਤਰੀਕੇ ਵਰਤਦੇ ਹਾਂ।\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Display basic statistics\n", "print(\"Age column statistics:\")\n", "print(dirty_data['age'].describe())\n", "\n", "# Identify impossible values using domain knowledge\n", "print(\"\\nRows with impossible age values (< 0 or > 120):\")\n", "impossible_ages = dirty_data[(dirty_data['age'] < 0) | (dirty_data['age'] > 120)]\n", "print(impossible_ages[['customer_id', 'name', 'age']])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### IQR (ਇੰਟਰਕਵਾਰਟਾਈਲ ਰੇਂਜ) ਵਿਧੀ ਦੀ ਵਰਤੋਂ\n", "\n", "IQR ਵਿਧੀ ਇੱਕ ਮਜ਼ਬੂਤ ਸਾਂਖਿਆਕੀ ਤਕਨੀਕ ਹੈ ਜੋ ਅਤਿ ਮੁੱਲਾਂ ਲਈ ਘੱਟ ਸੰਵੇਦਨਸ਼ੀਲ ਹੈ ਅਤੇ ਆਉਟਲਾਇਰ ਪਛਾਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Calculate IQR for age (excluding impossible values)\n", "valid_ages = dirty_data[(dirty_data['age'] >= 0) & (dirty_data['age'] <= 120)]['age']\n", "\n", "Q1 = valid_ages.quantile(0.25)\n", "Q3 = valid_ages.quantile(0.75)\n", "IQR = Q3 - Q1\n", "\n", "# Define outlier bounds\n", "lower_bound = Q1 - 1.5 * IQR\n", "upper_bound = Q3 + 1.5 * IQR\n", "\n", "print(f\"IQR-based outlier bounds for age: [{lower_bound:.2f}, {upper_bound:.2f}]\")\n", "\n", "# Identify outliers\n", "age_outliers = dirty_data[(dirty_data['age'] < lower_bound) | (dirty_data['age'] > upper_bound)]\n", "print(f\"\\nRows with age outliers:\")\n", "print(age_outliers[['customer_id', 'name', 'age']])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Z-ਸਕੋਰ ਵਿਧੀ ਦੀ ਵਰਤੋਂ\n", "\n", "Z-ਸਕੋਰ ਵਿਧੀ ਮੀਨ ਤੋਂ ਸਟੈਂਡਰਡ ਡਿਵਿਏਸ਼ਨ ਦੇ ਆਧਾਰ 'ਤੇ ਆਉਟਲਾਇਰਜ਼ ਦੀ ਪਹਿਚਾਣ ਕਰਦੀ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " from scipy import stats\n", "except ImportError:\n", " print(\"scipy is required for Z-score calculation. Please install it with 'pip install scipy' and rerun this cell.\")\n", "else:\n", " # Calculate Z-scores for age, handling NaN values\n", " age_nonan = dirty_data['age'].dropna()\n", " zscores = np.abs(stats.zscore(age_nonan))\n", " dirty_data['age_zscore'] = np.nan\n", " dirty_data.loc[age_nonan.index, 'age_zscore'] = zscores\n", "\n", " # Typically, Z-score > 3 indicates an outlier\n", " print(\"Rows with age Z-score > 3:\")\n", " zscore_outliers = dirty_data[dirty_data['age_zscore'] > 3]\n", " print(zscore_outliers[['customer_id', 'name', 'age', 'age_zscore']])\n", "\n", " # Clean up the temporary column\n", " dirty_data = dirty_data.drop('age_zscore', axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### ਆਉਟਲਾਇਰਸ ਦਾ ਸੰਭਾਲ\n", "\n", "ਜਦੋਂ ਪਛਾਣ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਆਉਟਲਾਇਰਸ ਨੂੰ ਕਈ ਤਰੀਕਿਆਂ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾ ਸਕਦਾ ਹੈ:\n", "1. **ਹਟਾਓ**: ਆਉਟਲਾਇਰਸ ਵਾਲੀਆਂ ਪੰਗਤਾਂ ਨੂੰ ਹਟਾਓ (ਜੇ ਇਹ ਗਲਤੀਆਂ ਹਨ)\n", "2. **ਸੀਮਾ ਲਗਾਓ**: ਸੀਮਾਵੀ ਮੁੱਲਾਂ ਨਾਲ ਬਦਲੋ\n", "3. **NaN ਨਾਲ ਬਦਲੋ**: ਇਸਨੂੰ ਗੁੰਮ ਹੋਏ ਡਾਟਾ ਵਜੋਂ ਮੰਨੋ ਅਤੇ ਭਰਨ ਦੀਆਂ ਤਕਨੀਕਾਂ ਵਰਤੋ\n", "4. **ਰੱਖੋ**: ਜੇ ਇਹ ਵਾਸਤਵਿਕ ਤੌਰ 'ਤੇ ਅਤਿ ਮੁੱਲ ਹਨ\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Create a cleaned version by replacing impossible ages with NaN\n", "dirty_data['age_clean'] = dirty_data['age'].apply(\n", " lambda x: np.nan if (x < 0 or x > 120) else x\n", ")\n", "\n", "print(\"Age column before and after cleaning:\")\n", "print(dirty_data[['customer_id', 'name', 'age', 'age_clean']])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3. ਨਜ਼ਦੀਕੀ-ਡੁਪਲੀਕੇਟ ਪੰਗਤਾਂ ਦੀ ਪਹਿਚਾਣ\n", "\n", "ਧਿਆਨ ਦਿਓ ਕਿ ਸਾਡੇ ਡਾਟਾਸੈਟ ਵਿੱਚ \"John Smith\" ਲਈ ਕਈ ਐਂਟਰੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਥੋੜ੍ਹਾ ਜਿਹਾ ਅੰਤਰ ਹੈ। ਆਓ ਨਾਮ ਦੀ ਸਮਾਨਤਾ ਦੇ ਆਧਾਰ 'ਤੇ ਸੰਭਾਵਿਤ ਡੁਪਲੀਕੇਟਾਂ ਦੀ ਪਹਿਚਾਣ ਕਰੀਏ।\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# First, let's look at exact name matches (ignoring extra whitespace)\n", "dirty_data['name_normalized'] = dirty_data['name'].str.strip().str.lower()\n", "\n", "print(\"Checking for duplicate names:\")\n", "duplicate_names = dirty_data[dirty_data.duplicated(['name_normalized'], keep=False)]\n", "print(duplicate_names.sort_values('name_normalized')[['customer_id', 'name', 'age', 'country']])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### ਫਜ਼ੀ ਮੈਚਿੰਗ ਨਾਲ ਨਜ਼ਦੀਕੀ ਡੁਪਲੀਕੇਟ ਲੱਭਣਾ\n", "\n", "ਜਿਆਦਾ ਉੱਚੇ ਪੱਧਰ ਦੇ ਡੁਪਲੀਕੇਟ ਪਛਾਣ ਲਈ, ਅਸੀਂ ਫਜ਼ੀ ਮੈਚਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹਾਂ ਜੋ ਮਿਲਦੇ-ਜੁਲਦੇ ਨਾਮ ਲੱਭਣ ਵਿੱਚ ਮਦਦ ਕਰਦੀ ਹੈ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "try:\n", " from rapidfuzz import process, fuzz\n", "\n", " # Function to find potential duplicates\n", " def find_near_duplicates(df, column, threshold=90):\n", " \"\"\"\n", " Find near-duplicate entries in a column using fuzzy matching.\n", " \n", " Parameters:\n", " - df: DataFrame\n", " - column: Column name to check for duplicates\n", " - threshold: Similarity threshold (0-100)\n", " \n", " Returns: List of potential duplicate groups\n", " \"\"\"\n", " values = df[column].unique()\n", " duplicate_groups = []\n", " checked = set()\n", " \n", " for value in values:\n", " if value in checked:\n", " continue\n", " \n", " # Find similar values\n", " matches = process.extract(value, values, scorer=fuzz.ratio, limit=len(values))\n", " similar = [m[0] for m in matches if m[1] >= threshold]\n", " \n", " if len(similar) > 1:\n", " duplicate_groups.append(similar)\n", " checked.update(similar)\n", " \n", " return duplicate_groups\n", "\n", " # Find near-duplicate names\n", " duplicate_groups = find_near_duplicates(dirty_data, 'name', threshold=90)\n", "\n", " print(\"Potential duplicate groups:\")\n", " for i, group in enumerate(duplicate_groups, 1):\n", " print(f\"\\nGroup {i}:\")\n", " for name in group:\n", " matching_rows = dirty_data[dirty_data['name'] == name]\n", " print(f\" '{name}': {len(matching_rows)} occurrence(s)\")\n", " for _, row in matching_rows.iterrows():\n", " print(f\" - Customer {row['customer_id']}: age={row['age']}, country={row['country']}\")\n", "except ImportError:\n", " print(\"rapidfuzz is not installed. Skipping fuzzy matching for near-duplicates.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### ਡੁਪਲੀਕੇਟਸ ਨੂੰ ਸੰਭਾਲਣਾ\n", "\n", "ਜਦੋਂ ਪਛਾਣ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਨੂੰ ਫੈਸਲਾ ਕਰਨਾ ਪਵੇਗਾ ਕਿ ਡੁਪਲੀਕੇਟਸ ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਣਾ ਹੈ:\n", "1. **ਪਹਿਲੀ ਵਾਰ ਨੂੰ ਰੱਖੋ**: `drop_duplicates(keep='first')` ਵਰਤੋ\n", "2. **ਆਖਰੀ ਵਾਰ ਨੂੰ ਰੱਖੋ**: `drop_duplicates(keep='last')` ਵਰਤੋ\n", "3. **ਜਾਣਕਾਰੀ ਨੂੰ ਇਕੱਠਾ ਕਰੋ**: ਡੁਪਲੀਕੇਟ ਪੰਨਿਆਂ ਤੋਂ ਜਾਣਕਾਰੀ ਨੂੰ ਜੋੜੋ\n", "4. **ਹੱਥੋਂ ਸਮੀਖਾ**: ਮਨੁੱਖੀ ਸਮੀਖਾ ਲਈ ਚਿੰਨ੍ਹਿਤ ਕਰੋ\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Example: Remove duplicates based on normalized name, keeping first occurrence\n", "cleaned_data = dirty_data.drop_duplicates(subset=['name_normalized'], keep='first')\n", "\n", "print(f\"Original dataset: {len(dirty_data)} rows\")\n", "print(f\"After removing name duplicates: {len(cleaned_data)} rows\")\n", "print(f\"Removed: {len(dirty_data) - len(cleaned_data)} duplicate rows\")\n", "\n", "print(\"\\nCleaned dataset:\")\n", "print(cleaned_data[['customer_id', 'name', 'age', 'country_clean']])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### ਸਾਰ: ਪੂਰੀ ਡਾਟਾ ਕਲੀਨਿੰਗ ਪਾਈਪਲਾਈਨ\n", "\n", "ਆਓ ਇਸਨੂੰ ਇੱਕ ਸੰਪੂਰਨ ਕਲੀਨਿੰਗ ਪਾਈਪਲਾਈਨ ਵਿੱਚ ਇਕੱਠਾ ਕਰੀਏ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def clean_dataset(df):\n", " \"\"\"\n", " Comprehensive data cleaning function.\n", " \"\"\"\n", " # Create a copy to avoid modifying the original\n", " cleaned = df.copy()\n", " \n", " # 1. Standardize categorical values (country)\n", " country_mapping = {\n", " 'usa': 'USA', 'u.s.a': 'USA', 'united states': 'USA',\n", " 'uk': 'UK', 'united kingdom': 'UK',\n", " 'canada': 'Canada', 'mexico': 'Mexico'\n", " }\n", " cleaned['country'] = cleaned['country'].str.lower().map(country_mapping)\n", " \n", " # 2. Clean abnormal age values\n", " cleaned['age'] = cleaned['age'].apply(\n", " lambda x: np.nan if (x < 0 or x > 120) else x\n", " )\n", " \n", " # 3. Remove near-duplicate names (normalize whitespace)\n", " cleaned['name'] = cleaned['name'].str.strip()\n", " cleaned = cleaned.drop_duplicates(subset=['name'], keep='first')\n", " \n", " return cleaned\n", "\n", "# Apply the cleaning pipeline\n", "final_cleaned_data = clean_dataset(dirty_data)\n", "\n", "print(\"Before cleaning:\")\n", "print(f\" Rows: {len(dirty_data)}\")\n", "print(f\" Unique countries: {dirty_data['country'].nunique()}\")\n", "print(f\" Invalid ages: {((dirty_data['age'] < 0) | (dirty_data['age'] > 120)).sum()}\")\n", "\n", "print(\"\\nAfter cleaning:\")\n", "print(f\" Rows: {len(final_cleaned_data)}\")\n", "print(f\" Unique countries: {final_cleaned_data['country'].nunique()}\")\n", "print(f\" Invalid ages: {((final_cleaned_data['age'] < 0) | (final_cleaned_data['age'] > 120)).sum()}\")\n", "\n", "print(\"\\nCleaned dataset:\")\n", "print(final_cleaned_data[['customer_id', 'name', 'age', 'country', 'purchase_amount']])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 🎯 ਚੁਣੌਤੀ ਅਭਿਆਸ\n", "\n", "ਹੁਣ ਤੁਹਾਡੀ ਵਾਰੀ ਹੈ! ਹੇਠਾਂ ਦਿੱਤੇ ਡਾਟਾ ਦੀ ਇੱਕ ਨਵੀਂ ਪੰਗਤੀ ਹੈ ਜਿਸ ਵਿੱਚ ਕਈ ਗੁਣਵੱਤਾ ਸਮੱਸਿਆਵਾਂ ਹਨ। ਕੀ ਤੁਸੀਂ:\n", "\n", "1. ਇਸ ਪੰਗਤੀ ਵਿੱਚ ਸਾਰੀਆਂ ਸਮੱਸਿਆਵਾਂ ਦੀ ਪਛਾਣ ਕਰ ਸਕਦੇ ਹੋ\n", "2. ਹਰ ਸਮੱਸਿਆ ਨੂੰ ਸਾਫ ਕਰਨ ਲਈ ਕੋਡ ਲਿਖ ਸਕਦੇ ਹੋ\n", "3. ਸਾਫ ਕੀਤੀ ਪੰਗਤੀ ਨੂੰ ਡਾਟਾਸੈੱਟ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ\n", "\n", "ਇਹ ਹੈ ਸਮੱਸਿਆਪੂਰਣ ਡਾਟਾ:\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# New problematic row\n", "new_row = pd.DataFrame({\n", " 'customer_id': [13],\n", " 'name': [' Diana Prince '], # Extra whitespace\n", " 'age': [250], # Impossible age\n", " 'country': ['U.S.A.'], # Inconsistent format\n", " 'purchase_amount': [150.00]\n", "})\n", "\n", "print(\"New row to clean:\")\n", "print(new_row)\n", "\n", "# TODO: Your code here to clean this row\n", "# Hints:\n", "# 1. Strip whitespace from the name\n", "# 2. Check if the name is a duplicate (Diana Prince already exists)\n", "# 3. Handle the impossible age value\n", "# 4. Standardize the country name\n", "\n", "# Example solution (uncomment and modify as needed):\n", "# new_row_cleaned = new_row.copy()\n", "# new_row_cleaned['name'] = new_row_cleaned['name'].str.strip()\n", "# new_row_cleaned['age'] = np.nan # Invalid age\n", "# new_row_cleaned['country'] = 'USA' # Standardized\n", "# print(\"\\nCleaned row:\")\n", "# print(new_row_cleaned)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### ਮੁੱਖ ਗੱਲਾਂ\n", "\n", "1. **ਅਸਥਿਰ ਸ਼੍ਰੇਣੀਆਂ** ਅਕਸਰ ਅਸਲ-ਜਗਤ ਦੇ ਡਾਟਾ ਵਿੱਚ ਮਿਲਦੀਆਂ ਹਨ। ਹਮੇਸ਼ਾ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਉਨ੍ਹਾਂ ਨੂੰ ਮੈਪਿੰਗ ਜਾਂ ਫਜ਼ੀ ਮੈਚਿੰਗ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਧਾਰਨ ਬਣਾਓ।\n", "\n", "2. **ਆਊਟਲਾਇਰਸ** ਤੁਹਾਡੇ ਵਿਸ਼ਲੇਸ਼ਣ 'ਤੇ ਗੰਭੀਰ ਪ੍ਰਭਾਵ ਪਾ ਸਕਦੇ ਹਨ। ਉਨ੍ਹਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਡੋਮੇਨ ਗਿਆਨ ਨੂੰ ਸਾਂਖਿਆਕੀ ਤਰੀਕਿਆਂ (IQR, Z-score) ਨਾਲ ਜੋੜੋ।\n", "\n", "3. **ਨਜ਼ਦੀਕੀ-ਡੁਪਲੀਕੇਟਸ** ਸਹੀ ਡੁਪਲੀਕੇਟਸ ਨਾਲੋਂ ਪਛਾਣ ਕਰਨਾ ਔਖਾ ਹੁੰਦਾ ਹੈ। ਫਜ਼ੀ ਮੈਚਿੰਗ ਅਤੇ ਡਾਟਾ ਨੂੰ ਨਾਰਮਲਾਈਜ਼ (ਲੋਅਰਕੇਸਿੰਗ, ਵ੍ਹਾਈਟਸਪੇਸ ਹਟਾਉਣਾ) ਕਰਨ ਦੀ ਵਿਚਾਰ ਕਰੋ।\n", "\n", "4. **ਡਾਟਾ ਸਾਫ਼ ਕਰਨਾ ਦੁਹਰਾਉਣਯੋਗ ਹੈ।** ਤੁਹਾਨੂੰ ਕਈ ਤਕਨੀਕਾਂ ਲਾਗੂ ਕਰਨੀਆਂ ਪੈ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਆਪਣੇ ਸਾਫ਼ ਕੀਤੇ ਡਾਟਾਸੈਟ ਨੂੰ ਅੰਤਮ ਰੂਪ ਦੇਣ ਤੋਂ ਪਹਿਲਾਂ ਨਤੀਜਿਆਂ ਦੀ ਸਮੀਖਿਆ ਕਰਨੀ ਪੈ ਸਕਦੀ ਹੈ।\n", "\n", "5. **ਆਪਣੇ ਫੈਸਲੇ ਦਸਤਾਵੇਜ਼ ਕਰੋ।** ਤੁਸੀਂ ਕਿਹੜੇ ਸਾਫ਼ ਕਰਨ ਦੇ ਕਦਮ ਲਾਗੂ ਕੀਤੇ ਅਤੇ ਕਿਉਂ, ਇਸ ਨੂੰ ਟਰੈਕ ਕਰਨਾ ਮੁਹੱਤਵਪੂਰਨ ਹੈ, ਤਾਂ ਜੋ ਦੁਬਾਰਾ ਬਣਾਉਣ ਅਤੇ ਪਾਰਦਰਸ਼ਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਇਆ ਜਾ ਸਕੇ।\n", "\n", "> **ਸਰਵੋਤਮ ਅਭਿਆਸ:** ਹਮੇਸ਼ਾ ਆਪਣੇ ਅਸਲ \"ਗੰਦੇ\" ਡਾਟਾ ਦੀ ਇੱਕ ਕਾਪੀ ਰੱਖੋ। ਆਪਣੇ ਸਰੋਤ ਡਾਟਾ ਫਾਈਲਾਂ ਨੂੰ ਕਦੇ ਵੀ ਓਵਰਰਾਈਟ ਨਾ ਕਰੋ - ਸਾਫ਼ ਕੀਤੇ ਵਰਜਨ ਬਣਾਓ ਜਿਨ੍ਹਾਂ ਦੇ ਸਪਸ਼ਟ ਨਾਮਕਰਨ ਜਿਵੇਂ `data_cleaned.csv` ਹੋਵੇ।\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n---\n\n**ਅਸਵੀਕਰਤਾ**: \nਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀ ਹੋਣ ਦਾ ਯਤਨ ਕਰਦੇ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚੱਜੇਪਣ ਹੋ ਸਕਦੇ ਹਨ। ਇਸ ਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਮੌਜੂਦ ਅਸਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।\n" ] } ], "metadata": { "anaconda-cloud": {}, "colab": { "name": "notebook.ipynb", "provenance": [] }, "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.5.4" }, "coopTranslator": { "original_hash": "6301339d1c9a301b00639c635dc9b731", "translation_date": "2025-10-03T19:50:09+00:00", "source_file": "2-Working-With-Data/08-data-preparation/notebook.ipynb", "language_code": "pa" } }, "nbformat": 4, "nbformat_minor": 0 }