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

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

ਡੇਟਾ ਤਿਆਰੀ - ਸਕੈਚਨੋਟ @nitya ਵਲੋਂ

ਪ੍ਰੀ-ਲੈਕਚਰ ਕੁਇਜ਼

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

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

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

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

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

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

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

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

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

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

DataFrame ਜਾਣਕਾਰੀ ਦੀ ਖੋਜ

ਸਿੱਖਣ ਦਾ ਲਕੜਾ: ਇਸ ਉਪ-ਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ 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 ਐਂਟਰੀਆਂ ਹਨ ਚਾਰ ਕਾਲਮਾਂ ਵਿੱਚ ਕਿਸੇ ਵੀ ਖਾਲੀ ਐਂਟਰੀ ਦੇ ਬਿਨਾਂ। ਸਾਰੇ ਡੇਟਾ 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 ਵਿੱਚ ਜਾਣਕਾਰੀ ਬਾਰੇ ਮੈਟਾਡੇਟਾ ਦੇਖ ਕੇ ਜਾਂ ਪਹਿਲੀਆਂ ਅਤੇ ਆਖ਼ਰੀਆਂ ਕੁਝ ਮੁੱਲਾਂ ਨੂੰ ਵੇਖ ਕੇ ਤੁਸੀਂ ਤੁਰੰਤ ਹੀ ਡੇਟਾ ਦੀ ਆਕਾਰ, ਆਕਾਰ-ਰੂਪ ਅਤੇ ਸਮੱਗਰੀ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹੋ।

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

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

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

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

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

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

• null ਮੁੱਲਾਂ ਦਾ ਪਤਾ ਲਾਉਣਾ: pandas ਵਿੱਚ, isnull() ਅਤੇ notnull() ਵਿਧੀਆਂ ਤੁਹਾਡੇ ਪ੍ਰਧਾਨ ਤਰੀਕੇ ਹਨ null ਡੇਟਾ ਪਛਾਣਣ ਲਈ। ਦੋਹਾਂ ਤੁਹਾਡੇ ਡੇਟਾ ਤੇ ਬੂਲੀਅਨ ਮਾਸਕ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। ਅਸੀਂ 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 ਇੱਕ ਅੰਕਗਣਿਤ ਨੱਲ ਹੈ, ਇਹ ਫਿਰ ਵੀ ਇੱਕ ਪੂਰਾ ਅੰਕ ਹੈ ਅਤੇ pandas ਇਸਨੂੰ ਇੱਧਰੇ ਹੀ ਮੰਨਦਾ ਹੈ। '' ਥੋੜਾ ਜ਼ਿਆਦਾ ਸੁਕੁੰਥ ਹੈ। ਜਿਵੇਂ ਅਸੀਂ ਧਾਰਾ 1 ਵਿੱਚ ਇਸਨੂੰ ਖ਼ਾਲੀ ਸਟਰਿੰਗ ਮੁੱਲ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਸੀ, ਪਰ ਇਹ ਫਿਰ ਵੀ ਇੱਕ ਸਟਰਿੰਗ ਆਬਜੈਕਟ ਹੈ ਅਤੇ pandas ਦੇ ਮੁਤਾਬਕ null ਦੀ ਪੇਸ਼ਕਸ਼ ਨਹੀਂ ਹੈ।

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

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

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

example2.dropna()

	0	1	2
1	2.0	5.0	8

ਜੇ ਜਰੂਰੀ ਹੋਵੇ ਤਾਂ ਤੁਸੀਂ ਕਾਲਮ ਤੋਂ NA ਮੁੱਲ ਹਟਾ ਸਕਦੇ ਹੋ। axis=1 ਵਰਤੋ ਇਸ ਲਈ:

example2.dropna(axis='columns')

	2
0	7
1	8
2	9

ਦਿਆਨ ਦਿਓ ਕਿ ਇਹ ਕਾਫੀ ਡੇਟਾ ਹਟਾ ਸਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਖਾਸ ਕਰਕੇ ਛੋਟੇ ਡੇਟਾਸੈੱਟ ਵਿੱਚ। ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ ਉਹ ਕਤਾਰਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਕਈ ਜਾਂ ਸਾਰੇ null ਮੁੱਲ ਰੱਖਦੇ ਹਨ ਤਾਂ? ਤੁਸੀਂ dropna ਵਿੱਚ how ਅਤੇ thresh ਪਰਾਮੀਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਹ ਸੈਟਿੰਗਾਂ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ।

ਡਿਫੌਲਟ ਹੈ how='any' (ਤੁਸੀਂ ਖੁਦ ਦੇਖਣ ਜਾਂ ਹੋਰ ਪਰਾਮੀਟਰ ਜਾਣਨ ਲਈ example4.dropna? ਦੌੜਾ ਸਕਦੇ ਹੋ)। ਤੁਸੀਂ ਬਦਲੇ ਵਿੱਚ how='all' ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਸਿਰਫ ਉਹ ਕਤਾਰਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਏ ਜਾਣ ਜੋ ਸਾਰੇ null ਮੁੱਲ ਰੱਖਦੇ ਹਨ। ਇਸਨੂੰ ਦੇਖਣ ਲਈ ਅਸੀਂ ਆਪਣਾ ਉਦਾਹਰਨ DataFrame ਵਧਾਈਏ।

example2[3] = np.nan
example2

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

thresh ਪਰਾਮੀਟਰ ਤੁਹਾਨੂੰ ਬਹੁਤ ਨਿੱਜੀ ਕਾਬੂ ਦਿੰਦਾ ਹੈ: ਤੁਸੀਂ ਉਹ ਨੰਬਰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ ਗੈਰ-ਨਲ ਮੁੱਲਾਂ ਦਾ ਜੋ ਇੱਕ ਕਤਾਰ ਜਾਂ ਕਾਲਮ ਕੋਲ ਬਣਿਆ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ:

example2.dropna(axis='rows', thresh=3)

	0	1	2	3
1	2.0	5.0	8	NaN

ਇੱਥੇ, ਪਹਿਲੀ ਅਤੇ ਆਖ਼ਰੀ ਕਤਾਰਾਂ ਹਟਾਈ ਗਈਆਂ ਹਨ, ਕਿਉਂਕਿ ਉਹ ਸਿਰਫ ਦੋ ਗੈਰ-ਨਲ ਮੁੱਲ ਰੱਖਦੀਆਂ ਹਨ।

• null ਮੁੱਲਾਂ ਨੂੰ ਭਰਨਾ: ਤੁਹਾਡੇ ਡੇਟਾਸੈੱਟ ਦੇ ਮਿਉਤਾਬਕ, ਕਈ ਵਾਰ null ਮੁੱਲਾਂ ਨੂੰ ਸਹੀ ਮੁੱਲਾਂ ਨਾਲ ਭਰਨ ਉਚਿਤ ਹੁੰਦਾ ਹੈ ਨਾ ਕਿ ਉਨ੍ਹਾਂ ਨੂੰ ਹਟਾਉਣਾ। ਤੁਸੀਂ ਇਸ ਨੂੰ ਜਗ੍ਹਾ ਤੇ isnull ਵਰਤ ਕੇ ਕਰ ਸਕਦੇ ਹੋ, ਪਰ ਇਹ ਸੁਖਮ ਸੰਘਰਸ਼ਮਈ ਹੈ, ਖਾਸ ਕਰਕੇ ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਬਹੁਤ ਸਾਰੇ ਮੁੱਲ ਹਨ ਭਰਨ ਲਈ। ਕਿਉਂਕਿ ਇਹ ਡੇਟਾ ਸਾਇੰਸ ਵਿੱਚ ਬਹੁਤ ਆਮ ਕੰਮ ਹੈ, pandas fillna ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ Series ਜਾਂ DataFrame ਦੀ ਇੱਕ ਨਕਲ ਵਾਪਸੀ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਗੁੰਮ ਮੁੱਲ ਤੁਹਾਡੇ ਚੁਣੇ ਹੋਏ ਮੁੱਲ ਨਾਲ ਬਦਲੇ ਜਾਂਦੇ ਹਨ। ਚਲੋ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ Series ਬਣਾਈਏ ਤਾਂ ਜੋ ਇਨ੍ਹਾਂ ਵਿਧੀਆਂ ਨੂੰ ਅਮਲੀ ਜ਼ਿੰਦਗੀ ਵਿੱਚ ਵੇਖਿਆ ਜਾ ਸਕੇ।

example3 = pd.Series([1, np.nan, 2, None, 3], index=list('abcde'))
example3

a    1.0
b    NaN
c    2.0
d    NaN
e    3.0
dtype: float64

ਤੁਸੀਂ ਸਾਰੇ null ਐਂਟਰੀਆਂ ਨੂੰ ਇੱਕ ਅਕਤਰਾ ਮੁੱਲ ਨਾਲ ਤਰਾਂ ਭਰ ਸਕਦੇ ਹੋ, ਜਿਵੇਂ 0:

example3.fillna(0)

a    1.0
b    0.0
c    2.0
d    0.0
e    3.0
dtype: float64

ਤੁਸੀਂ ਫਾਰਵਰਡ-ਫਿਲ null ਮੁੱਲ ਭਰ ਸਕਦੇ ਹੋ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਅਖੀਰਲਾ ਸਕੀਮਤ ਮੁੱਲ ਵਰਤਣਾ ਤਾਂ ਜੋ null ਨੂੰ ਭਰਿਆ ਜਾ ਸਕੇ:

example3.fillna(method='ffill')

a    1.0
b    1.0
c    2.0
d    2.0
e    3.0
dtype: float64

ਤੁਸੀਂ ਬੈਕ-ਫਿਲ ਵੀ ਕਰ ਸਕਦੇ ਹੋ, ਅਗਲਾ ਸਹੀ ਮੁੱਲ ਪਿੱਛੇ ਵੱਲ ਭਰਣ ਲਈ ਵਾਪਰਦਾ ਹੈ:

example3.fillna(method='bfill')

a    1.0
b    2.0
c    2.0
d    3.0
e    3.0
dtype: float64

ਜਿਵੇਂ ਤੁਸੀਂ ਅਟਕ ਸਕਦੇ ਹੋ, ਇਹ DataFrames ਨਾਲ ਵੀ ਉਹੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਇਹ ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿਸ axis 'ਤੇ null ਮੁੱਲ ਭਰਣੇ ਹਨ। ਫਿਰ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤੇ example2 ਨੂੰ ਲਵੋ:

example2.fillna(method='ffill', axis=1)

	0	1	2	3
0	1.0	1.0	7.0	7.0
1	2.0	5.0	8.0	8.0
2	NaN	6.0	9.0	9.0

ਦਿਆਨ ਦਿਓ ਜਦ ਇੱਕ ਪਿਛਲੇ ਮੁੱਲ ਦਾ ਉਪਲਬਧ ਨਾ ਹੋਵੇ ਫਾਰਵਰਡ-ਫਿਲਿੰਗ ਲਈ, null ਮੁੱਲ ਉਸੇ ਤਰ੍ਹਾਂ ਰਹਿੰਦਾ ਹੈ।

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

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

ਸਿੱਖਣ ਦਾ ਲਕਸਰ: ਇਸ ਉਪ-ਹਿੱਸੇ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ ਡੇਟਾਫ੍ਰੇਮ ਤੋਂ ਨਕਲ ਵਾਲੀਆਂ ਮੁੱਲਾਂ ਨੂੰ ਪਛਾਣਨ ਅਤੇ ਹਟਾਉਣ ਵਿੱਚ ਆਰਾਮਦਾਇਕ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ।

ਗੁੰਮ ਡੇਟਾ ਦੇ ਨਾਲ-ਨਾਲ, ਤੁਸੀਂ ਅਕਸਰ ਅਸਲੀ ਦੁਨੀਆ ਦੇ ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਨਕਲ ਡੇਟਾ ਦਾ ਸਾਹਮਣਾ ਕਰਦੇ ਹੋ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, 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 ਵਜੋਂ ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਹੈ। ਇਸ ਦੇ ਨਾਲ, ਹਰ ਹਿੱਸੇ ਦੇ ਬਾਅਦ ਕਸਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ, ਉਹਨਾਂ ਨੂੰ ਕੋਸ਼ਿਸ਼ ਕਰੋ!

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

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

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

• ਡਾਟਾ ਸਫਾਈ ਚੈਲੈਂਜ: ਤਰੀਖਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨਾ

• ਡਾਟਾ ਸਫਾਈ ਚੈਲੈਂਜ: ਡਾਟਾ ਨੂੰ ਸਕੇਲ ਅਤੇ ਨਾਰਮਲਾਈਜ਼ ਕਰਨਾ

ਅਸਾਈਨਮੈਂਟ

ਇੱਕ ਫਾਰਮ ਤੋਂ ਡਾਟਾ ਦਾ ਮੁਲਾਂਕਣ

---

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