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

Working with Data: 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 లో సమాచారం గురించి మెటాడేటాను లేదా మొదటి మరియు చివరి కొన్ని విలువలను చూసి కూడా, మీరు పని చేస్తున్న డేటా యొక్క పరిమాణం, ఆకారం మరియు కంటెంట్ గురించి తక్షణ ఆలోచన పొందవచ్చు.

లేకపోయిన డేటాతో వ్యవహరించడం

అభ్యాస లక్ష్యం: ఈ ఉపవిభాగం చివరికి, మీరు DataFrames నుండి నల్ విలువలను ఎలా మార్చాలి లేదా తొలగించాలో తెలుసుకోవాలి.

మీరు ఉపయోగించాలనుకునే (లేదా ఉపయోగించాల్సి ఉన్న) డేటాసెట్‌లలో ఎక్కువసార్లు లేకపోయిన విలువలు ఉంటాయి. లేకపోయిన డేటాను ఎలా నిర్వహించాలో నిర్ణయించడం మీ తుది విశ్లేషణ మరియు వాస్తవ ప్రపంచ ఫలితాలపై సున్నితమైన వ్యత్యాసాలను కలిగించవచ్చు.

Pandas రెండు విధాలుగా లేకపోయిన విలువలను నిర్వహిస్తుంది. మీరు గత సెక్షన్లలో చూసిన మొదటి: NaN, లేదా Not a Number. ఇది వాస్తవానికి IEEE ఫ్లోటింగ్-పాయింట్ స్పెసిఫికేషన్‌లో భాగమైన ప్రత్యేక విలువ మరియు ఇది కేవలం లేకపోయిన ఫ్లోటింగ్-పాయింట్ విలువలను సూచించడానికి ఉపయోగించబడుతుంది.

ఫ్లోట్స్ తప్ప మరొక విలువలకు pandas Python None ఆబ్జెక్ట్‌ను ఉపయోగిస్తుంది. మీరు రెండు వేర్వేరు రకాల విలువలను ఎదుర్కొంటారని ఆశ్చర్యపోవచ్చు, కానీ ఈ డిజైన్ ఎంపికకు ప్రోగ్రామాటిక్ కారణాలు ఉన్నాయి మరియు ప్రాక్టికల్‌గా, ఈ మార్గం pandas కు చాలా సందర్భాల్లో మంచి సమతుల్యతను అందిస్తుంది. అయినప్పటికీ, None మరియు NaN రెండూ ఉపయోగించడంలో పరిమితులు కలిగి ఉంటాయి, వాటిని ఎలా ఉపయోగించాలో జాగ్రత్తగా ఉండాలి.

NaN మరియు None గురించి మరింత తెలుసుకోండి నోట్‌బుక్ నుండి!

• నల్ విలువలను గుర్తించడం: pandas లో, isnull() మరియు notnull() పద్ధతులు నల్ డేటాను గుర్తించడానికి ప్రధాన పద్ధతులు. ఇవి రెండూ మీ డేటాపై బూలియన్ మాస్క్‌లను ఇస్తాయి. 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 దృష్టిలో ఇది స్ట్రింగ్ ఆబ్జెక్ట్ మాత్రమే, నల్ ప్రాతినిధ్యం కాదు.

ఇప్పుడు, దీన్ని తిరగబెట్టుకుని, మీరు ప్రాక్టీస్‌లో ఉపయోగించే విధంగా ఈ పద్ధతులను ఉపయోగిద్దాం. మీరు బూలియన్ మాస్క్‌లను నేరుగా Series లేదా DataFrame సూచికగా ఉపయోగించవచ్చు, ఇది ప్రత్యేకంగా లేకపోయిన (లేదా ఉన్న) విలువలతో పని చేయడానికి ఉపయోగకరం.

సారాంశం: isnull() మరియు notnull() పద్ధతులు DataFrame లలో ఉపయోగించినప్పుడు సమాన ఫలితాలను ఇస్తాయి: అవి ఫలితాలు మరియు వాటి సూచికలను చూపిస్తాయి, ఇది మీ డేటాతో పని చేసే సమయంలో చాలా సహాయపడుతుంది.

• నల్ విలువలను తొలగించడం: లేకపోయిన విలువలను గుర్తించడం మించి, pandas Series మరియు DataFrame నుండి నల్ విలువలను తొలగించడానికి సౌకర్యవంతమైన మార్గాన్ని అందిస్తుంది. (పెద్ద డేటాసెట్‌లలో, లేకపోయిన [NA] విలువలను విశ్లేషణ నుండి తొలగించడం మరింత సలహాదాయకం.) దీన్ని ప్రదర్శించడానికి, example1 కు తిరిగి వెళ్దాం:

example1 = example1.dropna()
example1

0    0
2     
dtype: object

ఇది example3[example3.notnull()] నుండి మీ అవుట్పుట్‌లాగా కనిపించాలి. ఇక్కడ తేడా ఏమిటంటే, మాస్క్ చేసిన విలువలపై సూచిక వేయడం కాకుండా, dropna ఆ లేకపోయిన విలువలను Series example1 నుండి తొలగించింది.

DataFrame లకు రెండు డైమెన్షన్లు ఉండటంతో, డేటాను తొలగించడానికి మరిన్ని ఎంపికలు ఉంటాయి.

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

(పాండాస్ NaNs ను అనుకూలించడానికి రెండు కాలమ్స్‌ను ఫ్లోట్స్‌గా అప్‌కాస్ట్ చేసినట్లు గమనించారా?)

DataFrame నుండి ఒకే విలువను తొలగించలేరు, కాబట్టి మీరు పూర్తి వరుసలు లేదా కాలమ్స్‌ను తొలగించాలి. మీరు ఏది చేయాలనుకుంటున్నారో ఆధారంగా, ఒకటి లేదా మరొకటి చేయవచ్చు, అందుకే pandas రెండు ఎంపికలను ఇస్తుంది. డేటా సైన్స్‌లో కాలమ్స్ సాధారణంగా వేరియబుల్స్‌ను సూచిస్తాయి మరియు వరుసలు పరిశీలనలను సూచిస్తాయి, కాబట్టి మీరు ఎక్కువగా డేటా వరుసలను తొలగిస్తారు; dropna() యొక్క డిఫాల్ట్ సెట్టింగ్ ఏదైనా నల్ విలువ ఉన్న అన్ని వరుసలను తొలగించడం:

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

ఇది మీరు నిలుపుకోవాలనుకునే చాలా డేటాను తొలగించవచ్చు, ముఖ్యంగా చిన్న డేటాసెట్‌లలో. మీరు కొన్ని లేదా అన్ని నల్ విలువలు ఉన్న వరుసలు లేదా కాలమ్స్ మాత్రమే తొలగించాలనుకుంటే? మీరు dropna లో how మరియు thresh పారామీటర్లతో ఆ సెట్టింగులను నిర్దేశించవచ్చు.

డిఫాల్ట్‌గా, how='any' (మీరు స్వయంగా తనిఖీ చేయాలనుకుంటే లేదా పద్ధతికి మరెన్ని పారామీటర్లు ఉన్నాయో చూడాలనుకుంటే, కోడ్ సెల్‌లో example4.dropna? నడపండి). మీరు ప్రత్యామ్నాయంగా how='all' ను నిర్దేశించవచ్చు, ఇది కేవలం అన్ని నల్ విలువలు ఉన్న వరుసలు లేదా కాలమ్స్ మాత్రమే తొలగిస్తుంది. దీన్ని ప్రదర్శించడానికి మన ఉదాహరణ 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

ఇక్కడ, మొదటి మరియు చివరి వరుసలు తొలగించబడ్డాయి, ఎందుకంటే అవి కేవలం రెండు నాన్-నల్ విలువలు మాత్రమే కలిగి ఉన్నాయి.

• నల్ విలువలను నింపడం: మీ డేటాసెట్ ఆధారంగా, నల్ విలువలను తొలగించడంలోకి కాకుండా సరైన విలువలతో నింపడం మరింత అర్థవంతంగా ఉండవచ్చు. మీరు 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

మీరు అన్ని నల్ ఎంట్రీలను ఒకే విలువతో నింపవచ్చు, ఉదాహరణకు 0:

example3.fillna(0)

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

మీరు ఫార్వర్డ్-ఫిల్ చేయవచ్చు, అంటే చివరి సరైన విలువను ఉపయోగించి నల్ విలువను నింపడం:

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

మీరు ఊహించగలిగినట్లుగా, ఇది DataFrame లతో కూడా అదే విధంగా పనిచేస్తుంది, కానీ మీరు నల్ విలువలను నింపడానికి ఒక axis ను కూడా నిర్దేశించవచ్చు. మునుపటి 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

ఫార్వర్డ్-ఫిల్లింగ్ కోసం గత విలువ అందుబాటులో లేకపోతే, నల్ విలువ అలాగే ఉంటుంది అని గమనించండి.

Takeaway: మీ డేటాసెట్‌లలో లేని విలువలతో వ్యవహరించడానికి అనేక మార్గాలు ఉన్నాయి. మీరు ఉపయోగించే నిర్దిష్ట వ్యూహం (వాటిని తొలగించడం, మార్చడం లేదా మీరు వాటిని ఎలా మార్చుతారో) ఆ డేటా యొక్క ప్రత్యేకతల ద్వారా నిర్ణయించబడాలి. మీరు డేటాసెట్‌లను ఎక్కువగా నిర్వహించగలిగే మరియు వాటితో పరస్పరం చేయగలిగే కొద్దీ లేని విలువలతో ఎలా వ్యవహరించాలో మీరు మెరుగైన అవగాహనను అభివృద్ధి చేస్తారు.

డూప్లికేట్ డేటాను తొలగించడం

Learning goal: ఈ ఉపవిభాగం చివరికి, మీరు డేటాఫ్రేమ్‌ల నుండి డూప్లికేట్ విలువలను గుర్తించి తొలగించడంలో సౌకర్యంగా ఉండాలి.

లేని డేటా తో పాటు, మీరు నిజమైన ప్రపంచ డేటాసెట్‌లలో తరచుగా డూప్లికేట్ డేటాను కూడా ఎదుర్కొంటారు. అదృష్టవశాత్తు, 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

Takeaway: డూప్లికేట్ డేటాను తొలగించడం ప్రతి డేటా-సైన్స్ ప్రాజెక్ట్‌లో ఒక ముఖ్యమైన భాగం. డూప్లికేట్ డేటా మీ విశ్లేషణల ఫలితాలను మార్చవచ్చు మరియు మీకు తప్పు ఫలితాలను ఇస్తుంది!

🚀 సవాలు

చర్చించిన అన్ని విషయాలు Jupyter Notebookగా అందుబాటులో ఉన్నాయి. అదనంగా, ప్రతి విభాగం తర్వాత వ్యాయామాలు ఉన్నాయి, వాటిని ప్రయత్నించండి!

పోస్ట్-లెక్చర్ క్విజ్

సమీక్ష & స్వీయ అధ్యయనం

మీ డేటాను విశ్లేషణ మరియు మోడలింగ్ కోసం సిద్ధం చేయడాన్ని కనుగొనడానికి మరియు దానికి చేరుకోవడానికి అనేక మార్గాలు ఉన్నాయి మరియు డేటాను శుభ్రపరచడం ఒక ముఖ్యమైన దశ, ఇది "ప్రాక్టికల్" అనుభవం. ఈ పాఠం కవర్ చేయని సాంకేతికతలను అన్వేషించడానికి Kaggle నుండి ఈ సవాళ్లను ప్రయత్నించండి.

• డేటా శుభ్రపరిచే సవాలు: తేదీలను పార్స్ చేయడం

• డేటా శుభ్రపరిచే సవాలు: డేటాను స్కేల్ చేయడం మరియు సాధారణీకరించడం

అసైన్‌మెంట్

ఫారమ్ నుండి డేటాను మూల్యాంకనం

---

అస్పష్టత:
ఈ పత్రాన్ని AI అనువాద సేవ Co-op Translator ఉపయోగించి అనువదించబడింది. మేము ఖచ్చితత్వానికి ప్రయత్నించినప్పటికీ, ఆటోమేటెడ్ అనువాదాల్లో పొరపాట్లు లేదా తప్పిదాలు ఉండవచ్చు. మూల పత్రం దాని స్వదేశీ భాషలో అధికారిక మూలంగా పరిగణించాలి. ముఖ్యమైన సమాచారానికి, ప్రొఫెషనల్ మానవ అనువాదం సిఫార్సు చేయబడుతుంది. ఈ అనువాదం వాడకంలో ఏర్పడిన ఏవైనా అపార్థాలు లేదా తప్పుదారితీసే అర్థాలు కోసం మేము బాధ్యత వహించము.