Data-Science-For-Beginners/translations/pa/2-Working-With-Data/08-data-preparation

ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਨਾ: ਡਾਟਾ ਤਿਆਰੀ

](../../sketchnotes/08-DataPreparation.png)
ਡਾਟਾ ਤਿਆਰੀ - @nitya ਦੁਆਰਾ ਸਕੈਚਨੋਟ

ਪ੍ਰੀ-ਲੈਕਚਰ ਕਵਿਜ਼

ਡਾਟਾ ਦੇ ਸਰੋਤ ਦੇ ਅਧਾਰ 'ਤੇ, ਕੱਚਾ ਡਾਟਾ ਕੁਝ ਅਸੰਗਤਤਾਵਾਂ ਰੱਖ ਸਕਦਾ ਹੈ ਜੋ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਮਾਡਲਿੰਗ ਵਿੱਚ ਚੁਣੌਤੀਆਂ ਪੈਦਾ ਕਰਦੇ ਹਨ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇਸ ਡਾਟਾ ਨੂੰ "ਗੰਦਾ" ਕਹਿ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇਸ ਪਾਠ ਵਿੱਚ ਗੁੰਮ, ਗਲਤ, ਜਾਂ ਅਧੂਰੇ ਡਾਟਾ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਡਾਟਾ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਅਤੇ ਰੂਪਾਂਤਰਿਤ ਕਰਨ ਦੀਆਂ ਤਕਨੀਕਾਂ 'ਤੇ ਧਿਆਨ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਇਸ ਪਾਠ ਵਿੱਚ ਕਵਰ ਕੀਤੇ ਗਏ ਵਿਸ਼ਿਆਂ ਨੂੰ Python ਅਤੇ Pandas ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਨੋਟਬੁੱਕ ਵਿੱਚ ਦਰਸਾਇਆ ਜਾਵੇਗਾ।

ਡਾਟਾ ਸਾਫ਼ ਕਰਨ ਦੀ ਮਹੱਤਤਾ

• ਵਰਤੋਂ ਅਤੇ ਦੁਬਾਰਾ ਵਰਤੋਂ ਦੀ ਸਹੂਲਤ: ਜਦੋਂ ਡਾਟਾ ਢੰਗ ਨਾਲ ਸੰਗਠਿਤ ਅਤੇ ਸਧਾਰਨ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਨੂੰ ਖੋਜਣਾ, ਵਰਤਣਾ ਅਤੇ ਹੋਰਾਂ ਨਾਲ ਸਾਂਝਾ ਕਰਨਾ ਆਸਾਨ ਹੁੰਦਾ ਹੈ।

• ਸਥਿਰਤਾ: ਡਾਟਾ ਸਾਇੰਸ ਅਕਸਰ ਇੱਕ ਤੋਂ ਵੱਧ ਡਾਟਾਸੈਟ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਪੈਂਦੀ ਹੈ, ਜਿੱਥੇ ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ ਤੋਂ ਡਾਟਾਸੈਟ ਨੂੰ ਇਕੱਠੇ ਜੋੜਨਾ ਪੈਂਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਹਰ ਵਿਅਕਤੀਗਤ ਡਾਟਾਸੈਟ ਵਿੱਚ ਆਮ ਮਿਆਰਕਰਨ ਹੈ, ਇਹ ਯਕੀਨੀ ਬਣਾਉਵੇਗਾ ਕਿ ਜਦੋਂ ਇਹ ਸਾਰੇ ਡਾਟਾ ਇੱਕ ਡਾਟਾਸੈਟ ਵਿੱਚ ਮਿਲਦੇ ਹਨ, ਤਾਂ ਇਹ ਹਾਲੇ ਵੀ ਉਪਯੋਗੀ ਹੈ।

• ਮਾਡਲ ਦੀ ਸ਼ੁੱਧਤਾ: ਸਾਫ਼ ਕੀਤਾ ਗਿਆ ਡਾਟਾ ਉਹ ਮਾਡਲਾਂ ਦੀ ਸ਼ੁੱਧਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ਜੋ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ।

ਆਮ ਸਾਫ਼ ਕਰਨ ਦੇ ਲਕਸ਼ ਅਤੇ ਰਣਨੀਤੀਆਂ

• ਡਾਟਾਸੈਟ ਦੀ ਖੋਜ: ਡਾਟਾ ਖੋਜ, ਜੋ ਅਗਲੇ ਪਾਠ ਵਿੱਚ ਕਵਰ ਕੀਤੀ ਗਈ ਹੈ, ਤੁਹਾਨੂੰ ਉਹ ਡਾਟਾ ਖੋਜਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੀ ਹੈ ਜਿਸਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਡਾਟਾਸੈਟ ਵਿੱਚ ਮੌਜੂਦ ਮੁੱਲਾਂ ਨੂੰ ਵਿਜ਼ੂਅਲ ਤੌਰ 'ਤੇ ਦੇਖਣਾ ਇਹ ਅਨੁਮਾਨ ਲਗਾ ਸਕਦਾ ਹੈ ਕਿ ਬਾਕੀ ਡਾਟਾ ਕਿਵੇਂ ਲੱਗੇਗਾ, ਜਾਂ ਉਹ ਸਮੱਸਿਆਵਾਂ ਦੇ ਵਿਚਾਰ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਹੱਲ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਖੋਜ ਵਿੱਚ ਬੁਨਿਆਦੀ ਪੁੱਛਗਿੱਛ, ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ, ਅਤੇ ਸੈਂਪਲਿੰਗ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀ ਹੈ।

• ਫਾਰਮੈਟਿੰਗ: ਸਰੋਤ ਦੇ ਅਧਾਰ 'ਤੇ, ਡਾਟਾ ਵਿੱਚ ਇਸ ਦੇ ਪੇਸ਼ ਕਰਨ ਦੇ ਤਰੀਕੇ ਵਿੱਚ ਅਸੰਗਤਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਇਹ ਮੁੱਲ ਦੀ ਖੋਜ ਅਤੇ ਪ੍ਰਸਤੁਤੀ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਇਹ ਡਾਟਾਸੈਟ ਵਿੱਚ ਵੇਖਿਆ ਜਾਂਦਾ ਹੈ ਪਰ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਜਾਂ ਪੁੱਛਗਿੱਛ ਦੇ ਨਤੀਜਿਆਂ ਵਿੱਚ ਢੰਗ ਨਾਲ ਪ੍ਰਸਤੁਤ ਨਹੀਂ ਹੁੰਦਾ। ਆਮ ਫਾਰਮੈਟਿੰਗ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਵ੍ਹਾਈਟਸਪੇਸ, ਮਿਤੀਆਂ, ਅਤੇ ਡਾਟਾ ਕਿਸਮਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਸ਼ਾਮਲ ਹੈ। ਫਾਰਮੈਟਿੰਗ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਨਾ ਆਮ ਤੌਰ 'ਤੇ ਉਹਨਾਂ ਲੋਕਾਂ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ ਜੋ ਡਾਟਾ ਦੀ ਵਰਤੋਂ ਕਰ ਰਹੇ ਹਨ। ਉਦਾਹਰਣ ਲਈ, ਮਿਤੀਆਂ ਅਤੇ ਗਿਣਤੀਆਂ ਨੂੰ ਪੇਸ਼ ਕਰਨ ਦੇ ਮਿਆਰ ਦੇਸ਼ਾਂ ਦੁਆਰਾ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦੇ ਹਨ।

• ਡੁਪਲੀਕੇਸ਼ਨ: ਡਾਟਾ ਜਿਸ ਵਿੱਚ ਇੱਕ ਤੋਂ ਵੱਧ ਘਟਨਾ ਹੁੰਦੀ ਹੈ, ਗਲਤ ਨਤੀਜੇ ਪੈਦਾ ਕਰ ਸਕਦੀ ਹੈ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਇਸਨੂੰ ਹਟਾ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਅਕਸਰ ਦੋ ਜਾਂ ਵੱਧ ਡਾਟਾਸੈਟ ਨੂੰ ਇਕੱਠੇ ਜੋੜਦੇ ਸਮੇਂ ਹੋ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਕੁਝ ਹਾਲਾਤਾਂ ਵਿੱਚ ਜੋੜੇ ਗਏ ਡਾਟਾਸੈਟ ਵਿੱਚ ਡੁਪਲੀਕੇਸ਼ਨ ਵਿੱਚ ਉਹ ਟੁਕੜੇ ਹੋ ਸਕਦੇ ਹਨ ਜੋ ਵਾਧੂ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰ ਸਕਦੇ ਹਨ ਅਤੇ ਇਸਨੂੰ ਸੰਭਾਲਣ ਦੀ ਲੋੜ ਹੋ ਸਕਦੀ ਹੈ।

• ਗੁੰਮ ਡਾਟਾ: ਗੁੰਮ ਡਾਟਾ ਗਲਤੀਆਂ ਦੇ ਨਾਲ-साथ ਕਮਜ਼ੋਰ ਜਾਂ ਪੱਖਪਾਤੀ ਨਤੀਜੇ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ। ਕਈ ਵਾਰ ਇਹ "ਰੀਲੋਡ" ਕਰਕੇ, ਗੁੰਮ ਮੁੱਲਾਂ ਨੂੰ ਗਣਨਾ ਅਤੇ ਕੋਡ ਜਿਵੇਂ Python ਨਾਲ ਭਰ ਕੇ, ਜਾਂ ਸਿਰਫ ਮੁੱਲ ਅਤੇ ਸੰਬੰਧਿਤ ਡਾਟਾ ਨੂੰ ਹਟਾ ਕੇ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਡਾਟਾ ਗੁੰਮ ਹੋਣ ਦੇ ਕਈ ਕਾਰਨ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਗੁੰਮ ਮੁੱਲਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕੀਤੇ ਗਏ ਕਾਰਵਾਈਆਂ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰ ਸਕਦੀਆਂ ਹਨ ਕਿ ਇਹ ਕਿਵੇਂ ਅਤੇ ਕਿਉਂ ਗੁੰਮ ਹੋਏ।

ਡਾਟਾ ਫਰੇਮ ਜਾਣਕਾਰੀ ਦੀ ਖੋਜ

ਸਿੱਖਣ ਦਾ ਲਕਸ਼: ਇਸ ਉਪਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ pandas DataFrames ਵਿੱਚ ਸਟੋਰ ਕੀਤੇ ਡਾਟਾ ਬਾਰੇ ਆਮ ਜਾਣਕਾਰੀ ਲੱਭਣ ਵਿੱਚ ਸਹੂਲਤ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ।

ਜਦੋਂ ਤੁਸੀਂ pandas ਵਿੱਚ ਆਪਣਾ ਡਾਟਾ ਲੋਡ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਇਹ DataFrame ਵਿੱਚ ਹੋਵੇਗਾ (ਪਿਛਲੇ ਪਾਠ ਵਿੱਚ ਵੇਰਵੇਦਾਰ ਝਲਕ ਲਈ ਹਵਾਲਾ ਦਿਓ)। ਹਾਲਾਂਕਿ, ਜੇ ਤੁਹਾਡੇ DataFrame ਵਿੱਚ 60,000 ਪੰਕਤੀਆਂ ਅਤੇ 400 ਕਾਲਮ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਗੱਲ ਦਾ ਅੰਦਾਜ਼ਾ ਕਿਵੇਂ ਲਗਾਉਂਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੀ ਕੰਮ ਕਰ ਰਹੇ ਹੋ? ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, pandas ਕੁਝ ਸਹੂਲਤਮੰਦ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ DataFrame ਬਾਰੇ ਕੁੱਲ ਜਾਣਕਾਰੀ ਤੇਜ਼ੀ ਨਾਲ ਦੇਖਣ ਲਈ ਅਤੇ ਪਹਿਲੀਆਂ ਕੁਝ ਅਤੇ ਆਖਰੀ ਕੁਝ ਪੰਕਤੀਆਂ ਦੇਖਣ ਲਈ ਸਹਾਇਕ ਹੁੰਦੇ ਹਨ।

ਇਸ ਫੰਕਸ਼ਨਲਿਟੀ ਦੀ ਖੋਜ ਕਰਨ ਲਈ, ਅਸੀਂ Python scikit-learn ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਇੰਪੋਰਟ ਕਰਾਂਗੇ ਅਤੇ ਇੱਕ ਪ੍ਰਸਿੱਧ ਡਾਟਾਸੈਟ ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ: Iris ਡਾਟਾਸੈਟ।

import pandas as pd
from sklearn.datasets import load_iris

iris = load_iris()
iris_df = pd.DataFrame(data=iris['data'], columns=iris['feature_names'])

	sepal length (cm)	sepal width (cm)	petal length (cm)	petal width (cm)
0	5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2
2	4.7	3.2	1.3	0.2
3	4.6	3.1	1.5	0.2
4	5.0	3.6	1.4	0.2

• DataFrame.info: ਸ਼ੁਰੂ ਕਰਨ ਲਈ, info() ਵਿਧੀ ਨੂੰ DataFrame ਵਿੱਚ ਮੌਜੂਦ ਸਮੱਗਰੀ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਆਓ ਇਸ ਡਾਟਾਸੈਟ ਨੂੰ ਦੇਖੀਏ ਕਿ ਸਾਡੇ ਕੋਲ ਕੀ ਹੈ:

iris_df.info()

RangeIndex: 150 entries, 0 to 149
Data columns (total 4 columns):
 #   Column             Non-Null Count  Dtype  
---  ------             --------------  -----  
 0   sepal length (cm)  150 non-null    float64
 1   sepal width (cm)   150 non-null    float64
 2   petal length (cm)  150 non-null    float64
 3   petal width (cm)   150 non-null    float64
dtypes: float64(4)
memory usage: 4.8 KB

ਇਸ ਤੋਂ, ਅਸੀਂ ਜਾਣਦੇ ਹਾਂ ਕਿ Iris ਡਾਟਾਸੈਟ ਵਿੱਚ ਚਾਰ ਕਾਲਮਾਂ ਵਿੱਚ 150 ਐਂਟਰੀਆਂ ਹਨ ਜਿਨ੍ਹਾਂ ਵਿੱਚ ਕੋਈ null ਐਂਟਰੀ ਨਹੀਂ ਹੈ। ਸਾਰਾ ਡਾਟਾ 64-ਬਿਟ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਨੰਬਰਾਂ ਵਜੋਂ ਸਟੋਰ ਕੀਤਾ ਗਿਆ ਹੈ।

• DataFrame.head(): ਅਗਲੇ, DataFrame ਦੀ ਅਸਲ ਸਮੱਗਰੀ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਅਸੀਂ head() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਆਓ ਦੇਖੀਏ ਕਿ ਸਾਡੇ iris_df ਦੀਆਂ ਪਹਿਲੀਆਂ ਕੁਝ ਪੰਕਤੀਆਂ ਕਿਵੇਂ ਲੱਗਦੀਆਂ ਹਨ:

iris_df.head()

   sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
0                5.1               3.5                1.4               0.2
1                4.9               3.0                1.4               0.2
2                4.7               3.2                1.3               0.2
3                4.6               3.1                1.5               0.2
4                5.0               3.6                1.4               0.2

• DataFrame.tail(): ਇਸਦੇ ਉਲਟ, DataFrame ਦੀਆਂ ਆਖਰੀ ਕੁਝ ਪੰਕਤੀਆਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, ਅਸੀਂ tail() ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:

iris_df.tail()

     sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)
145                6.7               3.0                5.2               2.3
146                6.3               2.5                5.0               1.9
147                6.5               3.0                5.2               2.0
148                6.2               3.4                5.4               2.3
149                5.9               3.0                5.1               1.8

ਨਿਸਕਰਸ਼: ਸਿਰਫ DataFrame ਵਿੱਚ ਮੌਜੂਦ ਜਾਣਕਾਰੀ ਬਾਰੇ ਮੈਟਾਡੇਟਾ ਜਾਂ ਪਹਿਲੀਆਂ ਅਤੇ ਆਖਰੀ ਕੁਝ ਮੁੱਲਾਂ ਨੂੰ ਦੇਖ ਕੇ, ਤੁਸੀਂ ਤੁਰੰਤ ਇਸ ਗੱਲ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਜਿਸ ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰ ਰਹੇ ਹੋ, ਉਸ ਦਾ ਆਕਾਰ, ਰੂਪ ਅਤੇ ਸਮੱਗਰੀ ਕੀ ਹੈ।

ਗੁੰਮ ਡਾਟਾ ਨਾਲ ਨਿਪਟਣਾ

ਸਿੱਖਣ ਦਾ ਲਕਸ਼: ਇਸ ਉਪਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ DataFrames ਵਿੱਚ null ਮੁੱਲਾਂ ਨੂੰ ਬਦਲਣ ਜਾਂ ਹਟਾਉਣ ਦਾ ਗਿਆਨ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਅਕਸਰ ਉਹ ਡਾਟਾਸੈਟ ਜੋ ਤੁਸੀਂ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ (ਜਾਂ ਵਰਤਣ ਲਈ ਮਜਬੂਰ ਹੋ) ਵਿੱਚ ਗੁੰਮ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਗੁੰਮ ਡਾਟਾ ਨੂੰ ਹੱਲ ਕਰਨ ਦਾ ਤਰੀਕਾ ਸੁਖਮ ਤਰਾਜੂ ਲਿਆਉਂਦਾ ਹੈ ਜੋ ਤੁਹਾਡੇ ਅੰਤਿਮ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਅਸਲ-ਦੁਨੀਆ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰ ਸਕਦਾ ਹੈ।

Pandas ਗੁੰਮ ਮੁੱਲਾਂ ਨੂੰ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਹੱਲ ਕਰਦਾ ਹੈ। ਪਹਿਲਾ ਤੁਸੀਂ ਪਿਛਲੇ ਸੈਕਸ਼ਨਾਂ ਵਿੱਚ ਦੇਖਿਆ ਹੈ: NaN, ਜਾਂ Not a Number। ਇਹ ਵਾਸਤਵ ਵਿੱਚ IEEE ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਵਿਸ਼ੇਸ਼ਤਾ ਦਾ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਮੁੱਲ ਹੈ ਅਤੇ ਇਹ ਸਿਰਫ ਗੁੰਮ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਮੁੱਲਾਂ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ।

ਫਲੋਟਾਂ ਤੋਂ ਇਲਾਵਾ ਗੁੰਮ ਮੁੱਲਾਂ ਲਈ, pandas Python None ਆਬਜੈਕਟ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਹਾਲਾਂਕਿ ਇਹ ਗੁੰਮ ਡਾਟਾ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਦੋ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਮੁੱਲਾਂ ਨੂੰ ਦੇਖਣ ਵਿੱਚ ਗੁੰਝਲਦਾਰ ਲੱਗ ਸਕਦਾ ਹੈ, ਪਰ ਇਸ ਡਿਜ਼ਾਈਨ ਚੋਣ ਲਈ ਵਾਜਬ ਕਾਰਨ ਹਨ ਅਤੇ, ਅਮਲ ਵਿੱਚ, ਇਸ ਤਰੀਕੇ ਨਾਲ pandas ਵਧੀਏ ਤਰਜੀਹ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ ਜ਼ਿਆਦਾਤਰ ਹਾਲਾਤਾਂ ਲਈ ਚੰਗਾ ਕੰਪ੍ਰੋਮਾਈਜ਼ ਹੈ। ਇਸਦੇ ਬਾਵਜੂਦ, None ਅਤੇ NaN ਦੋਵੇਂ ਪਾਬੰਦੀਆਂ ਲਿਆਉਂਦੇ ਹਨ ਜਿਨ੍ਹਾਂ ਨੂੰ ਤੁਸੀਂ ਇਸ ਗੱਲ ਦੇ ਪ੍ਰਤੀ ਸਾਵਧਾਨ ਰਹਿਣਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਇਹਨਾਂ ਨੂੰ ਕਿਵੇਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।

NaN ਅਤੇ None ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਨੋਟਬੁੱਕ ਨੂੰ ਦੇਖੋ!

• Null ਮੁੱਲਾਂ ਦੀ ਪਛਾਣ: pandas ਵਿੱਚ, isnull() ਅਤੇ notnull() ਵਿਧੀਆਂ ਤੁਹਾਡੇ ਡਾਟਾ ਵਿੱਚ null ਮੁੱਲਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਮੁੱਖ ਵਿਧੀਆਂ ਹਨ। ਦੋਵੇਂ ਤੁਹਾਡੇ ਡਾਟਾ 'ਤੇ Boolean ਮਾਸਕ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਅਸੀਂ NaN ਮੁੱਲਾਂ ਲਈ numpy ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:

import numpy as np

example1 = pd.Series([0, np.nan, '', None])
example1.isnull()

0    False
1     True
2    False
3     True
dtype: bool

ਆਉਟਪੁੱਟ ਨੂੰ ਧਿਆਨ ਨਾਲ ਦੇਖੋ। ਕੀ ਇਸ ਵਿੱਚੋਂ ਕੋਈ ਤੁਹਾਨੂੰ ਹੈਰਾਨ ਕਰਦਾ ਹੈ? ਹਾਲਾਂਕਿ 0 ਇੱਕ ਅੰਕਗਣਿਤ null ਹੈ, ਇਹ ਹਾਲੇ ਵੀ ਇੱਕ ਬਹੁਤ ਵਧੀਆ ਪੂਰਾ ਅੰਕ ਹੈ ਅਤੇ pandas ਇਸਨੂੰ ਇਸ ਤਰ੍ਹਾਂ ਮੰਨਦਾ ਹੈ। '' ਕੁਝ ਹੋਰ ਸੁਖਮ ਹੈ। ਹਾਲਾਂਕਿ ਅਸੀਂ ਇਸਨੂੰ ਸੈਕਸ਼ਨ 1 ਵਿੱਚ ਇੱਕ ਖਾਲੀ ਸਤਰ ਮੁੱਲ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ, ਇਹ ਹਾਲੇ ਵੀ ਇੱਕ ਸਤਰ ਆਬਜੈਕਟ ਹੈ ਅਤੇ pandas ਦੇ ਹਿਸਾਬ ਨਾਲ null ਦਾ ਪ੍ਰਤੀਨਿਧੀ ਨਹੀਂ ਹੈ।

ਹੁਣ, ਆਓ ਇਸਨੂੰ ਉਲਟ ਕਰੀਏ ਅਤੇ ਇਹਨਾਂ ਵਿਧੀਆਂ ਨੂੰ ਇਸ ਤਰੀਕੇ ਨਾਲ ਵਰਤਾਂ ਜਿਵੇਂ ਤੁਸੀਂ ਅਮਲ ਵਿੱਚ ਵਰਤੋਂਗੇ। ਤੁਸੀਂ Boolean ਮਾਸਕਾਂ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ Series ਜਾਂ DataFrame ਇੰਡੈਕਸ ਵਜੋਂ ਵਰਤ ਸਕਦੇ ਹੋ, ਜੋ ਗੁੰਮ (ਜਾਂ ਮੌਜੂਦ) ਮੁੱਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਸਮੇਂ ਉਪਯੋਗ ਹੋ ਸਕਦਾ ਹੈ।

ਨਿਸਕਰਸ਼: isnull() ਅਤੇ notnull() ਦੋਵੇਂ pandas ਵਿੱਚ ਵਰਤਿਆਂ ਸਮਾਨ ਨਤੀਜੇ ਪੈਦਾ ਕਰਦੇ ਹਨ: ਇਹ ਨਤੀਜੇ ਅਤੇ ਉਹਨਾਂ ਨਤੀਜਿਆਂ ਦੇ ਇੰਡੈਕਸ ਦਿਖਾਉਂਦੇ ਹਨ, ਜੋ ਤੁਹਾਨੂੰ ਆਪਣੇ ਡਾਟਾ ਨਾਲ ਨਿਪਟਣ ਦੇ ਸਮੇਂ ਬਹੁਤ ਮਦਦਗਾਰ ਹੋਣਗੇ।

• Null ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣਾ: ਗੁੰਮ ਮੁੱਲਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਤੋਂ ਇਲਾਵਾ, pandas Series ਅਤੇ DataFrames ਤੋਂ null ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣ ਦਾ ਇੱਕ ਸਹੂਲਤਮੰਦ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। (ਵੱਡੇ ਡਾਟਾਸੈਟਾਂ 'ਤੇ ਖਾਸ ਤੌਰ 'ਤੇ, ਅਕਸਰ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਸਿਰਫ ਗੁੰਮ [NA] ਮੁੱਲਾਂ ਨੂੰ ਆਪਣੇ ਵਿਸ਼ਲੇਸ਼ਣ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਵੇ ਬਜਾਏ ਕਿ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਨਿਪਟਣ ਦੇ।) ਇਸਨੂੰ ਅਮਲ ਵਿੱਚ ਦੇਖਣ ਲਈ, ਆਓ example1 'ਤੇ ਵਾਪਸ ਆਈਏ:

example1 = example1.dropna()
example1

0    0
2     
dtype: object

ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਤੁਹਾਡੇ example3[example3.notnull()] ਦੇ ਆਉਟਪੁੱਟ ਵਰਗਾ ਲੱਗਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਥੇ ਫਰਕ ਇਹ ਹੈ ਕਿ, ਸਿਰਫ ਮਾਸਕ ਕੀਤੇ ਮੁੱਲਾਂ 'ਤੇ ਇੰਡੈਕਸ ਕਰਨ ਦੀ ਬਜਾਏ, dropna ਨੇ Series example1 ਤੋਂ ਉਹ ਗੁੰਮ ਮੁੱਲ ਹਟਾ ਦਿੱਤੇ ਹਨ।

ਕਿਉਂਕਿ DataFrames ਵਿੱਚ ਦੋ ਮਾਪ ਹਨ, ਇਹ ਡਾਟਾ ਹਟਾਉਣ ਲਈ ਹੋਰ ਵਿਕਲਪ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹਨ।

example2 = pd.DataFrame([[1,      np.nan, 7], 
                         [2,      5,      8], 
                         [np.nan, 6,      9]])
example2

	0	1	2
0	1.0	NaN	7
1	2.0	5.0	8
2	NaN	6.0	9

(ਕੀ ਤੁਸੀਂ ਧਿਆਨ ਦਿੱਤਾ ਕਿ pandas ਨੇ NaNs ਨੂੰ ਸਮਰਥਨ ਦੇਣ ਲਈ ਦੋ ਕਾਲਮਾਂ ਨੂੰ ਫਲੋਟ ਵਿੱਚ ਅਪਕਾਸਟ ਕੀਤਾ?)

ਤੁਸੀਂ DataFrame ਤੋਂ ਇੱਕ ਹੀ ਮੁੱਲ ਨੂੰ ਹਟਾ ਨਹੀਂ ਸਕਦੇ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਪੂਰੀਆਂ ਪ

ਮੁੱਖ ਗੱਲ: ਤੁਹਾਡੇ ਡੇਟਾਸੈਟ ਵਿੱਚ ਗੁੰਮ ਹੋਈਆਂ ਵੈਲਿਊਜ਼ ਨਾਲ ਨਜਿੱਠਣ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ। ਜੋ ਖਾਸ ਰਣਨੀਤੀ ਤੁਸੀਂ ਵਰਤਦੇ ਹੋ (ਉਨ੍ਹਾਂ ਨੂੰ ਹਟਾਉਣਾ, ਬਦਲਣਾ, ਜਾਂ ਇਹ ਵੀ ਕਿ ਤੁਸੀਂ ਕਿਵੇਂ ਬਦਲਦੇ ਹੋ) ਉਹ ਡੇਟਾ ਦੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੁਆਰਾ ਨਿਰਧਾਰਤ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਜਿਵੇਂ ਜਿਵੇਂ ਤੁਸੀਂ ਡੇਟਾਸੈਟਸ ਨਾਲ ਵਧੇਰੇ ਕੰਮ ਕਰਦੇ ਹੋ ਅਤੇ ਉਨ੍ਹਾਂ ਨਾਲ ਸੰਪਰਕ ਕਰਦੇ ਹੋ, ਗੁੰਮ ਹੋਈਆਂ ਵੈਲਿਊਜ਼ ਨਾਲ ਨਜਿੱਠਣ ਦਾ ਬਿਹਤਰ ਅਹਿਸਾਸ ਵਿਕਸਿਤ ਹੋਵੇਗਾ।

ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਨੂੰ ਹਟਾਉਣਾ

ਸਿੱਖਣ ਦਾ ਉਦੇਸ਼: ਇਸ ਉਪਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਸੀਂ DataFrames ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਦੀ ਪਹਿਚਾਣ ਅਤੇ ਹਟਾਉਣ ਵਿੱਚ ਸਹੀ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਗੁੰਮ ਹੋਈ ਡਾਟਾ ਤੋਂ ਇਲਾਵਾ, ਤੁਸੀਂ ਅਕਸਰ ਅਸਲ-ਜਗਤ ਦੇ ਡਾਟਾਸੈਟਸ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, pandas ਡੁਪਲੀਕੇਟ ਐਂਟਰੀਜ਼ ਦੀ ਪਹਿਚਾਣ ਅਤੇ ਹਟਾਉਣ ਲਈ ਇੱਕ ਆਸਾਨ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

• ਡੁਪਲੀਕੇਟ ਦੀ ਪਹਿਚਾਣ: duplicated: ਤੁਸੀਂ pandas ਵਿੱਚ duplicated ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਵੇਖ ਸਕਦੇ ਹੋ, ਜੋ ਇੱਕ Boolean ਮਾਸਕ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਦੱਸਦਾ ਹੈ ਕਿ DataFrame ਵਿੱਚ ਕੋਈ ਐਂਟਰੀ ਪਹਿਲਾਂ ਦੀ ਐਂਟਰੀ ਦਾ ਡੁਪਲੀਕੇਟ ਹੈ। ਆਓ ਇਸ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖਣ ਲਈ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ DataFrame ਬਣਾਈਏ।

example4 = pd.DataFrame({'letters': ['A','B'] * 2 + ['B'],
                         'numbers': [1, 2, 1, 3, 3]})
example4

	letters	numbers
0	A	1
1	B	2
2	A	1
3	B	3
4	B	3

example4.duplicated()

0    False
1    False
2     True
3    False
4     True
dtype: bool

• ਡੁਪਲੀਕੇਟ ਹਟਾਉਣਾ: drop_duplicates: ਸਿਰਫ ਉਸ ਡਾਟਾ ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਰੇ duplicated ਮੁੱਲ False ਹਨ:

example4.drop_duplicates()

	letters	numbers
0	A	1
1	B	2
3	B	3

duplicated ਅਤੇ drop_duplicates ਦੋਵੇਂ ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ ਸਾਰੇ ਕਾਲਮਾਂ ਨੂੰ ਮਾਨਦੇ ਹਨ, ਪਰ ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਉਹ ਤੁਹਾਡੇ DataFrame ਵਿੱਚ ਸਿਰਫ ਕੁਝ ਕਾਲਮਾਂ ਦੀ ਜਾਂਚ ਕਰਨ:

example4.drop_duplicates(['letters'])

letters	numbers
0	A	1
1	B	2

ਮੁੱਖ ਗੱਲ: ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਨੂੰ ਹਟਾਉਣਾ ਲਗਭਗ ਹਰ ਡਾਟਾ-ਸਾਇੰਸ ਪ੍ਰੋਜੈਕਟ ਦਾ ਇੱਕ ਜਰੂਰੀ ਹਿੱਸਾ ਹੈ। ਡੁਪਲੀਕੇਟ ਡਾਟਾ ਤੁਹਾਡੇ ਵਿਸ਼ਲੇਸ਼ਣ ਦੇ ਨਤੀਜੇ ਬਦਲ ਸਕਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਗਲਤ ਨਤੀਜੇ ਦੇ ਸਕਦਾ ਹੈ!

🚀 ਚੁਣੌਤੀ

ਸਾਰੇ ਚਰਚਾ ਕੀਤੇ ਗਏ ਸਮੱਗਰੀ Jupyter Notebook ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਹਰ ਸੈਕਸ਼ਨ ਦੇ ਬਾਅਦ ਅਭਿਆਸ ਦਿੱਤੇ ਗਏ ਹਨ, ਉਨ੍ਹਾਂ ਨੂੰ ਅਜ਼ਮਾਓ!

ਪੋਸਟ-ਲੈਕਚਰ ਕਵਿਜ਼

ਸਮੀਖਿਆ ਅਤੇ ਸਵੈ ਅਧਿਐਨ

ਤੁਹਾਡੇ ਡਾਟਾ ਨੂੰ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਮਾਡਲਿੰਗ ਲਈ ਤਿਆਰ ਕਰਨ ਦੇ ਕਈ ਤਰੀਕੇ ਹਨ ਅਤੇ ਡਾਟਾ ਨੂੰ ਸਾਫ ਕਰਨਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ ਜੋ "ਹੱਥ-ਵਰਤੋਂ" ਅਨੁਭਵ ਹੈ। Kaggle ਤੋਂ ਇਹ ਚੁਣੌਤੀਆਂ ਅਜ਼ਮਾਓ ਜਿਨ੍ਹਾਂ ਨਾਲ ਉਹ ਤਕਨੀਕਾਂ ਖੋਜੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ ਜੋ ਇਸ ਪਾਠ ਵਿੱਚ ਕਵਰ ਨਹੀਂ ਕੀਤੀਆਂ ਗਈਆਂ।

• ਡਾਟਾ ਸਾਫ ਕਰਨ ਦੀ ਚੁਣੌਤੀ: ਤਾਰੀਖਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨਾ

• ਡਾਟਾ ਸਾਫ ਕਰਨ ਦੀ ਚੁਣੌਤੀ: ਡਾਟਾ ਨੂੰ ਸਕੇਲ ਅਤੇ ਨਾਰਮਲਾਈਜ਼ ਕਰਨਾ

ਅਸਾਈਨਮੈਂਟ

ਫਾਰਮ ਤੋਂ ਡਾਟਾ ਦਾ ਮੁਲਾਂਕਨ

---

ਅਸਵੀਕਾਰਨਾ:
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ Co-op Translator ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ ਅਸੀਂ ਸਹੀਅਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁੱਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।