msb-public
/
Data-Science-For-Beginners
mirror of https://github.com/microsoft/Data-Science-For-Beginners.git
1
0
Code Issues Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
Data-Science-For-Beginners/translations/kn/2-Working-With-Data/08-data-preparation/README.md

335 lines
37 KiB
Raw Permalink Blame History

# ಡೇಟಾ ಜೊತೆಗೆ ಕೆಲಸ ಮಾಡುವುದು: ಡೇಟಾ ತಯಾರಿ
|![ [(@sketchthedocs)](https://sketchthedocs.dev) ಅವರಿಂದ ಸ್ಕೆಚ್ ನೋಟ್ ](../../sketchnotes/08-DataPreparation.png)|
|:---:|
|ಡೇಟಾ ತಯಾರಿ - _[@nitya](https://twitter.com/nitya) ಅವರಿಂದ ಸ್ಕೆಚ್ ನೋಟ್_ |
## [ಪೂರ್ವ-ಲೇಕ್ಚರ್ ಕ್ವಿಜ್](https://ff-quizzes.netlify.app/en/ds/quiz/14)
ಮೂಲದ ಮೇಲೆ ಅವಲಂಬಿಸಿ, ಕಚ್ಚಾ ಡೇಟಾ ಕೆಲವು ಅಸಮಾನತೆಗಳನ್ನು ಹೊಂದಿರಬಹುದು, ಇದು ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ಮಾದರೀಕರಣದಲ್ಲಿ ಸವಾಲುಗಳನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ. ಬೇರೆ ಮಾತಿನಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಈ ಡೇಟಾವನ್ನು "ಕಳಪೆ" ಎಂದು ವರ್ಗೀಕರಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಅಗತ್ಯವಿದೆ. ಈ ಪಾಠವು ಕಳೆದುಹೋಗಿರುವ, ತಪ್ಪು ಅಥವಾ ಅಪೂರ್ಣ ಡೇಟಾ ಸವಾಲುಗಳನ್ನು ನಿಭಾಯಿಸಲು ಡೇಟಾವನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುವ ಮತ್ತು ಪರಿವರ್ತಿಸುವ ತಂತ್ರಗಳನ್ನು ಕೇಂದ್ರೀಕರಿಸುತ್ತದೆ. ಈ ಪಾಠದಲ್ಲಿ ಒಳಗೊಂಡ ವಿಷಯಗಳು ಪೈಥಾನ್ ಮತ್ತು ಪಾಂಡಾಸ್ ಗ್ರಂಥಾಲಯವನ್ನು ಬಳಸುತ್ತವೆ ಮತ್ತು ಈ ಡೈರೆಕ್ಟರಿಯೊಳಗಿನ [ನೋಟ್ಬುಕ್](notebook.ipynb) ನಲ್ಲಿ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.
## ಡೇಟಾ ಸ್ವಚ್ಛಗೊಳಿಸುವ ಮಹತ್ವ
- **ಬಳಕೆ ಮತ್ತು ಮರುಬಳಕೆ ಸುಲಭತೆ**: ಡೇಟಾ ಸರಿಯಾಗಿ ಸಂಘಟಿತ ಮತ್ತು ಸಾಮಾನ್ಯೀಕೃತವಾಗಿದ್ದಾಗ, ಅದನ್ನು ಹುಡುಕುವುದು, ಬಳಸುವುದು ಮತ್ತು ಇತರರೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳುವುದು ಸುಲಭವಾಗುತ್ತದೆ.
- **ಸಮಾನತೆ**: ಡೇಟಾ ವಿಜ್ಞಾನದಲ್ಲಿ ಸಾಮಾನ್ಯವಾಗಿ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಡೇಟಾಸೆಟ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ, ವಿವಿಧ ಮೂಲಗಳಿಂದ ಬಂದ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ. ಪ್ರತಿ ಡೇಟಾಸೆಟ್‌ಗೆ ಸಾಮಾನ್ಯ ಮಾನದಂಡವನ್ನು ಖಚಿತಪಡಿಸುವುದು, ಅವುಗಳನ್ನು ಒಂದೇ ಡೇಟಾಸೆಟ್ ಆಗಿ ಮಿಶ್ರಣ ಮಾಡಿದಾಗ ಡೇಟಾ ಉಪಯುಕ್ತವಾಗಿರುತ್ತದೆ.
- **ಮಾದರಿ ನಿಖರತೆ**: ಸ್ವಚ್ಛಗೊಳಿಸಿದ ಡೇಟಾ ಆಧಾರಿತ ಮಾದರಿಗಳ ನಿಖರತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
## ಸಾಮಾನ್ಯ ಸ್ವಚ್ಛಗೊಳಿಸುವ ಗುರಿಗಳು ಮತ್ತು ತಂತ್ರಗಳು
- **ಡೇಟಾಸೆಟ್ ಅನ್ವೇಷಣೆ**: ಡೇಟಾ ಅನ್ವೇಷಣೆ, ಇದು [ನಂತರದ ಪಾಠದಲ್ಲಿ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/4-Data-Science-Lifecycle/15-analyzing) ಒಳಗೊಂಡಿದೆ, ಸ್ವಚ್ಛಗೊಳಿಸುವ ಅಗತ್ಯವಿರುವ ಡೇಟಾವನ್ನು ಕಂಡುಹಿಡಿಯಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಡೇಟಾಸೆಟ್‌ನ ಮೌಲ್ಯಗಳನ್ನು ದೃಶ್ಯವಾಗಿ ಗಮನಿಸುವುದು ಉಳಿದ ಭಾಗವು ಹೇಗಿರಬಹುದು ಎಂಬ ನಿರೀಕ್ಷೆಗಳನ್ನು ಹೊಂದಲು ಅಥವಾ ಪರಿಹರಿಸಬಹುದಾದ ಸಮಸ್ಯೆಗಳ ಕಲ್ಪನೆಯನ್ನು ನೀಡಬಹುದು. ಅನ್ವೇಷಣೆ ಮೂಲಭೂತ ಪ್ರಶ್ನೆ, ದೃಶ್ಯೀಕರಣ ಮತ್ತು ಮಾದರಿಯನ್ನು ಒಳಗೊಂಡಿರಬಹುದು.
- **ರೂಪರೇಖೆ**: ಮೂಲದ ಮೇಲೆ ಅವಲಂಬಿಸಿ, ಡೇಟಾ ಪ್ರಸ್ತುತಪಡಿಸುವ ರೀತಿಯಲ್ಲಿ ಅಸಮಾನತೆಗಳಿರಬಹುದು. ಇದು ಮೌಲ್ಯವನ್ನು ಹುಡುಕಲು ಮತ್ತು ಪ್ರತಿನಿಧಿಸಲು ಸಮಸ್ಯೆಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು, ಅದು ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ಕಾಣಿಸಬಹುದು ಆದರೆ ದೃಶ್ಯೀಕರಣ ಅಥವಾ ಪ್ರಶ್ನೆ ಫಲಿತಾಂಶಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ಪ್ರತಿನಿಧಿಸಲಾಗುವುದಿಲ್ಲ. ಸಾಮಾನ್ಯ ರೂಪರೇಖೆ ಸಮಸ್ಯೆಗಳು ಶೂನ್ಯಸ್ಥಾನ, ದಿನಾಂಕಗಳು ಮತ್ತು ಡೇಟಾ ಪ್ರಕಾರಗಳನ್ನು ಪರಿಹರಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತವೆ. ರೂಪರೇಖೆ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುವುದು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾವನ್ನು ಬಳಸುವವರ ಜವಾಬ್ದಾರಿಯಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ದಿನಾಂಕಗಳು ಮತ್ತು ಸಂಖ್ಯೆಗಳ ಪ್ರಸ್ತುತಪಡಿಸುವ ಮಾನದಂಡಗಳು ದೇಶದ ಪ್ರಕಾರ ಬದಲಾಗಬಹುದು.
- **ನಕಲುಗಳು**: ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಸಂಭವನೆಯಿರುವ ಡೇಟಾ ತಪ್ಪು ಫಲಿತಾಂಶಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ತೆಗೆದುಹಾಕಬೇಕು. ಇದು ಎರಡು ಅಥವಾ ಹೆಚ್ಚು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಸೇರಿಸುವಾಗ ಸಾಮಾನ್ಯವಾಗಿರಬಹುದು. ಆದರೆ, ಸೇರಿಸಿದ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ನಕಲುಗಳು ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿಯನ್ನು ಒದಗಿಸುವ ತುಂಡುಗಳನ್ನು ಹೊಂದಿರಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಉಳಿಸಬೇಕಾಗಬಹುದು.
- **ಕಳೆದುಹೋಗಿರುವ ಡೇಟಾ**: ಕಳೆದುಹೋಗಿರುವ ಡೇಟಾ ತಪ್ಪುಗಳು ಮತ್ತು ದುರ್ಬಲ ಅಥವಾ ಪಕ್ಷಪಾತಿ ಫಲಿತಾಂಶಗಳನ್ನು ಉಂಟುಮಾಡಬಹುದು. ಕೆಲವೊಮ್ಮೆ ಇದನ್ನು ಡೇಟಾವನ್ನು "ಮರುಲೋಡ್" ಮಾಡುವ ಮೂಲಕ, ಗಣನೆ ಮತ್ತು ಪೈಥಾನ್ ಕೋಡ್ ಬಳಸಿ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ತುಂಬಿಸುವ ಮೂಲಕ ಅಥವಾ ಸರಳವಾಗಿ ಮೌಲ್ಯ ಮತ್ತು ಸಂಬಂಧಿತ ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ಪರಿಹರಿಸಬಹುದು. ಡೇಟಾ ಕಳೆದುಹೋಗುವ ಹಲವು ಕಾರಣಗಳಿವೆ ಮತ್ತು ಈ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಪರಿಹರಿಸಲು ತೆಗೆದುಕೊಳ್ಳುವ ಕ್ರಮಗಳು ಮೊದಲಿಗೆ ಅವು ಹೇಗೆ ಮತ್ತು ಏಕೆ ಕಳೆದುಹೋಗಿದೆಯೋ ಅವಲಂಬಿತವಾಗಿರುತ್ತವೆ.
## ಡೇಟಾಫ್ರೇಮ್ ಮಾಹಿತಿಯನ್ನು ಅನ್ವೇಷಿಸುವುದು
> **ಕಲಿಕೆಯ ಗುರಿ:** ಈ ಉಪವಿಭಾಗದ ಕೊನೆಯಲ್ಲಿ, ಪಾಂಡಾಸ್ ಡೇಟಾಫ್ರೇಮ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾದ ಡೇಟಾ ಬಗ್ಗೆ ಸಾಮಾನ್ಯ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಲು ನೀವು ಆರಾಮವಾಗಿ ಇರಬೇಕು.
ನೀವು ನಿಮ್ಮ ಡೇಟಾವನ್ನು ಪಾಂಡಾಸ್‌ಗೆ ಲೋಡ್ ಮಾಡಿದ ನಂತರ, ಅದು ಬಹುಶಃ ಡೇಟಾಫ್ರೇಮ್ ಆಗಿರುತ್ತದೆ (ವಿಸ್ತೃತ ಅವಲೋಕನಕ್ಕಾಗಿ ಹಿಂದಿನ [ಪಾಠ](https://github.com/microsoft/Data-Science-For-Beginners/tree/main/2-Working-With-Data/07-python#dataframe) ನೋಡಿ). ಆದರೆ, ನಿಮ್ಮ ಡೇಟಾಫ್ರೇಮ್‌ನಲ್ಲಿ 60,000 ಸಾಲುಗಳು ಮತ್ತು 400 ಕಾಲಮ್‌ಗಳಿದ್ದರೆ, ನೀವು ಯಾವ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದೀರಿ ಎಂಬುದರ ಅರ್ಥವನ್ನು ಹೇಗೆ ಪಡೆಯುತ್ತೀರಿ? ಭಾಗ್ಯವಶಾತ್, [pandas](https://pandas.pydata.org/) ಡೇಟಾಫ್ರೇಮ್ ಬಗ್ಗೆ ಒಟ್ಟು ಮಾಹಿತಿಯನ್ನು ಮತ್ತು ಮೊದಲ ಕೆಲವು ಮತ್ತು ಕೊನೆಯ ಕೆಲವು ಸಾಲುಗಳನ್ನು ತ್ವರಿತವಾಗಿ ನೋಡಲು ಅನುಕೂಲಕರ ಸಾಧನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
ಈ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅನ್ವೇಷಿಸಲು, ನಾವು ಪೈಥಾನ್ ಸ್ಕಿಕಿಟ್-ಲರ್ನ್ ಗ್ರಂಥಾಲಯವನ್ನು ಆಮದುಮಾಡಿ ಮತ್ತು ಐಕಾನಿಕ್ ಡೇಟಾಸೆಟ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ: **ಐರಿಸ್ ಡೇಟಾ ಸೆಟ್**.
```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'])
```
| |ಸೆಪಲ್ ಉದ್ದ (ಸೆಂಮೀ)|ಸೆಪಲ್ ಅಗಲ (ಸೆಂಮೀ)|ಪೆಟಲ್ ಉದ್ದ (ಸೆಂಮೀ)|ಪೆಟಲ್ ಅಗಲ (ಸೆಂಮೀ)|
|----------------------------------------|-----------------|----------------|-----------------|----------------|
|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
```
ಇದರಿಂದ, *ಐರಿಸ್* ಡೇಟಾಸೆಟ್‌ನಲ್ಲಿ ನಾಲ್ಕು ಕಾಲಮ್‌ಗಳಲ್ಲಿ 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
```
> **ತೀರ್ಮಾನ:** ಡೇಟಾಫ್ರೇಮ್‌ನ ಮಾಹಿತಿಯ ಮೆಟಾಡೇಟಾ ಅಥವಾ ಅದರ ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಕೆಲವು ಮೌಲ್ಯಗಳನ್ನು ನೋಡಿದರೆ, ನೀವು ತಕ್ಷಣವೇ ಡೇಟಾದ ಗಾತ್ರ, ಆಕಾರ ಮತ್ತು ವಿಷಯದ ಬಗ್ಗೆ ಕಲ್ಪನೆ ಪಡೆಯಬಹುದು.
## ಕಳೆದುಹೋಗಿರುವ ಡೇಟಾ ನಿಭಾಯಿಸುವುದು
> **ಕಲಿಕೆಯ ಗುರಿ:** ಈ ಉಪವಿಭಾಗದ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಡೇಟಾಫ್ರೇಮ್‌ಗಳಿಂದ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸಬೇಕು ಅಥವಾ ತೆಗೆದುಹಾಕಬೇಕು ಎಂಬುದನ್ನು ತಿಳಿದುಕೊಳ್ಳಬೇಕು.
ನೀವು ಬಳಸಲು ಬಯಸುವ (ಅಥವಾ ಬಳಸಬೇಕಾಗಿರುವ) ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ಬಹುಶಃ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳಿರುತ್ತವೆ. ಕಳೆದುಹೋಗಿರುವ ಡೇಟಾವನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸುವುದು ಅಂತಿಮ ವಿಶ್ಲೇಷಣೆ ಮತ್ತು ನೈಜ ಜಗತ್ತಿನ ಫಲಿತಾಂಶಗಳಿಗೆ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ತರಬಹುದು.
ಪಾಂಡಾಸ್ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಎರಡು ರೀತಿಯಲ್ಲಿ ನಿಭಾಯಿಸುತ್ತದೆ. ಮೊದಲನೆಯದು ನೀವು ಹಿಂದಿನ ವಿಭಾಗಗಳಲ್ಲಿ ನೋಡಿದ್ದೀರಿ: `NaN`, ಅಥವಾ ನಂಬರ್ ಅಲ್ಲ. ಇದು ವಾಸ್ತವದಲ್ಲಿ IEEE ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಸ್ಪೆಸಿಫಿಕೇಶನ್‌ನ ಭಾಗವಾದ ವಿಶೇಷ ಮೌಲ್ಯ ಮತ್ತು ಇದು ಕಳೆದುಹೋಗಿರುವ ಫ್ಲೋಟಿಂಗ್-ಪಾಯಿಂಟ್ ಮೌಲ್ಯಗಳನ್ನು ಸೂಚಿಸಲು ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ.
ಫ್ಲೋಟ್ಸ್ ಹೊರತುಪಡಿಸಿ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳಿಗೆ, ಪಾಂಡಾಸ್ ಪೈಥಾನ್ `None` ವಸ್ತುವನ್ನು ಬಳಸುತ್ತದೆ. ನೀವು ಎರಡು ವಿಭಿನ್ನ ರೀತಿಯ ಮೌಲ್ಯಗಳನ್ನು ಎದುರಿಸುವುದು ಗೊಂದಲಕಾರಿಯಾಗಬಹುದು, ಆದರೆ ಈ ವಿನ್ಯಾಸಕ್ಕೆ ತರ್ಕಬದ್ಧ ಕಾರಣಗಳಿವೆ ಮತ್ತು ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಈ ಮಾರ್ಗವು ಬಹುತೇಕ ಪ್ರಕರಣಗಳಿಗೆ ಉತ್ತಮ ಸಮಾಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, `None` ಮತ್ತು `NaN` ಎರಡೂ ಬಳಕೆಗೆ ಸಂಬಂಧಿಸಿದ ನಿರ್ಬಂಧಗಳನ್ನು ಹೊಂದಿವೆ.
`NaN` ಮತ್ತು `None` ಬಗ್ಗೆ ಹೆಚ್ಚಿನ ಮಾಹಿತಿಗಾಗಿ [ನೋಟ್ಬುಕ್](https://github.com/microsoft/Data-Science-For-Beginners/blob/main/4-Data-Science-Lifecycle/15-analyzing/notebook.ipynb) ನೋಡಿ!
- **ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಪತ್ತೆಹಚ್ಚುವುದು**: `pandas` ನಲ್ಲಿ, `isnull()` ಮತ್ತು `notnull()` ವಿಧಾನಗಳು ನಲ್ ಡೇಟಾವನ್ನು ಪತ್ತೆಹಚ್ಚಲು ನಿಮ್ಮ ಪ್ರಮುಖ ವಿಧಾನಗಳಾಗಿವೆ. ಎರಡೂ ನಿಮ್ಮ ಡೇಟಾದ ಮೇಲೆ ಬೂಲಿಯನ್ ಮಾಸ್ಕ್‌ಗಳನ್ನು ನೀಡುತ್ತವೆ. ನಾವು `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` ಗಣಿತೀಯ ನಲ್ ಆಗಿದ್ದರೂ, ಅದು ಸಂಪೂರ್ಣವಾಗಿ ಒಳ್ಳೆಯ ಪೂರ್ಣಾಂಕ ಮತ್ತು ಪಾಂಡಾಸ್ ಅದನ್ನು ಹಾಗೆಯೇ ಪರಿಗಣಿಸುತ್ತದೆ. `''` ಸ್ವಲ್ಪ ಸೂಕ್ಷ್ಮವಾಗಿದೆ. ನಾವು ಅದನ್ನು ಖಾಲಿ ಸ್ಟ್ರಿಂಗ್ ಮೌಲ್ಯವನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಉಪಯೋಗಿಸಿದ್ದರೂ, ಅದು ಸ್ಟ್ರಿಂಗ್ ವಸ್ತು ಮತ್ತು ಪಾಂಡಾಸ್ ದೃಷ್ಟಿಯಿಂದ ನಲ್ ಪ್ರತಿನಿಧಿಸುವುದಲ್ಲ.
ಈಗ, ಇದನ್ನು ತಿರುಗಿಸಿ, ನೀವು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಬಳಸುವ ರೀತಿಯಲ್ಲಿ ಈ ವಿಧಾನಗಳನ್ನು ಬಳಸೋಣ. ನೀವು ಬೂಲಿಯನ್ ಮಾಸ್ಕ್‌ಗಳನ್ನು ನೇರವಾಗಿ ``Series`` ಅಥವಾ ``DataFrame`` ಸೂಚ್ಯಂಕವಾಗಿ ಬಳಸಬಹುದು, ಇದು ಕಳೆದುಹೋಗಿರುವ (ಅಥವಾ ಇರುವ) ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಉಪಯುಕ್ತವಾಗಬಹುದು.
> **ತೀರ್ಮಾನ:** `isnull()` ಮತ್ತು `notnull()` ಎರಡೂ `DataFrame`ಗಳಲ್ಲಿ ಬಳಸಿದಾಗ ಸಮಾನ ಫಲಿತಾಂಶಗಳನ್ನು ನೀಡುತ್ತವೆ: ಅವು ಫಲಿತಾಂಶಗಳನ್ನೂ ಮತ್ತು ಆ ಫಲಿತಾಂಶಗಳ ಸೂಚ್ಯಂಕವನ್ನೂ ತೋರಿಸುತ್ತವೆ, ಇದು ನಿಮ್ಮ ಡೇಟಾ ಜೊತೆ ಹೋರಾಡುವಾಗ ಬಹಳ ಸಹಾಯ ಮಾಡುತ್ತದೆ.
- **ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು**: ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಗುರುತಿಸುವುದನ್ನು ಮೀರಿ, ಪಾಂಡಾಸ್ `Series` ಮತ್ತು `DataFrame`ಗಳಿಂದ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕಲು ಅನುಕೂಲಕರ ವಿಧಾನವನ್ನು ಒದಗಿಸುತ್ತದೆ. (ವಿಶಾಲ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ, missing [NA] ಮೌಲ್ಯಗಳನ್ನು ನಿಮ್ಮ ವಿಶ್ಲೇಷಣೆಯಿಂದ ತೆಗೆದುಹಾಕುವುದು ಅವುಗಳನ್ನು ಬೇರೆ ರೀತಿಯಲ್ಲಿ ನಿಭಾಯಿಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ.) ಇದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, `example1` ಗೆ ಮರಳೋಣ:
```python
example1 = example1.dropna()
example1
```
```
0 0
2
dtype: object
```
ನೀವು ಇದನ್ನು `example3[example3.notnull()]` ನಿಂದ ನಿಮ್ಮ ಔಟ್‌ಪುಟ್‌ನಂತೆ ಕಾಣಬೇಕು. ಇಲ್ಲಿ ವ್ಯತ್ಯಾಸವೆಂದರೆ, ಮಾಸ್ಕ್ ಮಾಡಿದ ಮೌಲ್ಯಗಳ ಮೇಲೆ ಸೂಚ್ಯಂಕ ಮಾಡುವ ಬದಲು, `dropna` ಆ ಕಳೆದುಹೋಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು `Series` `example1` ನಿಂದ ತೆಗೆದುಹಾಕಿದೆ.
`DataFrame` ಗಳು ಎರಡು ಆಯಾಮಗಳನ್ನು ಹೊಂದಿರುವುದರಿಂದ, ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕಲು ಹೆಚ್ಚಿನ ಆಯ್ಕೆಗಳು ಇವೆ.
```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 |
(ನೀವು ಗಮನಿಸಿದ್ದೀರಾ, ಪಾಂಡಾಸ್ `NaN` ಗಳನ್ನು ಹೊಂದಿಸಲು ಎರಡು ಕಾಲಮ್‌ಗಳನ್ನು ಫ್ಲೋಟ್‌ಗಳಿಗೆ ಅಪ್‌ಕಾಸ್ಟ್ ಮಾಡಿದೆ?)
ನೀವು `DataFrame` ನಿಂದ ಒಂದು ಮೌಲ್ಯವನ್ನು ಮಾತ್ರ ತೆಗೆದುಹಾಕಲು ಸಾಧ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನೀವು ಸಂಪೂರ್ಣ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ತೆಗೆದುಹಾಕಬೇಕು. ನೀವು ಏನು ಮಾಡುತ್ತಿದ್ದೀರೋ ಅವಲಂಬಿಸಿ, ನೀವು ಒಂದನ್ನು ಅಥವಾ ಇನ್ನೊಂದನ್ನು ಮಾಡಬಹುದು, ಆದ್ದರಿಂದ ಪಾಂಡಾಸ್ ಎರಡಕ್ಕೂ ಆಯ್ಕೆಯನ್ನು ನೀಡುತ್ತದೆ. ಡೇಟಾ ವಿಜ್ಞಾನದಲ್ಲಿ, ಕಾಲಮ್‌ಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಚರಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ ಮತ್ತು ಸಾಲುಗಳು ಅವಲೋಕನಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ನೀವು ಹೆಚ್ಚು ಸಾಧ್ಯತೆ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವಿರಿ; `dropna()` ನ ಡೀಫಾಲ್ಟ್ ಸೆಟ್ಟಿಂಗ್ ಯಾವುದೇ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಎಲ್ಲಾ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು:
```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
```
ನೀವು ಗಮನಿಸಿದರೆ, ಇದು ನೀವು ಉಳಿಸಬೇಕಾದ ಬಹಳಷ್ಟು ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕಬಹುದು, ವಿಶೇಷವಾಗಿ ಸಣ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ. ನೀವು ಕೆಲವೊಮ್ಮೆ ಅಥವಾ ಎಲ್ಲಾ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ತೆಗೆದುಹಾಕಲು ಬಯಸಿದರೆ? ನೀವು `dropna` ನಲ್ಲಿ `how` ಮತ್ತು `thresh` ಪರಿಮಾಣಗಳನ್ನು ಬಳಸಬಹುದು.
ಡೀಫಾಲ್ಟ್ ಆಗಿ, `how='any'` (ನೀವು ಸ್ವತಃ ಪರಿಶೀಲಿಸಲು ಅಥವಾ ವಿಧಾನದಲ್ಲಿ ಇನ್ನಾವುದೇ ಪರಿಮಾಣಗಳಿವೆ ಎಂದು ನೋಡಲು, ಕೋಡ್ ಸೆಲ್‌ನಲ್ಲಿ `example4.dropna?` ಅನ್ನು ರನ್ ಮಾಡಿ). ನೀವು ಬದಲಿ ಆಯ್ಕೆಯಾಗಿ `how='all'` ಅನ್ನು ಸೂಚಿಸಬಹುದು, ಇದು ಎಲ್ಲಾ ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿರುವ ಸಾಲುಗಳು ಅಥವಾ ಕಾಲಮ್‌ಗಳನ್ನು ಮಾತ್ರ ತೆಗೆದುಹಾಕುತ್ತದೆ. ಈ ಕಾರ್ಯವನ್ನು ನೋಡಲು ನಮ್ಮ ಉದಾಹರಣೆಯ `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
```
ಇಲ್ಲಿ, ಮೊದಲ ಮತ್ತು ಕೊನೆಯ ಸಾಲುಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗಿದೆ, ಏಕೆಂದರೆ ಅವುಗಳಲ್ಲಿ ಕೇವಲ ಎರಡು ನಾನ್-ನಲ್ ಮೌಲ್ಯಗಳಿವೆ.
- **ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತುಂಬುವುದು**: ನಿಮ್ಮ ಡೇಟಾಸೆಟ್ ಮೇಲೆ ಅವಲಂಬಿಸಿ, ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದಕ್ಕಿಂತ ಮಾನ್ಯ ಮೌಲ್ಯಗಳಿಂದ ತುಂಬುವುದು ಹೆಚ್ಚು ಅರ್ಥಪೂರ್ಣವಾಗಬಹುದು. ನೀವು ಇದನ್ನು ಸ್ಥಳದಲ್ಲಿ ಮಾಡಲು `isnull` ಅನ್ನು ಬಳಸಬಹುದು, ಆದರೆ ಇದು ಬಹಳ ಶ್ರಮದಾಯಕವಾಗಬಹುದು, ವಿಶೇಷವಾಗಿ ತುಂಬಬೇಕಾದ ಮೌಲ್ಯಗಳ ಸಂಖ್ಯೆ ಹೆಚ್ಚು ಇದ್ದರೆ. ಡೇಟಾ ವಿಜ್ಞಾನದಲ್ಲಿ ಇದು ಸಾಮಾನ್ಯ ಕಾರ್ಯವಾಗಿರುವುದರಿಂದ, ಪಾಂಡಾಸ್ `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
```
ನೀವು ಎಲ್ಲಾ ನಲ್ ಎಂಟ್ರಿಗಳನ್ನು ಒಂದೇ ಮೌಲ್ಯದಿಂದ, ಉದಾಹರಣೆಗೆ `0` ರಿಂದ ತುಂಬಬಹುದು:
```python
example3.fillna(0)
```
```
a 1.0
b 0.0
c 2.0
d 0.0
e 3.0
dtype: float64
```
ನೀವು ನಲ್ ಮೌಲ್ಯಗಳನ್ನು **ಮುಂದಿನ ಮೌಲ್ಯದಿಂದ ತುಂಬಬಹುದು**, ಅಂದರೆ ಕೊನೆಯ ಮಾನ್ಯ ಮೌಲ್ಯವನ್ನು ಬಳಸಿ ನಲ್ ಅನ್ನು ತುಂಬುವುದು:
```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` ಗಳೊಂದಿಗೆ ಸಹ ಇದೇ ರೀತಿಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತದೆ, ಆದರೆ ನೀವು ನಲ್ ಮೌಲ್ಯಗಳನ್ನು ತುಂಬಲು `axis` ಅನ್ನು ಸೂಚಿಸಬಹುದು. ಹಿಂದಿನ `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
```
ಮುಂದಿನ ಮೌಲ್ಯದಿಂದ ತುಂಬುವಾಗ, ಹಿಂದಿನ ಮಾನ್ಯ ಮೌಲ್ಯ ಲಭ್ಯವಿಲ್ಲದಿದ್ದರೆ, ನಲ್ ಮೌಲ್ಯ ಉಳಿಯುತ್ತದೆ.
> **ತೀರ್ಮಾನ:** ನಿಮ್ಮ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ಕಾಣೆಯಾಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಹಲವು ವಿಧಾನಗಳಿವೆ. ನೀವು ಬಳಸುವ ನಿರ್ದಿಷ್ಟ ತಂತ್ರ (ಅವುಗಳನ್ನು ತೆಗೆದುಹಾಕುವುದು, ಬದಲಿಸುವುದು, ಅಥವಾ ಬದಲಿಸುವ ವಿಧಾನ) ಆ ಡೇಟಾದ ವಿಶೇಷತೆಯಿಂದ ನಿರ್ಧರಿಸಬೇಕು. ನೀವು ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಹೆಚ್ಚು ಹ್ಯಾಂಡಲ್ ಮಾಡಿ ಸಂವಹನ ಮಾಡಿದಂತೆ ಕಾಣೆಯಾಗಿರುವ ಮೌಲ್ಯಗಳನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕೆಂಬ ಉತ್ತಮ ಅರ್ಥವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸುತ್ತೀರಿ.
## ನಕಲಿ ಡೇಟಾವನ್ನು ತೆಗೆದುಹಾಕುವುದು
> **ಕಲಿಕೆಯ ಗುರಿ:** ಈ ಉಪವಿಭಾಗದ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಡೇಟಾಫ್ರೇಮ್‌ಗಳಿಂದ ನಕಲಿ ಮೌಲ್ಯಗಳನ್ನು ಗುರುತಿಸಿ ತೆಗೆದುಹಾಕಲು ಆರಾಮವಾಗಿ ಇರಬೇಕು.
ಕಾಣೆಯಾಗಿರುವ ಡೇಟಾದ ಜೊತೆಗೆ, ನೀವು ನಿಜಜೀವನದ ಡೇಟಾಸೆಟ್‌ಗಳಲ್ಲಿ ನಕಲಿ ಡೇಟಾವನ್ನು ಸಹ συχνά ಎದುರಿಸುತ್ತೀರಿ. ಭಾಗ್ಯವಶಾತ್, `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` ನಲ್ಲಿ ಕೆಲವು ಕಾಲಮ್‌ಗಳ subset ಅನ್ನು ಮಾತ್ರ ಪರಿಶೀಲಿಸಲು ಸೂಚಿಸಬಹುದು:
```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)
---
<!-- CO-OP TRANSLATOR DISCLAIMER START -->
**ಅಸ್ವೀಕರಣ**:
ಈ ದಸ್ತಾವೇಜು AI ಅನುವಾದ ಸೇವೆ [Co-op Translator](https://github.com/Azure/co-op-translator) ಬಳಸಿ ಅನುವಾದಿಸಲಾಗಿದೆ. ನಾವು ನಿಖರತೆಯಿಗಾಗಿ ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದರೂ, ಸ್ವಯಂಚಾಲಿತ ಅನುವಾದಗಳಲ್ಲಿ ತಪ್ಪುಗಳು ಅಥವಾ ಅಸತ್ಯತೆಗಳು ಇರಬಹುದು ಎಂದು ದಯವಿಟ್ಟು ಗಮನಿಸಿ. ಮೂಲ ಭಾಷೆಯಲ್ಲಿರುವ ಮೂಲ ದಸ್ತಾವೇಜನ್ನು ಅಧಿಕೃತ ಮೂಲವೆಂದು ಪರಿಗಣಿಸಬೇಕು. ಮಹತ್ವದ ಮಾಹಿತಿಗಾಗಿ, ವೃತ್ತಿಪರ ಮಾನವ ಅನುವಾದವನ್ನು ಶಿಫಾರಸು ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಅನುವಾದ ಬಳಕೆಯಿಂದ ಉಂಟಾಗುವ ಯಾವುದೇ ತಪ್ಪು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿಕೆ ಅಥವಾ ತಪ್ಪು ವಿವರಣೆಗಳಿಗೆ ನಾವು ಹೊಣೆಗಾರರಾಗುವುದಿಲ್ಲ.
<!-- CO-OP TRANSLATOR DISCLAIMER END -->
Reference in new issue View Git Blame Copy Permalink