పాండాలు వర్గీయ విలువలను పూర్ణాంక విలువలుగా మారుస్తాయి

వర్గీకరణను Intకి మార్చడానికి పద్ధతులు

డేటాఫ్రేమ్ యొక్క వర్గీకరణను పూర్ణాంక విలువలుగా మార్చడానికి “పాండాలు”లో అందుబాటులో ఉన్న సాంకేతికతలు ఇక్కడ అందించబడ్డాయి:

• • DataFrame.replace() పద్ధతి
  • DataFrame.apply(factorize()) పద్ధతి

మేము ఈ ఆర్టికల్లో ఈ పద్ధతులను ఉపయోగించుకుంటాము మరియు 'పాండాలు'లో రెండు పద్ధతులను ఎలా ఉపయోగించాలో వివరంగా వివరిస్తాము.

ఉదాహరణ # 1: పాండాస్ రీప్లేస్() పద్ధతిని ఉపయోగించడం

పాండాస్ “DataFrame.replace()” పద్ధతిని ఉపయోగించడం ద్వారా డేటాఫ్రేమ్‌లోని వర్గీకరణ విలువలను పూర్ణాంకానికి మార్చవచ్చు. ఈ పద్ధతిని ఉపయోగించడం గురించి మనం ఇక్కడ నేర్చుకుంటాము.

పైథాన్‌లో ఈ టెక్నిక్‌ని ఉత్తమంగా అమలు చేయడానికి మేము 'స్పైడర్' సాధనాన్ని ఉపయోగించాము. స్క్రిప్ట్ రాయడం ప్రారంభించడానికి, “స్పైడర్” సాధనంలో కొత్త పైథాన్ ఫైల్‌ను తెరవండి. స్క్రిప్ట్ రాయడానికి అత్యంత ముఖ్యమైన అవసరం తగిన లైబ్రరీలను దిగుమతి చేసుకోవడం. మేము 'పాండాలు' పద్ధతిని అమలు చేయవలసి ఉన్నందున, 'పాండాలు' యొక్క లక్షణాలను యాక్సెస్ చేయడానికి మనకు 'పాండాలను pdగా దిగుమతి చేయండి' ఉంటుంది. అప్పుడు మేము మా కోర్ పైథాన్ కోడ్‌ను ప్రారంభిస్తాము. మేము “pd.DataFrame()” పద్ధతిని ఉపయోగించి డేటాఫ్రేమ్‌ని సృష్టించాము. డేటాఫ్రేమ్ 'పేరు', 'డిగ్రీ' మరియు 'ఆదాయం' అనే మూడు నిలువు వరుసల ద్వారా ప్రారంభించబడింది. అన్ని డేటాఫ్రేమ్ నిలువు వరుసలు ఒకే విలువల పొడవును నిల్వ చేస్తాయి.

మొదటి నిలువు వరుస, 'పేరు', 'బుష్', 'ఆల్బర్ట్', 'హ్యారీ', 'పీటర్', 'ఎమ్మా', 'న్యూటన్', 'స్మిత్' మరియు 'ఎల్సా' అనే ఎనిమిది విలువలను కలిగి ఉంది. రెండవ కాలమ్, 'డిగ్రీ', 'BS', 'MS', 'MS', 'BS', 'BS', 'BS', 'MS' మరియు 'MS' అనే ఎనిమిది వర్గీకరణ విలువలను కూడా నిల్వ చేస్తుంది. చివరి కాలమ్ 'ఆదాయం' ఎనిమిది పూర్ణాంకాల విలువలను '60000', '80000', '75000', '45000', '56000', '65000', '55000' మరియు '70000' కలిగి ఉంది. మేము 'pd.DataFrame()' ఫంక్షన్‌ని ఇన్వోకింగ్ అవుట్‌పుట్‌ని నిల్వ చేయడానికి డేటాఫ్రేమ్ ఆబ్జెక్ట్ “స్టాఫ్”ని సృష్టించాము. మా ప్రారంభ డేటాఫ్రేమ్‌ని ప్రదర్శించడానికి, మేము స్క్రిప్ట్ చివరి పంక్తిలో డేటాఫ్రేమ్ పేరు “స్టాఫ్” అనే పరామితితో “ప్రింట్()” పద్ధతిని ఉపయోగించాము.

టెర్మినల్‌లో అవుట్‌పుట్‌ను వీక్షించడానికి, 'స్పైడర్' సాధనంలో 'రన్ ఫైల్' బటన్‌ను ఉపయోగించండి లేదా 'Shift+Enter' కీలను నొక్కండి. టెర్మినల్‌పై ప్రదర్శించబడే అవుట్‌పుట్ విజయవంతంగా రూపొందించబడిన మూడు నిలువు వరుసలతో కూడిన డేటాఫ్రేమ్‌ను చూపుతుంది.

ఇప్పుడు, మా డేటాఫ్రేమ్ నిర్మించబడింది, మేము దానికి అవసరమైన సాంకేతికతను వర్తింపజేయాలి. పాండాలు “DataFrame.replace()” పద్ధతిని పేర్కొన్న నిలువు వరుస యొక్క వర్గీకరణ విలువలను పూర్ణాంక విలువలుగా మార్చడానికి ఉపయోగించబడుతుంది, తద్వారా యంత్రాలు వాటిని చదవగలిగేలా చేయగలవు.

మేము డేటాఫ్రేమ్ పేరును నిర్దిష్ట కాలమ్ పేరుతో అందించాము, దీని విలువలను మనం భర్తీ చేయాలి, అది “సిబ్బంది[‘డిగ్రీ’]”. వర్గీకరణ విలువలను కలిగి ఉన్న 'డిగ్రీ' నిలువు వరుస విలువలను పూర్ణాంక విలువలతో భర్తీ చేయాలని మేము కోరుకుంటున్నాము. అప్పుడు “.replace()” పద్ధతి ప్రారంభించబడుతుంది. మేము దానిని రెండు సెట్లుగా ఆమోదించాము; మొదటిది మేము 'డిగ్రీ' కాలమ్ నుండి సంగ్రహించిన '['BS', 'MS']' అనే రెండు వర్గీకరణ విలువలను కలిగి ఉంది. మీరు చూడగలిగినట్లుగా, 'డిగ్రీ' కాలమ్ ఈ రెండు విలువలను పదేపదే ఉపయోగిస్తుంది. మనకు మూడవ విలువ ఉంటే, మనం దానిని కూడా ప్రస్తావించాలి. రెండవ సెట్‌లో రెండు పూర్ణాంక విలువలు “[0, 1]” ఉన్నాయి, ఇవి వరుసగా మొదటి సెట్ విలువల స్థానంలో ఉంటాయి. ఇతర పరామితి, 'ఇన్‌ప్లేస్', 'ట్రూ'గా సెట్ చేయబడింది, ఇది విలువల భర్తీని అనుమతిస్తుంది. 'తప్పు'కి సెట్ చేస్తే, అది భర్తీని నిలిపివేస్తుంది. చివరగా, నవీకరించబడిన “స్టాఫ్” డేటాఫ్రేమ్‌ను ప్రదర్శించడానికి మేము “ప్రింట్()” పద్ధతిని ఉపయోగించాము.

ఫలిత డేటాఫ్రేమ్ 'డిగ్రీ' నిలువు వరుసలో పూర్ణాంక విలువలను కలిగి ఉంటుంది. 'BS' విలువ '0s'తో భర్తీ చేయబడింది మరియు 'MS' '1s'తో భర్తీ చేయబడింది.

మీరు “dataframe.dtype” ప్రాపర్టీని ఉపయోగించడం ద్వారా ప్రతి నిలువు వరుస కోసం డేటాటైప్‌ను కూడా ధృవీకరించవచ్చు. ఇది పేర్కొన్న డేటాఫ్రేమ్‌లోని అన్ని నిలువు వరుసల డేటాటైప్‌లను పొందుతుంది.

ఇక్కడ, మేము మా డేటాఫ్రేమ్ యొక్క డేటాటైప్‌లను పొందాము. “డిగ్రీ” కాలమ్ యొక్క డేటాటైప్ “int64”కి మార్చబడిందని మనం చూడవచ్చు.

ఉదాహరణ # 2: పాండాలు దరఖాస్తు() పద్ధతిని ఉపయోగించడం

పాండాలు మాకు అందించిన ఇతర పద్ధతి 'DataFrame.apply()' అనేది వర్గీకరణ విలువలను పూర్ణాంకాలుగా మార్చడం. మునుపటి ఉదాహరణలో, మేము ఒక వర్గీకరణ నిలువు వరుసను పూర్ణాంకంలోకి మార్చడం నేర్చుకున్నాము. డేటాఫ్రేమ్‌లోని అన్ని వర్గీకర నిలువు వరుసలను పూర్ణాంకానికి ఎలా మార్చాలో ఇప్పుడు చూద్దాం.

ఆచరణాత్మక అమలుతో ప్రారంభించి, ఈ పద్ధతికి అవసరమైన లైబ్రరీని తప్పనిసరిగా దిగుమతి చేసుకోవాలి, ఇది పాండాలు. 'స్పైడర్' టూల్‌లో మా పైథాన్ ఫైల్‌లోకి పాండాలను దిగుమతి చేయడానికి 'పిడిగా పాండాలను దిగుమతి చేయి' అనే స్క్రిప్ట్‌ని ఉపయోగించాము, ఇది 'పిడి'ని ఉపయోగించి పాండాస్ మాడ్యూల్‌లను యాక్సెస్ చేయడానికి అనుమతిస్తుంది. మేము DataFrameని నిర్మించడానికి “pd.DataFrame()” ఫంక్షన్‌ని ఉపయోగించాము.

ఈ డేటాఫ్రేమ్‌లో నాలుగు నిలువు వరుసలు “సమూహం”, “స్థానం”, “స్కోర్లు” మరియు “సహాయకాలు” ఉన్నాయి. ప్రతి నిలువు వరుస 9 విలువలను నిల్వ చేస్తుంది. “సమూహం” కాలమ్ విలువలు “X”, “X”, “Y”, “X”, “Y”, “Y”, “Y”, “X”, మరియు “Y”. 'స్థానం' నిలువు వరుసలో 9 విలువలు ఉన్నాయి, అవి 'A', 'C', 'D', 'A', 'C', 'B', 'B', 'D' మరియు 'B'. “స్కోర్‌లు” కాలమ్‌లో “4”, “8”, “7”, “10”, “9”, “5”, “7”, “3” మరియు “23” వంటి పూర్ణాంక విలువలు ఉన్నాయి. చివరి నిలువు వరుస, 'సహాయకాలు', '10', '2', '3', '9', '3', '7', '4', '2' మరియు '9' విలువలను కలిగి ఉంది.

మేము DataFrame ఆబ్జెక్ట్ “ప్రోగ్”ని సృష్టించాము మరియు దానికి “pd.DataFrame()” పద్ధతిని అమలు చేసే అవుట్‌పుట్‌ను కేటాయించాము. కాబట్టి, “pd.DataFrame()” నుండి రూపొందించబడిన ఫలిత డేటా ఫ్రేమ్ ఫ్రేమ్ “ప్రోగ్”లో నిల్వ చేయబడుతుంది. ఇప్పుడు, ఈ వస్తువును ఉపయోగించడం ద్వారా మనం డేటాఫ్రేమ్‌ని యాక్సెస్ చేయవచ్చు. ఈ డేటాఫ్రేమ్‌ను వీక్షించడానికి, మేము డేటాఫ్రేమ్ ఆబ్జెక్ట్ “ప్రోగ్”తో “ప్రింట్()” పద్ధతిని దాని పరామితిగా ఉపయోగించాము.

మునుపటి పైథాన్ ప్రోగ్రామ్ అమలు చేయబడినప్పుడు, టెర్మినల్‌లో నాలుగు నిలువు వరుసలతో కూడిన డేటాఫ్రేమ్ ప్రదర్శించబడుతుంది.

బహుళ వర్గీయ నిలువు వరుసలను పూర్ణాంకాలుగా మార్చడానికి, మేము ఈ పద్ధతిని అనుసరించాము. మేము మొదట పాండాస్ “DataFrame.select_dtypes().columns” పద్ధతిని ఉపయోగించడం ద్వారా ఆబ్జెక్ట్ డేటాటైప్‌ను కలిగి ఉన్న అన్ని నిలువు వరుసలను ఎంచుకోవాలి. మేము దానిని మన స్క్రిప్ట్‌లో అవసరమైన విధంగా ఉపయోగించినప్పుడు, అది 'prog.select_dtypes(['object']).columns' అవుతుంది. ఇది 'ప్రోగ్' డేటాఫ్రేమ్‌లో డేటాటైప్ 'ఆబ్జెక్ట్' ఉన్న అన్ని నిలువు వరుసలను ఎంచుకుంటుంది. ఈ పద్ధతి యొక్క అవుట్‌పుట్‌ను నిల్వ చేయడానికి మేము వేరియబుల్ “concate_col”ని సృష్టించాము. ఈ వేరియబుల్ “concat_col”ని ఉపయోగించడం ద్వారా మనం ఇప్పుడు “ఆబ్జెక్ట్” డేటాటైప్ నిలువు వరుసలను యాక్సెస్ చేయవచ్చు.

ఇప్పుడు, ఈ నిలువు వరుసలను పూర్ణాంకాలకి మార్చడానికి, మేము “pd.factorize()” పద్ధతితో “DataFrame.apply()” అనే పాండాలను ఉపయోగించాము. మేము డేటాఫ్రేమ్ పేరుతో “concat_col” వేరియబుల్‌ని ఉపయోగించాము, ఆపై “.apply()” పద్ధతి అమలు చేయబడుతుంది. “.apply” పద్ధతి యొక్క కుండలీకరణాల మధ్య, మేము “pd.factorize()” పద్ధతిని పిలిచాము, ఇక్కడ “ఆబ్జెక్ట్” డేటాటైప్‌తో “ప్రోగ్” డేటాఫ్రేమ్ నుండి “x” ఏదైనా విలువ కావచ్చు. ఈ విధంగా, ఈ మొత్తం కోడ్ లైన్ “prog['concat_col'] = ప్రోగ్['concat_col'] అని వ్రాయబడింది.apply(lambda x : pd.factorize(x)[0])'. కారకం పద్ధతి దీనితో విలువను తీసుకుంటుంది ఒక 'ఆబ్జెక్ట్' డేటాటైప్ మరియు దానిని 'int' గా మార్చండి. “ప్రోగ్” వేరియబుల్‌ను దాని పారామీటర్‌గా పాస్ చేయడం ద్వారా “ప్రింట్()” ఫంక్షన్‌ని కాల్ చేయడం ద్వారా తుది అవుట్‌పుట్ ప్రదర్శించబడుతుంది.

నవీకరించబడిన డేటాఫ్రేమ్‌లో, “సమూహం” మరియు “స్థానం” నిలువు వరుసల విలువలు మొదట్లో వర్గీకరించబడ్డాయి, అంటే వస్తువుగా ఉన్నాయని మనం గమనించవచ్చు. ఇప్పటికీ నవీకరించబడిన అవుట్‌పుట్ డేటాఫ్రేమ్‌లో, రెండు నిలువు వరుసలు పూర్ణాంక విలువలను కలిగి ఉంటాయి. “సమూహం” కాలమ్‌లో, “X” స్థానంలో “0” మరియు “Y”ని “1” ద్వారా భర్తీ చేస్తారు. “స్థానం” నిలువు వరుస “A”ని “0”, “C”ని “1”, “D”ని “2” మరియు “B”ని “3”తో భర్తీ చేస్తారు.

ఇప్పుడు, అప్‌డేట్ చేయబడిన డేటాటైప్‌లను వెరిఫై చేద్దాం.

కింది నిలువు వరుసలన్నీ “int64” డేటాటైప్‌ను కలిగి ఉన్నాయి.

ముగింపు

మా గైడ్ వర్గీకర విలువలను సంఖ్యా విలువలుగా మార్చడం చుట్టూ తిరుగుతుంది, తద్వారా ఆబ్జెక్ట్ డేటాటైప్ వాటిని ప్రాసెస్ చేయలేనందున వాటిని యంత్రాల ద్వారా అర్థమయ్యేలా చేయవచ్చు. అవసరమైన డేటాటైప్‌ను పొందడానికి 'పాండాలు' లైబ్రరీ ద్వారా ఫీచర్ చేయబడిన రెండు విధానాలను మేము మీకు పరిచయం చేసాము. అలాగే, 'స్పైడర్' సాధనంపై అమలు చేయబడిన ఉదాహరణ కోడ్‌ల ఆచరణాత్మక అమలుతో, మేము ప్రతి ఉదాహరణ యొక్క ఫలితాన్ని పంచుకున్నాము. చివరగా, మేము ఆశించిన ఫలితాన్ని సాధించడానికి ప్రతి దశను వివరించాము.