<!--
CO_OP_TRANSLATOR_METADATA:
{
  "original_hash": "1b560955ff39a2bcf2a049fce474a951",
  "translation_date": "2025-09-06T08:08:07+00:00",
  "source_file": "2-Working-With-Data/08-data-preparation/README.md",
  "language_code": "pa"
}
-->
# ਡਾਟਾ ਨਾਲ ਕੰਮ ਕਰਨਾ: ਡਾਟਾ ਤਿਆਰੀ

|![ [(@sketchthedocs)] ਦੁਆਰਾ ਸਕੈਚਨੋਟ](https://sketchthedocs.dev) ](../../sketchnotes/08-DataPreparation.png)|
|:---:|
|ਡਾਟਾ ਤਿਆਰੀ - _[@nitya](https://twitter.com/nitya) ਦੁਆਰਾ ਸਕੈਚਨੋਟ_ |

## [ਪ੍ਰੀ-ਲੈਕਚਰ ਕਵਿਜ਼](https://ff-quizzes.netlify.app/en/ds/quiz/14)

ਡਾਟਾ ਦੇ ਸਰੋਤ ਦੇ ਅਧਾਰ 'ਤੇ, ਕੱਚਾ ਡਾਟਾ ਕੁਝ ਅਸੰਗਤਤਾਵਾਂ ਰੱਖ ਸਕਦਾ ਹੈ ਜੋ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਮਾਡਲਿੰਗ ਵਿੱਚ ਚੁਣੌਤੀਆਂ ਪੈਦਾ ਕਰਦੇ ਹਨ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਇਸ ਡਾਟਾ ਨੂੰ "ਗੰਦਾ" ਕਹਿ ਸਕਦੇ ਹਾਂ ਅਤੇ ਇਸਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇਸ ਪਾਠ ਵਿੱਚ ਗੁੰਮ, ਗਲਤ, ਜਾਂ ਅਧੂਰੇ ਡਾਟਾ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਡਾਟਾ ਨੂੰ ਸਾਫ਼ ਕਰਨ ਅਤੇ ਰੂਪਾਂਤਰਿਤ ਕਰਨ ਦੀਆਂ ਤਕਨੀਕਾਂ 'ਤੇ ਧਿਆਨ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਇਸ ਪਾਠ ਵਿੱਚ ਕਵਰ ਕੀਤੇ ਗਏ ਵਿਸ਼ਿਆਂ ਨੂੰ Python ਅਤੇ Pandas ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ [ਨੋਟਬੁੱਕ ਵਿੱਚ ਦਰਸਾਇਆ](../../../../2-Working-With-Data/08-data-preparation/notebook.ipynb) ਜਾਵੇਗਾ।

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

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

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

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

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

- **ਡਾਟਾਸੈਟ ਦੀ ਖੋਜ**: ਡਾਟਾ ਖੋਜ, ਜੋ [ਅਗਲੇ ਪਾਠ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/4-Data-Science-Lifecycle/15-analyzing) ਵਿੱਚ ਕਵਰ ਕੀਤੀ ਗਈ ਹੈ, ਤੁਹਾਨੂੰ ਉਹ ਡਾਟਾ ਖੋਜਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦੀ ਹੈ ਜਿਸਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਡਾਟਾਸੈਟ ਵਿੱਚ ਮੌਜੂਦ ਮੁੱਲਾਂ ਨੂੰ ਵਿਜ਼ੂਅਲ ਤੌਰ 'ਤੇ ਦੇਖਣਾ ਇਹ ਅਨੁਮਾਨ ਲਗਾ ਸਕਦਾ ਹੈ ਕਿ ਬਾਕੀ ਡਾਟਾ ਕਿਵੇਂ ਲੱਗੇਗਾ, ਜਾਂ ਉਹ ਸਮੱਸਿਆਵਾਂ ਦੇ ਵਿਚਾਰ ਦੇ ਸਕਦਾ ਹੈ ਜੋ ਹੱਲ ਕੀਤੀਆਂ ਜਾ ਸਕਦੀਆਂ ਹਨ। ਖੋਜ ਵਿੱਚ ਬੁਨਿਆਦੀ ਪੁੱਛਗਿੱਛ, ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ, ਅਤੇ ਸੈਂਪਲਿੰਗ ਸ਼ਾਮਲ ਹੋ ਸਕਦੀ ਹੈ।

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

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

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

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

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

ਜਦੋਂ ਤੁਸੀਂ pandas ਵਿੱਚ ਆਪਣਾ ਡਾਟਾ ਲੋਡ ਕਰਦੇ ਹੋ, ਤਾਂ ਇਹ ਸੰਭਵ ਹੈ ਕਿ ਇਹ DataFrame ਵਿੱਚ ਹੋਵੇਗਾ (ਪਿਛਲੇ [ਪਾਠ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/2-Working-With-Data/07-python#dataframe) ਵਿੱਚ ਵੇਰਵੇਦਾਰ ਝਲਕ ਲਈ ਹਵਾਲਾ ਦਿਓ)। ਹਾਲਾਂਕਿ, ਜੇ ਤੁਹਾਡੇ DataFrame ਵਿੱਚ 60,000 ਪੰਕਤੀਆਂ ਅਤੇ 400 ਕਾਲਮ ਹਨ, ਤਾਂ ਤੁਸੀਂ ਇਸ ਗੱਲ ਦਾ ਅੰਦਾਜ਼ਾ ਕਿਵੇਂ ਲਗਾਉਂਦੇ ਹੋ ਕਿ ਤੁਸੀਂ ਕੀ ਕੰਮ ਕਰ ਰਹੇ ਹੋ? ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, [pandas](https://pandas.pydata.org/) ਕੁਝ ਸਹੂਲਤਮੰਦ ਟੂਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ ਜੋ DataFrame ਬਾਰੇ ਕੁੱਲ ਜਾਣਕਾਰੀ ਤੇਜ਼ੀ ਨਾਲ ਦੇਖਣ ਲਈ ਅਤੇ ਪਹਿਲੀਆਂ ਕੁਝ ਅਤੇ ਆਖਰੀ ਕੁਝ ਪੰਕਤੀਆਂ ਦੇਖਣ ਲਈ ਸਹਾਇਕ ਹੁੰਦੇ ਹਨ।

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

```python
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` ਵਿੱਚ ਮੌਜੂਦ ਸਮੱਗਰੀ ਦੀ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਿੰਟ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਆਓ ਇਸ ਡਾਟਾਸੈਟ ਨੂੰ ਦੇਖੀਏ ਕਿ ਸਾਡੇ ਕੋਲ ਕੀ ਹੈ:
```python
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` ਦੀਆਂ ਪਹਿਲੀਆਂ ਕੁਝ ਪੰਕਤੀਆਂ ਕਿਵੇਂ ਲੱਗਦੀਆਂ ਹਨ:
```python
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()` ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:
```python
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` ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ [ਨੋਟਬੁੱਕ](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/4-Data-Science-Lifecycle/15-analyzing/notebook.ipynb) ਨੂੰ ਦੇਖੋ!

- **Null ਮੁੱਲਾਂ ਦੀ ਪਛਾਣ**: pandas ਵਿੱਚ, `isnull()` ਅਤੇ `notnull()` ਵਿਧੀਆਂ ਤੁਹਾਡੇ ਡਾਟਾ ਵਿੱਚ null ਮੁੱਲਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਮੁੱਖ ਵਿਧੀਆਂ ਹਨ। ਦੋਵੇਂ ਤੁਹਾਡੇ ਡਾਟਾ 'ਤੇ Boolean ਮਾਸਕ ਵਾਪਸ ਕਰਦੇ ਹਨ। ਅਸੀਂ `NaN` ਮੁੱਲਾਂ ਲਈ `numpy` ਦੀ ਵਰਤੋਂ ਕਰਾਂਗੇ:
```python
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` ਅਤੇ `DataFrame`s ਤੋਂ null ਮੁੱਲਾਂ ਨੂੰ ਹਟਾਉਣ ਦਾ ਇੱਕ ਸਹੂਲਤਮੰਦ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। (ਵੱਡੇ ਡਾਟਾਸੈਟਾਂ 'ਤੇ ਖਾਸ ਤੌਰ 'ਤੇ, ਅਕਸਰ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਕਿ ਸਿਰਫ ਗੁੰਮ [NA] ਮੁੱਲਾਂ ਨੂੰ ਆਪਣੇ ਵਿਸ਼ਲੇਸ਼ਣ ਤੋਂ ਹਟਾ ਦਿੱਤਾ ਜਾਵੇ ਬਜਾਏ ਕਿ ਹੋਰ ਤਰੀਕਿਆਂ ਨਾਲ ਨਿਪਟਣ ਦੇ।) ਇਸਨੂੰ ਅਮਲ ਵਿੱਚ ਦੇਖਣ ਲਈ, ਆਓ `example1` 'ਤੇ ਵਾਪਸ ਆਈਏ:
```python
example1 = example1.dropna()
example1
```
```
0    0
2     
dtype: object
```
ਨੋਟ ਕਰੋ ਕਿ ਇਹ ਤੁਹਾਡੇ `example3[example3.notnull()]` ਦੇ ਆਉਟਪੁੱਟ ਵਰਗਾ ਲੱਗਣਾ ਚਾਹੀਦਾ ਹੈ। ਇੱਥੇ ਫਰਕ ਇਹ ਹੈ ਕਿ, ਸਿਰਫ ਮਾਸਕ ਕੀਤੇ ਮੁੱਲਾਂ 'ਤੇ ਇੰਡੈਕਸ ਕਰਨ ਦੀ ਬਜਾਏ, `dropna` ਨੇ `Series` `example1` ਤੋਂ ਉਹ ਗੁੰਮ ਮੁੱਲ ਹਟਾ ਦਿੱਤੇ ਹਨ।

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

```python
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 ਨੇ `NaN`s ਨੂੰ ਸਮਰਥਨ ਦੇਣ ਲਈ ਦੋ ਕਾਲਮਾਂ ਨੂੰ ਫਲੋਟ ਵਿੱਚ ਅਪਕਾਸਟ ਕੀਤਾ?)

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

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

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

- **ਡੁਪਲੀਕੇਟ ਦੀ ਪਹਿਚਾਣ: `duplicated`**: ਤੁਸੀਂ pandas ਵਿੱਚ `duplicated` ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਸਾਨੀ ਨਾਲ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਵੇਖ ਸਕਦੇ ਹੋ, ਜੋ ਇੱਕ Boolean ਮਾਸਕ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਦੱਸਦਾ ਹੈ ਕਿ `DataFrame` ਵਿੱਚ ਕੋਈ ਐਂਟਰੀ ਪਹਿਲਾਂ ਦੀ ਐਂਟਰੀ ਦਾ ਡੁਪਲੀਕੇਟ ਹੈ। ਆਓ ਇਸ ਨੂੰ ਕਾਰਵਾਈ ਵਿੱਚ ਦੇਖਣ ਲਈ ਇੱਕ ਹੋਰ ਉਦਾਹਰਨ `DataFrame` ਬਣਾਈਏ।
```python
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      |

```python
example4.duplicated()
```
```
0    False
1    False
2     True
3    False
4     True
dtype: bool
```
- **ਡੁਪਲੀਕੇਟ ਹਟਾਉਣਾ: `drop_duplicates`:** ਸਿਰਫ ਉਸ ਡਾਟਾ ਦੀ ਇੱਕ ਕਾਪੀ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਿਸ ਵਿੱਚ ਸਾਰੇ `duplicated` ਮੁੱਲ `False` ਹਨ:
```python
example4.drop_duplicates()
```
```
	letters	numbers
0	A	1
1	B	2
3	B	3
```
`duplicated` ਅਤੇ `drop_duplicates` ਦੋਵੇਂ ਡਿਫਾਲਟ ਤੌਰ 'ਤੇ ਸਾਰੇ ਕਾਲਮਾਂ ਨੂੰ ਮਾਨਦੇ ਹਨ, ਪਰ ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਉਹ ਤੁਹਾਡੇ `DataFrame` ਵਿੱਚ ਸਿਰਫ ਕੁਝ ਕਾਲਮਾਂ ਦੀ ਜਾਂਚ ਕਰਨ:
```python
example4.drop_duplicates(['letters'])
```
```
letters	numbers
0	A	1
1	B	2
```

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


## 🚀 ਚੁਣੌਤੀ

ਸਾਰੇ ਚਰਚਾ ਕੀਤੇ ਗਏ ਸਮੱਗਰੀ [Jupyter Notebook](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/2-Working-With-Data/08-data-preparation/notebook.ipynb) ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਹਨ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਹਰ ਸੈਕਸ਼ਨ ਦੇ ਬਾਅਦ ਅਭਿਆਸ ਦਿੱਤੇ ਗਏ ਹਨ, ਉਨ੍ਹਾਂ ਨੂੰ ਅਜ਼ਮਾਓ!

## [ਪੋਸਟ-ਲੈਕਚਰ ਕਵਿਜ਼](https://ff-quizzes.netlify.app/en/ds/quiz/15)


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

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

- [ਡਾਟਾ ਸਾਫ ਕਰਨ ਦੀ ਚੁਣੌਤੀ: ਤਾਰੀਖਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨਾ](https://www.kaggle.com/rtatman/data-cleaning-challenge-parsing-dates/)

- [ਡਾਟਾ ਸਾਫ ਕਰਨ ਦੀ ਚੁਣੌਤੀ: ਡਾਟਾ ਨੂੰ ਸਕੇਲ ਅਤੇ ਨਾਰਮਲਾਈਜ਼ ਕਰਨਾ](https://www.kaggle.com/rtatman/data-cleaning-challenge-scale-and-normalize-data)


## ਅਸਾਈਨਮੈਂਟ

[ਫਾਰਮ ਤੋਂ ਡਾਟਾ ਦਾ ਮੁਲਾਂਕਨ](assignment.md)

---

**ਅਸਵੀਕਾਰਨਾ**:  
ਇਹ ਦਸਤਾਵੇਜ਼ AI ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਅਨੁਵਾਦ ਕੀਤਾ ਗਿਆ ਹੈ। ਹਾਲਾਂਕਿ ਅਸੀਂ ਸਹੀਅਤਾ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸੁੱਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਨੂੰ ਇਸਦੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਤ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਮਹੱਤਵਪੂਰਨ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਸ ਅਨੁਵਾਦ ਦੀ ਵਰਤੋਂ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੇ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆ ਲਈ ਅਸੀਂ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹਾਂ।