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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

ਸਿੱਖਣ ਦਾ ਲਕਸ਼: ਇਸ ਉਪ-ਵਿਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ 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 ਡਾਟਾ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਤੁਹਾਡੀਆਂ ਮੁੱਖ ਵਿਧੀਆਂ ਹਨ। ਦੋਵੇਂ ਤੁਹਾਡੇ ਡਾਟਾ 'ਤੇ ਬੂਲੀਅਨ ਮਾਸਕ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਅਸੀਂ numpy ਦੀ ਵਰਤੋਂ NaN ਮੁੱਲਾਂ ਲਈ ਕਰਾਂਗੇ:

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 ਦਾ ਪ੍ਰਤੀਨਿਧੀ ਨਹੀਂ ਹੈ।

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

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

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

example1 = example1.dropna()
example1

0    0
2     
dtype: object

ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਤੁਹਾਡੇ example3[example3.notnull()] ਦੇ ਆਉਟਪੁੱਟ ਵਰਗਾ ਲੱਗਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਥੇ ਫਰਕ ਇਹ ਹੈ ਕਿ, masked ਮੁੱਲਾਂ 'ਤੇ ਸਿਰਫ਼ ਇੰਡੈਕਸ ਕਰਨ ਦੀ ਬਜਾਏ, 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 ਤੋਂ ਇੱਕੋ ਮੁੱਲ ਨੂੰ ਹਟਾ ਨਹੀਂ ਸਕਦੇ,

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

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

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

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

• ਡੁਪਲੀਕੇਟਸ ਦੀ ਪਹਿਚਾਣ: duplicated: ਤੁਸੀਂ pandas ਵਿੱਚ duplicated ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਡੁਪਲੀਕੇਟ ਵੈਲਿਊਜ਼ ਦੀ ਪਹਿਚਾਣ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਇੱਕ ਬੂਲੀਅਨ ਮਾਸਕ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ 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 ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁਚੀਤਤਾਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤ ਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।