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/te/2-Working-With-Data/08-data-preparation/README.md

341 lines
35 KiB
Raw Permalink Blame History

# Working with Data: Data Preparation
|![ 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 లో సమాచారం గురించి మెటాడేటాను లేదా మొదటి మరియు చివరి కొన్ని విలువలను చూసి కూడా, మీరు పని చేస్తున్న డేటా యొక్క పరిమాణం, ఆకారం మరియు కంటెంట్ గురించి తక్షణ ఆలోచన పొందవచ్చు.
## లేకపోయిన డేటాతో వ్యవహరించడం
> **అభ్యాస లక్ష్యం:** ఈ ఉపవిభాగం చివరికి, మీరు DataFrames నుండి నల్ విలువలను ఎలా మార్చాలి లేదా తొలగించాలో తెలుసుకోవాలి.
మీరు ఉపయోగించాలనుకునే (లేదా ఉపయోగించాల్సి ఉన్న) డేటాసెట్‌లలో ఎక్కువసార్లు లేకపోయిన విలువలు ఉంటాయి. లేకపోయిన డేటాను ఎలా నిర్వహించాలో నిర్ణయించడం మీ తుది విశ్లేషణ మరియు వాస్తవ ప్రపంచ ఫలితాలపై సున్నితమైన వ్యత్యాసాలను కలిగించవచ్చు.
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) నుండి!
- **నల్ విలువలను గుర్తించడం**: `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` గణిత నల్ అయినప్పటికీ, అది పూర్తిగా సరైన ఇంటిజర్ మరియు pandas దాన్ని అలానే పరిగణిస్తుంది. `''` కొంచెం సున్నితమైనది. సెక్షన్ 1 లో ఖాళీ స్ట్రింగ్ విలువను సూచించడానికి దీన్ని ఉపయోగించాము, కానీ pandas దృష్టిలో ఇది స్ట్రింగ్ ఆబ్జెక్ట్ మాత్రమే, నల్ ప్రాతినిధ్యం కాదు.
ఇప్పుడు, దీన్ని తిరగబెట్టుకుని, మీరు ప్రాక్టీస్‌లో ఉపయోగించే విధంగా ఈ పద్ధతులను ఉపయోగిద్దాం. మీరు బూలియన్ మాస్క్‌లను నేరుగా ``Series`` లేదా ``DataFrame`` సూచికగా ఉపయోగించవచ్చు, ఇది ప్రత్యేకంగా లేకపోయిన (లేదా ఉన్న) విలువలతో పని చేయడానికి ఉపయోగకరం.
> **సారాంశం**: `isnull()` మరియు `notnull()` పద్ధతులు DataFrame లలో ఉపయోగించినప్పుడు సమాన ఫలితాలను ఇస్తాయి: అవి ఫలితాలు మరియు వాటి సూచికలను చూపిస్తాయి, ఇది మీ డేటాతో పని చేసే సమయంలో చాలా సహాయపడుతుంది.
- **నల్ విలువలను తొలగించడం**: లేకపోయిన విలువలను గుర్తించడం మించి, pandas `Series` మరియు `DataFrame` నుండి నల్ విలువలను తొలగించడానికి సౌకర్యవంతమైన మార్గాన్ని అందిస్తుంది. (పెద్ద డేటాసెట్‌లలో, లేకపోయిన [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`s ను అనుకూలించడానికి రెండు కాలమ్స్‌ను ఫ్లోట్స్‌గా అప్‌కాస్ట్ చేసినట్లు గమనించారా?)
DataFrame నుండి ఒకే విలువను తొలగించలేరు, కాబట్టి మీరు పూర్తి వరుసలు లేదా కాలమ్స్‌ను తొలగించాలి. మీరు ఏది చేయాలనుకుంటున్నారో ఆధారంగా, ఒకటి లేదా మరొకటి చేయవచ్చు, అందుకే pandas రెండు ఎంపికలను ఇస్తుంది. డేటా సైన్స్‌లో కాలమ్స్ సాధారణంగా వేరియబుల్స్‌ను సూచిస్తాయి మరియు వరుసలు పరిశీలనలను సూచిస్తాయి, కాబట్టి మీరు ఎక్కువగా డేటా వరుసలను తొలగిస్తారు; `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` ఉపయోగించి దీన్ని చేయవచ్చు, కానీ ఇది శ్రమగా ఉండవచ్చు, ముఖ్యంగా మీరు నింపాల్సిన విలువలు ఎక్కువగా ఉన్నప్పుడు. డేటా సైన్స్‌లో ఇది సాధారణ పని కావడంతో, 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
```
మీరు అన్ని నల్ ఎంట్రీలను ఒకే విలువతో నింపవచ్చు, ఉదాహరణకు `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
```
ఫార్వర్డ్-ఫిల్లింగ్ కోసం గత విలువ అందుబాటులో లేకపోతే, నల్ విలువ అలాగే ఉంటుంది అని గమనించండి.
> **Takeaway:** మీ డేటాసెట్‌లలో లేని విలువలతో వ్యవహరించడానికి అనేక మార్గాలు ఉన్నాయి. మీరు ఉపయోగించే నిర్దిష్ట వ్యూహం (వాటిని తొలగించడం, మార్చడం లేదా మీరు వాటిని ఎలా మార్చుతారో) ఆ డేటా యొక్క ప్రత్యేకతల ద్వారా నిర్ణయించబడాలి. మీరు డేటాసెట్‌లను ఎక్కువగా నిర్వహించగలిగే మరియు వాటితో పరస్పరం చేయగలిగే కొద్దీ లేని విలువలతో ఎలా వ్యవహరించాలో మీరు మెరుగైన అవగాహనను అభివృద్ధి చేస్తారు.
## డూప్లికేట్ డేటాను తొలగించడం
> **Learning goal:** ఈ ఉపవిభాగం చివరికి, మీరు డేటాఫ్రేమ్‌ల నుండి డూప్లికేట్ విలువలను గుర్తించి తొలగించడంలో సౌకర్యంగా ఉండాలి.
లేని డేటా తో పాటు, మీరు నిజమైన ప్రపంచ డేటాసెట్‌లలో తరచుగా డూప్లికేట్ డేటాను కూడా ఎదుర్కొంటారు. అదృష్టవశాత్తు, `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
```
> **Takeaway:** డూప్లికేట్ డేటాను తొలగించడం ప్రతి డేటా-సైన్స్ ప్రాజెక్ట్‌లో ఒక ముఖ్యమైన భాగం. డూప్లికేట్ డేటా మీ విశ్లేషణల ఫలితాలను మార్చవచ్చు మరియు మీకు తప్పు ఫలితాలను ఇస్తుంది!
## 🚀 సవాలు
చర్చించిన అన్ని విషయాలు [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