# ਡੇਟਾ ਨਾਲ ਕੰਮ ਕਰਨਾ: ਡੇਟਾ ਤਿਆਰੀ |![ Sketchnote by [(@sketchthedocs)](https://sketchthedocs.dev) ](../../sketchnotes/08-DataPreparation.png)| |:---:| |ਡੇਟਾ ਤਿਆਰੀ - _ਸਕੈਚਨੋਟ [@nitya](https://twitter.com/nitya) ਵਲੋਂ_ | ## [ਪ੍ਰੀ-ਲੈਕਚਰ ਕੁਇਜ਼](https://ff-quizzes.netlify.app/en/ds/quiz/14) ਇਸਦੀ ਸਰੋਤ ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੋਇਆ, ਰਾ ਡੇਟਾ ਵਿੱਚ ਕੁਝ ਅਸੰਗਤੀਆਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਮਾਡਲਿੰਗ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰਨਗੀਆਂ। ਦੂਜੇ ਸਲੰਗ ਵਿੱਚ ਕਹਿਣਾ, ਇਹ ਡੇਟਾ "ਗੰਦਾ" ਸ਼੍ਰੇਣੀਬੱਧ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੋਵੇਗੀ। ਇਹ ਪਾਠ ਖ਼ਾਸ ਤੌਰ ਤੇ ਡੇਟਾ ਦੀ ਸਫਾਈ ਅਤੇ ਤਬਦੀਲੀ ਦੇ ਤਕਨੀਕਾਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਿਤ ਕਰਦਾ ਹੈ ਤਾਂ ਜੋ ਕਮੀ, ਗਲਤ ਜਾਂ ਅਧੂਰੇ ਡੇਟਾ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਸੰਭਾਲਿਆ ਜਾ ਸਕੇ। ਇਸ ਪਾਠ ਵਿੱਚ ਕਵਰ ਕੀਤੇ ਟਾਪਿਕਾਂ Python ਅਤੇ Pandas ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੇ ਜਾਣਗੇ ਅਤੇ ਇਸ ਡਾਇਰੈਕਟਰੀ ਦੇ ਅੰਦਰ [ਨੋਟਬੁੱਕ](notebook.ipynb) ਵਿੱਚ ਪ੍ਰਦਰਸ਼ਿਤ ਕੀਤੇ ਜਾਣਗੇ। ## ਡੇਟਾ ਸਾਫ਼ ਕਰਨ ਦੀ ਮਹੱਤਤਾ - **ਵਰਤੋਂ ਅਤੇ ਦੁਬਾਰਾ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨੀ**: ਜਦੋਂ ਡੇਟਾ ਠੀਕ ਢੰਗ ਨਾਲ ਸੰਘਟਿਤ ਅਤੇ ਨਾਰਮਲਾਇਜ਼ ਕੀਤਾ ਗਿਆ ਹੁੰਦਾ ਹੈ ਤਾਂ ਇਹ ਖੋਜਣ, ਵਰਤਣ ਅਤੇ ਦੂਜਿਆਂ ਨਾਲ ਸਾਂਝਾ ਕਰਨ ਵਿੱਚ ਆਸਾਨ ਹੁੰਦਾ ਹੈ। - **ਅਸਮਰੂਪਤਾ**: ਡੇਟਾ ਸਾਇੰਸ ਅਕਸਰ ਇੱਕ ਤੋਂ ਵੱਧ ਡੇਟਾਸੈੱਟ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਿੱਥੇ ਵੱਖ-ਵੱਖ ਸਰੋਤਾਂ ਤੋਂ ਡੇਟਾਸੈੱਟਸ ਨੂੰ ਜੋੜਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਯਕੀਨੀ ਬਣਾਉਣਾ ਕਿ ਹਰ ਇੱਕ ਵਿਅਕਤੀਗਤ ਡੇਟਾ ਸੈੱਟ ਵਿੱਚ ਸਾਂਝਾ ਮਿਆਰੀਕਰਨ ਹੈ, ਇਹ ਜਾਂਚਣਗਾ ਕਿ ਡੇਟਾ ਅਜੇ ਵੀ ਵਰਤਣਯੋਗ ਹੈ ਜਦੋਂ ਉਹ ਸਾਰੇ ਇੱਕ ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਮਿਲਾਏ ਜਾਂਦੇ ਹਨ। - **ਮਾਡਲ ਸਹੀਤਾ**: ਜਿਹੜਾ ਡੇਟਾ ਸਾਫ਼ ਕੀਤਾ ਗਿਆ ਹੈ ਉਹ ਮਾਡਲਾਂ ਦੀ ਸਹੀਤਾ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦਾ ਹੈ ਜੋ ਇਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹਨ। ## ਆਮ ਸਾਫ਼ ਕਰਨ ਦੇ ਲੱਖਣ ਅਤੇ ਰਣਨੀਤੀਆਂ - **ਡੇਟਾਸੈੱਟ ਦੀ ਖੋਜ**: ਡੇਟਾ ਖੋਜ, ਜਿਸਨੂੰ ਇੱਕ [ਬਾਅਦਲੇ ਪਾਠ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/4-Data-Science-Lifecycle/15-analyzing) ਵਿੱਚ ਕਵਰ ਕੀਤਾ ਗਿਆ ਹੈ, ਤੁਹਾਨੂੰ ਉਹ ਡੇਟਾ ਲੱਭਣ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ ਜਿਸਨੂੰ ਸਾਫ਼ ਕਰਨ ਦੀ ਲੋੜ ਹੈ। ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਮੂਲਿਆਂ ਦਾ ਵਿਜ਼ੂਅਲ ਦੇਖਣਾ ਇਹ ਸਮਝਾਉਂਦਾ ਹੈ ਕਿ ਬਾਕੀ ਡੇਟਾ ਕਿਵੇਂ ਦਿੱਸੇਗਾ ਜਾਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾਉਂਦਾ ਹੈ ਜੋ ਹੱਲ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ। ਖੋਜ ਵਿੱਚ ਬੁਨਿਆਦੀ ਕਵੈਰੀ, ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਸੈਮਪਲਿੰਗ ਸ਼ਾਮਿਲ ਹੋ ਸਕਦਾ ਹੈ। - **ਫਾਰਮੈਟਿੰਗ**: ਸਰੋਤ ਦੇ ਮੁਤਾਬਕ, ਡੇਟਾ ਦਿਖਾਵੇ ਵਿੱਚ ਅਸੰਗਤੀਆਂ ਰੱਖ ਸਕਦਾ ਹੈ। ਇਹ ਖੋਜ ਕਰਨ ਅਤੇ ਮੁੱਲ ਨੂੰ ਦਰਸਾਉਣ ਵਿੱਚ ਸਮੱਸਿਆਵਾਂ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ, ਜਿੱਥੇ ਇਹ ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਹੈ ਪਰ ਵਿਜ਼ੂਅਲਾਈਜ਼ੇਸ਼ਨ ਜਾਂ ਕਵੈਰੀ ਨਤੀਜਿਆਂ ਵਿੱਚ ਠੀਕ ਤਰੀਕੇ ਨਾਲ ਦਰਸਾਇਆ ਨਹੀਂ ਗਿਆ। ਆਮ ਫਾਰਮੈਟਿੰਗ ਸਮੱਸਿਆਵਾਂ ਵਿੱਚ ਖਾਲੀ ਸਥਾਨ, ਮਿਤੀਆਂ ਅਤੇ ਡੇਟਾ ਤਰ੍ਹਾਂ ਦਾ ਨਿਪਟਾਰਾ ਸ਼ਾਮਿਲ ਹੈ। ਫਾਰਮੈਟਿੰਗ ਸਮੱਸਿਆਵਾਂ ਦਾ ਨਿਵਾਰਣ ਆਮ ਤੌਰ ਤੇ ਡੇਟਾ ਵਰਤ ਰਹੇ ਲੋਕਾਂ 'ਤੇ ਨਿਰਭਰ ਹੁੰਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਕਿੱਤੇ ਅਤੇ ਨੰਬਰਾਂ ਦੇ ਵਿਖਾਵੇ ਲਈ ਮਿਆਰੀ ਮਾਪਦੰਡ ਦੇਸ਼ ਦਰ ਦੇਸ਼ ਵੱਖਰੇ ਹੋ ਸਕਦੇ ਹਨ। - **ਡੁਪਲਿਕੇਸ਼ਨ**: ਜੇਕਰ ਡੇਟਾ ਵਿੱਚ ਇੱਕ ਤੋਂ ਵੱਧ ਵਾਰ ਹੋਣਾ ਹੈ ਤਾਂ ਇਹ ਗਲਤ ਨਤੀਜੇ ਪੈਦਾ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਆਮ ਤੌਰ 'ਤੇ ਇਸਨੂੰ ਹਟਾ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ। ਇਹ ਸੋਧ ਅਕਸਰ ਦੋ ਜਾਂ ਉਸ ਤੋਂ ਵੱਧ ਡੇਟਾਸੈੱਟ ਨੂੰ ਜੋੜਦੇ ਸਮੇਂ ਵਾਪਰਦਾ ਹੈ। ਪਰ, ਕੁਝ ਮੌਕੇ ਐਸੇ ਵੀ ਹਨ ਜਦੋਂ ਜੋੜੇ ਗਏ ਡੇਟਾਸੈੱਟ ਵਿੱਚ ਡੁਪਲਿਕੇਸ਼ਨ ਵਿੱਚ ਅਜਿਹੇ ਹਿੱਸੇ ਹੋ ਸਕਦੇ ਹਨ ਜੋ ਵਾਧੂ ਜਾਣਕਾਰੀ ਦਿੰਦੇ ਹਨ ਅਤੇ ਉਹਨੂੰ ਸੰਭਾਲਣਾ ਜ਼ਰੂਰੀ ਹੋ ਸਕਦਾ ਹੈ। - **ਗੁੰਮ ਡੇਟਾ**: ਗੁੰਮ ਡੇਟਾ ਗਲਤੀਆਂ ਦੇ ਨਾਲ-ਨਾਲ ਕਮਜ਼ੋਰ ਜਾਂ ਪੱਖਪਾਤੀ ਨਤੀਜੇ ਵੀ ਲਿਆ ਸਕਦਾ ਹੈ। ਕਈ ਵਾਰ ਇਹ ਡੇਟਾ ਮੁੜ لوਡ ਕਰਨ, ਗਣਨਾ ਅਤੇ ਕੋਡ ਜਿਵੇਂ Python ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਗੁਆਂਢੀਆਂ ਮੁੱਲਾਂ ਨੂੰ ਭਰਕੇ, ਜਾਂ ਸਿਰਫ ਉਸ ਮੁੱਲ ਅਤੇ ਸੰਬੰਧਤ ਡੇਟਾ ਨੂੰ ਹਟਾ ਕੇ ਹੱਲ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਡੇਟਾ ਗੁੰਮ ਹੋਣ ਦੇ ਕਈ ਕਾਰਨ ਹੋ ਸਕਦੇ ਹਨ ਅਤੇ ਮੁੱਲਾਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕੀਤੇ ਗਏ ਕਾਰਵਾਈਆਂ ਇਸ ਗੱਲ 'ਤੇ ਨਿਰਭਰ ਕਰਦੀ ਹੈ ਕਿ ਇਹ ਕਿਵੇਂ ਅਤੇ ਕਿਉਂ ਪਹਿਲਾਂ ਗੁੰਮ ਹੋਇਆ ਸੀ। ## DataFrame ਜਾਣਕਾਰੀ ਦੀ ਖੋਜ > **ਸਿੱਖਣ ਦਾ ਲਕੜਾ:** ਇਸ ਉਪ-ਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ 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 ਐਂਟਰੀਆਂ ਹਨ ਚਾਰ ਕਾਲਮਾਂ ਵਿੱਚ ਕਿਸੇ ਵੀ ਖਾਲੀ ਐਂਟਰੀ ਦੇ ਬਿਨਾਂ। ਸਾਰੇ ਡੇਟਾ 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 ਵਿੱਚ ਜਾਣਕਾਰੀ ਬਾਰੇ ਮੈਟਾਡੇਟਾ ਦੇਖ ਕੇ ਜਾਂ ਪਹਿਲੀਆਂ ਅਤੇ ਆਖ਼ਰੀਆਂ ਕੁਝ ਮੁੱਲਾਂ ਨੂੰ ਵੇਖ ਕੇ ਤੁਸੀਂ ਤੁਰੰਤ ਹੀ ਡੇਟਾ ਦੀ ਆਕਾਰ, ਆਕਾਰ-ਰੂਪ ਅਤੇ ਸਮੱਗਰੀ ਦਾ ਅੰਦਾਜ਼ਾ ਲਗਾ ਸਕਦੇ ਹੋ। ## ਗੁੰਮ ਡੇਟਾ ਨਾਲ ਨਿਪਟਣਾ > **ਸਿੱਖਣ ਦਾ ਲਕੜਾ:** ਇਸ ਉਪ-ਭਾਗ ਦੇ ਅੰਤ ਤੱਕ, ਤੁਹਾਨੂੰ ਪਤਾ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ ਕਿ DataFrame ਵਿੱਚੋਂ null ਮੁੱਲਾਂ ਨੂੰ ਕਿਵੇਂ ਬਦਲਣਾ ਜਾਂ ਹਟਾਉਣਾ ਹੈ। ਜਿਆਦਾਤਰ ਸਮੇਂ ਜੋ ਡੇਟਾਸੈੱਟ ਤੁਸੀਂ ਵਰਤਣਾ ਚਾਹੁੰਦੇ ਹੋ (ਜਾਂ ਵਰਤਣੇ ਪੈਂਦੇ ਹਨ) ਉਹਨਾਂ ਵਿੱਚ ਗੁੰਮ ਕੀਤੇ ਮੁੱਲ ਹੁੰਦੇ ਹਨ। ਗੁੰਮ ਡੇਟਾ ਕਿਵੇਂ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ, ਇਸ ਨਾਲ ਸੂਖਮ ਤੌਰ 'ਤੇ ਵਪਾਰ ਬਦਲਾਅ ਹੁੰਦੇ ਹਨ ਜੋ ਤੁਹਾਡੇ ਅੰਤਿਮ ਵਿਸ਼ਲੇਸ਼ਣ ਅਤੇ ਅਸਲੀ ਦੁਨੀਆ ਦੇ ਨਤੀਜਿਆਂ 'ਤੇ ਅਸਰ ਪਾ ਸਕਦੇ ਹਨ। Pandas ਗੁੰਮ ਮੁੱਲਾਂ ਨੂੰ ਦੋ ਤਰੀਕਿਆਂ ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ। ਪਹਿਲਾ ਜੋ ਤੁਸੀਂ ਪਹਿਲਾਂ ਦੇ ਭਾਗਾਂ ਵਿੱਚ ਵੇਖਿਆ ਹੈ: `NaN`, ਜਾਂ Not a Number। ਇਹ ਅਸਲ ਵਿੱਚ ਇੱਕ ਖਾਸ ਮੁੱਲ ਹੈ ਜੋ IEEE ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਵਿਸ਼ੇਸ਼ਣ ਦਾ ਹਿੱਸਾ ਹੈ ਅਤੇ ਸਿਰਫ ਗੁੰਮ ਫਲੋਟਿੰਗ-ਪੌਇੰਟ ਮੁੱਲਾਂ ਦੀ ਦਰਸਾਈ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਫਲੋਟ ਤੋਂ ਇਲਾਵਾ ਗੁੰਮ ਮੁੱਲ ਲਈ, pandas ਪਾਇਥਨ `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 ਡੇਟਾ ਪਛਾਣਣ ਲਈ। ਦੋਹਾਂ ਤੁਹਾਡੇ ਡੇਟਾ ਤੇ ਬੂਲੀਅਨ ਮਾਸਕ ਵਾਪਸ ਕਰਦੀਆਂ ਹਨ। ਅਸੀਂ `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` ਇੱਕ ਅੰਕਗਣਿਤ ਨੱਲ ਹੈ, ਇਹ ਫਿਰ ਵੀ ਇੱਕ ਪੂਰਾ ਅੰਕ ਹੈ ਅਤੇ pandas ਇਸਨੂੰ ਇੱਧਰੇ ਹੀ ਮੰਨਦਾ ਹੈ। `''` ਥੋੜਾ ਜ਼ਿਆਦਾ ਸੁਕੁੰਥ ਹੈ। ਜਿਵੇਂ ਅਸੀਂ ਧਾਰਾ 1 ਵਿੱਚ ਇਸਨੂੰ ਖ਼ਾਲੀ ਸਟਰਿੰਗ ਮੁੱਲ ਦਰਸਾਉਣ ਲਈ ਵਰਤਿਆ ਸੀ, ਪਰ ਇਹ ਫਿਰ ਵੀ ਇੱਕ ਸਟਰਿੰਗ ਆਬਜੈਕਟ ਹੈ ਅਤੇ pandas ਦੇ ਮੁਤਾਬਕ null ਦੀ ਪੇਸ਼ਕਸ਼ ਨਹੀਂ ਹੈ। ਹੁਣ, ਚਲੋ ਇਸਨੂੰ ਪਲਟ ਕੇ ਵਰਤਦੇ ਹਾਂ, ਆਪਣੇ ਅਮਲ ਵਿੱਚ ਜਿਵੇਂ ਤੁਸੀਂ ਇਨ੍ਹਾਂ ਨੂੰ ਵਰਤੋਂਗੇ। ਤੁਸੀਂ ਬੂਲੀਅਨ ਮਾਸਕਾਂ ਨੂੰ ਸਿੱਧਾ ``Series`` ਜਾਂ ``DataFrame`` ਇੰਡੈਕਸ ਵਜੋਂ ਵਰਤ ਸਕਦੇ ਹੋ, ਜੋ ਗੁੰਮ (ਜਾਂ ਮੌਜੂਦ) ਮੁੱਲਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਸਮੇਂ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੋ ਸਕਦਾ ਹੈ। > **ਸਿੱਖਿਆ**: ਦੋਹਾਂ `isnull()` ਅਤੇ `notnull()` ਵਿਧੀਆਂ `DataFrame`s ਵਿੱਚ ਵਰਤਿਆਂ ਸਮਾਨ ਨਤੀਜੇ ਦਿੰਦੇ ਹਨ: ਉਹ ਨਤੀਜੇ ਅਤੇ ਨਤੀਜੇ ਦਾ ਇੰਡੈਕਸ ਦਿਖਾਉਂਦੇ ਹਨ, ਜੋ ਤੁਹਾਨੂੰ ਆਪਣੇ ਡੇਟਾ ਨਾਲ ਸੰਘਰਸ਼ ਕਰਦੇ ਸਮੇਂ ਬਹੁਤ ਮਦਦ ਕਰੇਗਾ। - **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` ਵਿੱਚੋਂ ਇੱਕ ਵੱਧ ਮੁੱਲ ਨਹੀਂ ਹਟਾ ਸਕਦੇ, ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਪੂਰੀਆਂ ਕਤਾਰਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਉਣੇ ਪੈਣਗੇ। ਤੁਸੀਂ ਜੋ ਕਰ ਰਹੇ ਹੋ ਉਸ 'ਤੇ ਨਿਰਭਰ ਕਰਕੇ ਤੁਸੀਂ ਇੱਕ ਜਾਂ ਦੂਸਰਾ ਕਰਨਾ ਚਾਹੋਗੇ, ਇਸ ਲਈ pandas ਦੋਹਾਂ ਲਈ ਤੇਰੇ ਵਿਕਲਪ ਦਿੰਦਾ ਹੈ। ਡੇਟਾ ਸਾਇੰਸ ਵਿੱਚ, ਕਾਲਮ ਆਮ ਤੌਰ 'ਤੇ ਵੈਰੀਏਬਲ ਦਰਸਾਉਂਦੇ ਹਨ ਅਤੇ ਕਤਾਰਾਂ ਅਬਜ਼ਰਵੇਸ਼ਨ, ਇਸ ਲਈ ਤੁਸੀਂ ਜ਼ਿਆਦਾਤਰ ਡੇਟਾ ਕਤਾਰਾਂ ਨੂੰ ਹਟਾਉਣਾ ਚਾਹੋਗੇ; `dropna()` ਦਾ ਡਿਫੌਲਟ ਹੱਲ ਇਹ ਹੈ ਕਿ ਉਹ ਸਾਰੀਆਂ ਕਤਾਰਾਂ ਹਟਾ ਦੇਵੇ ਜੋ ਕਿਸੇ ਵੀ null ਮੁੱਲ ਨੂੰ ਰੱਖਦੀਆਂ ਹਨ: ```python example2.dropna() ``` ``` 0 1 2 1 2.0 5.0 8 ``` ਜੇ ਜਰੂਰੀ ਹੋਵੇ ਤਾਂ ਤੁਸੀਂ ਕਾਲਮ ਤੋਂ NA ਮੁੱਲ ਹਟਾ ਸਕਦੇ ਹੋ। `axis=1` ਵਰਤੋ ਇਸ ਲਈ: ```python example2.dropna(axis='columns') ``` ``` 2 0 7 1 8 2 9 ``` ਦਿਆਨ ਦਿਓ ਕਿ ਇਹ ਕਾਫੀ ਡੇਟਾ ਹਟਾ ਸਕਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਖਾਸ ਕਰਕੇ ਛੋਟੇ ਡੇਟਾਸੈੱਟ ਵਿੱਚ। ਜੇਕਰ ਤੁਸੀਂ ਸਿਰਫ ਉਹ ਕਤਾਰਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਕਈ ਜਾਂ ਸਾਰੇ null ਮੁੱਲ ਰੱਖਦੇ ਹਨ ਤਾਂ? ਤੁਸੀਂ `dropna` ਵਿੱਚ `how` ਅਤੇ `thresh` ਪਰਾਮੀਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਹ ਸੈਟਿੰਗਾਂ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ। ਡਿਫੌਲਟ ਹੈ `how='any'` (ਤੁਸੀਂ ਖੁਦ ਦੇਖਣ ਜਾਂ ਹੋਰ ਪਰਾਮੀਟਰ ਜਾਣਨ ਲਈ `example4.dropna?` ਦੌੜਾ ਸਕਦੇ ਹੋ)। ਤੁਸੀਂ ਬਦਲੇ ਵਿੱਚ `how='all'` ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਤਾਂ ਜੋ ਸਿਰਫ ਉਹ ਕਤਾਰਾਂ ਜਾਂ ਕਾਲਮ ਹਟਾਏ ਜਾਣ ਜੋ ਸਾਰੇ null ਮੁੱਲ ਰੱਖਦੇ ਹਨ। ਇਸਨੂੰ ਦੇਖਣ ਲਈ ਅਸੀਂ ਆਪਣਾ ਉਦਾਹਰਨ DataFrame ਵਧਾਈਏ। ```python 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` ਪਰਾਮੀਟਰ ਤੁਹਾਨੂੰ ਬਹੁਤ ਨਿੱਜੀ ਕਾਬੂ ਦਿੰਦਾ ਹੈ: ਤੁਸੀਂ ਉਹ ਨੰਬਰ ਨਿਰਧਾਰਤ ਕਰਦੇ ਹੋ *ਗੈਰ-ਨਲ* ਮੁੱਲਾਂ ਦਾ ਜੋ ਇੱਕ ਕਤਾਰ ਜਾਂ ਕਾਲਮ ਕੋਲ ਬਣਿਆ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ: ```python 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` ਬਣਾਈਏ ਤਾਂ ਜੋ ਇਨ੍ਹਾਂ ਵਿਧੀਆਂ ਨੂੰ ਅਮਲੀ ਜ਼ਿੰਦਗੀ ਵਿੱਚ ਵੇਖਿਆ ਜਾ ਸਕੇ। ```python 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`: ```python example3.fillna(0) ``` ``` a 1.0 b 0.0 c 2.0 d 0.0 e 3.0 dtype: float64 ``` ਤੁਸੀਂ **ਫਾਰਵਰਡ-ਫਿਲ** null ਮੁੱਲ ਭਰ ਸਕਦੇ ਹੋ, ਜਿਸਦਾ ਅਰਥ ਹੈ ਅਖੀਰਲਾ ਸਕੀਮਤ ਮੁੱਲ ਵਰਤਣਾ ਤਾਂ ਜੋ null ਨੂੰ ਭਰਿਆ ਜਾ ਸਕੇ: ```python example3.fillna(method='ffill') ``` ``` a 1.0 b 1.0 c 2.0 d 2.0 e 3.0 dtype: float64 ``` ਤੁਸੀਂ **ਬੈਕ-ਫਿਲ** ਵੀ ਕਰ ਸਕਦੇ ਹੋ, ਅਗਲਾ ਸਹੀ ਮੁੱਲ ਪਿੱਛੇ ਵੱਲ ਭਰਣ ਲਈ ਵਾਪਰਦਾ ਹੈ: ```python example3.fillna(method='bfill') ``` ``` a 1.0 b 2.0 c 2.0 d 3.0 e 3.0 dtype: float64 ``` ਜਿਵੇਂ ਤੁਸੀਂ ਅਟਕ ਸਕਦੇ ਹੋ, ਇਹ `DataFrame`s ਨਾਲ ਵੀ ਉਹੀ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਇਹ ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਕਿ ਕਿਸ `axis` 'ਤੇ null ਮੁੱਲ ਭਰਣੇ ਹਨ। ਫਿਰ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤੇ `example2` ਨੂੰ ਲਵੋ: ```python 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` ਬਣਾਈਏ ਤਾਂ ਜੋ ਇਹ ਕਾਰਗੁਜ਼ਾਰੀ ਵੇਖੀ ਜਾ ਸਕੇ। ```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) ## ਸਮੀਖਿਆ ਅਤੇ ਸਵੈ ਅਧਿਐਨ ਆਪਣੇ ਡਾਟਾ ਦੀ ਤਿਆਰੀ ਅਤੇ ਸਫਾਈ ਲਈ ਕਈ ਤਰੀਕੇ ਹਨ ਅਤੇ ਡਾਟਾ ਸਾਫ਼ ਕਰਨਾ ਇੱਕ ਮਹੱਤਵਪੂਰਨ ਕਦਮ ਹੈ ਜੋ "ਹੱਥਾਂ-ਉੱਪਰ" ਅਨੁਭਵ ਹੈ। ਇਹ ਚੈਲੈਂਜਜ਼ ਕੋਗਲ ਤੋਂ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਤਾਂ ਜੋ ਉਹ ਤਕਨੀਕਾਂ ਖੋਜ ਸਕੋ ਜੋ ਇਸ ਪਾਠ ਵਿੱਚ ਕਵਰ ਨਹੀਂ ਹੋਈਆਂ। - [ਡਾਟਾ ਸਫਾਈ ਚੈਲੈਂਜ: ਤਰੀਖਾਂ ਨੂੰ ਪਾਰਸ ਕਰਨਾ](https://www.kaggle.com/rtatman/data-cleaning-challenge-parsing-dates/) - [ਡਾਟਾ ਸਫਾਈ ਚੈਲੈਂਜ: ਡਾਟਾ ਨੂੰ ਸਕੇਲ ਅਤੇ ਨਾਰਮਲਾਈਜ਼ ਕਰਨਾ](https://www.kaggle.com/rtatman/data-cleaning-challenge-scale-and-normalize-data) ## ਅਸਾਈਨਮੈਂਟ [ਇੱਕ ਫਾਰਮ ਤੋਂ ਡਾਟਾ ਦਾ ਮੁਲਾਂਕਣ](assignment.md) --- **ਅਸਵੀਕਾਰੋਪਣ**: ਇਸ ਦਸਤਾਵੇਜ਼ ਦਾ ਅਨੁਵਾਦ ਏਆਈ ਅਨੁਵਾਦ ਸੇਵਾ [Co-op Translator](https://github.com/Azure/co-op-translator) ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤਾ ਗਿਆ ਹੈ। ਜਦੋਂ ਕਿ ਅਸੀਂ ਸਹੀਤਾਵਾਂ ਲਈ ਯਤਨਸ਼ੀਲ ਹਾਂ, ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਰੱਖੋ ਕਿ ਸਵੈਚਾਲਿਤ ਅਨੁਵਾਦਾਂ ਵਿੱਚ ਗਲਤੀਆਂ ਜਾਂ ਅਸਮੱਤਿਆਵਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ। ਮੂਲ ਦਸਤਾਵੇਜ਼ ਆਪਣੀ ਮੂਲ ਭਾਸ਼ਾ ਵਿੱਚ ਅਧਿਕਾਰਕ ਸਰੋਤ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਜਰੂਰੀ ਜਾਣਕਾਰੀ ਲਈ, ਪੇਸ਼ੇਵਰ ਮਨੁੱਖੀ ਅਨੁਵਾਦ ਦੀ ਸਿਫ਼ਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਅਸੀਂ ਇਸ ਅਨੁਵਾਦ ਦੇ ਉਪਯੋਗ ਤੋਂ ਪੈਦਾ ਹੋਣ ਵਾਲੀਆਂ ਕਿਸੇ ਵੀ ਗਲਤਫਹਿਮੀਆਂ ਜਾਂ ਗਲਤ ਵਿਆਖਿਆਵਾਂ ਲਈ ਜਵਾਬਦੇਹ ਨਹੀਂ ਹਾਂ।