పైథాన్ పాండాస్ లైబ్రరీ అందించే 4 రకాల డేటాఫ్రేమ్‌లు చేరాయి

డేటా విశ్లేషకుడిగా, మీరు తరచుగా బహుళ డేటాసెట్‌లను కలపవలసిన అవసరాన్ని ఎదుర్కొంటారు. మీ విశ్లేషణను పూర్తి చేసి, మీ వ్యాపారం/స్టేక్‌హోల్డర్‌ల కోసం ఒక నిర్ణయానికి రావడానికి మీరు దీన్ని చేయాల్సి ఉంటుంది.

విభిన్న పట్టికలలో నిల్వ చేయబడినప్పుడు డేటాను సూచించడం తరచుగా సవాలుగా ఉంటుంది. అటువంటి పరిస్థితులలో, మీరు పని చేస్తున్న ప్రోగ్రామింగ్ భాషతో సంబంధం లేకుండా చేరినవారు తమ విలువను నిరూపించుకుంటారు.

రోజు యొక్క వీడియోను తయారు చేయండి

పైథాన్ జాయిన్‌లు SQL జాయిన్స్ లాగా ఉంటాయి: అవి సాధారణ సూచికలో వాటి వరుసలను సరిపోల్చడం ద్వారా డేటా సెట్‌లను మిళితం చేస్తాయి.

సూచన కోసం రెండు డేటాఫ్రేమ్‌లను సృష్టించండి

ఈ గైడ్‌లోని ఉదాహరణలను అనుసరించడానికి, మీరు రెండు నమూనా డేటాఫ్రేమ్‌లను సృష్టించవచ్చు. ID, మొదటి పేరు మరియు చివరి పేరును కలిగి ఉన్న మొదటి DataFrameని సృష్టించడానికి క్రింది కోడ్‌ని ఉపయోగించండి.

import pandas as pd 
  
a = pd.DataFrame({"ID": ["001", "002", "003", "004", "005"], 
    "Fname": ["Ron", "John", "Helen", "Jenny", "Kenny"], 
    "Lname": ["Keith", "Harley", "Smith", "Kerr-Hislop", "Barber"]}) 
print(a)

మొదటి దశ కోసం, దిగుమతి చేయండి పాండాలు గ్రంధాలయం. అప్పుడు మీరు వేరియబుల్ ఉపయోగించవచ్చు, a , డేటాఫ్రేమ్ కన్స్ట్రక్టర్ నుండి ఫలితాన్ని నిల్వ చేయడానికి. మీకు అవసరమైన విలువలను కలిగి ఉన్న నిఘంటువును కన్స్ట్రక్టర్‌కు పంపండి.

చివరగా, మీరు ఆశించిన విధంగా ప్రతిదీ కనిపిస్తుందని తనిఖీ చేయడానికి, ప్రింట్ ఫంక్షన్‌తో డేటాఫ్రేమ్ విలువలోని కంటెంట్‌లను ప్రదర్శించండి.

అదేవిధంగా, మీరు మరొక డేటాఫ్రేమ్‌ని సృష్టించవచ్చు, బి , ఇది ID మరియు జీతం విలువలను కలిగి ఉంటుంది.

b = pd.DataFrame({"ID": ["001", "002", "003", "004", "005"], 
    "Salary": [100000, 700000, 80000, 904750, 604772]}) 
  
print(b)

మీరు కన్సోల్ లేదా IDEలో అవుట్‌పుట్‌ని తనిఖీ చేయవచ్చు. ఇది మీ డేటాఫ్రేమ్‌ల కంటెంట్‌లను నిర్ధారించాలి:

పైథాన్‌లోని మెర్జ్ ఫంక్షన్ నుండి జాయిన్‌లు ఎలా విభిన్నంగా ఉంటాయి?

డేటాఫ్రేమ్‌లను మార్చేందుకు మీరు ఉపయోగించే ప్రధాన లైబ్రరీలలో పాండాస్ లైబ్రరీ ఒకటి. DataFrames బహుళ డేటా సెట్‌లను కలిగి ఉన్నందున, వాటిని చేరడానికి పైథాన్‌లో వివిధ విధులు అందుబాటులో ఉన్నాయి.

పైథాన్ మీరు డేటాఫ్రేమ్‌లను కలపడానికి ఉపయోగించే అనేక ఇతర వాటిలో చేరడం మరియు విలీనం చేయడం వంటి ఫంక్షన్‌లను అందిస్తుంది. ఈ రెండు ఫంక్షన్ల మధ్య పూర్తి వ్యత్యాసం ఉంది, వీటిని ఉపయోగించే ముందు మీరు గుర్తుంచుకోవాలి.

జాయిన్ ఫంక్షన్ వాటి ఇండెక్స్ విలువల ఆధారంగా రెండు డేటాఫ్రేమ్‌లను కలుపుతుంది. ది విలీనం ఫంక్షన్ డేటాఫ్రేమ్‌లను మిళితం చేస్తుంది సూచిక విలువలు మరియు నిలువు వరుసల ఆధారంగా.

పైథాన్‌లో చేరడం గురించి మీరు ఏమి తెలుసుకోవాలి?

అందుబాటులో ఉన్న చేరికల రకాలను చర్చించే ముందు, ఇక్కడ గమనించవలసిన కొన్ని ముఖ్యమైన విషయాలు ఉన్నాయి:

SQL జాయిన్‌లు అత్యంత ప్రాథమిక విధుల్లో ఒకటి మరియు పైథాన్ యొక్క చేరికలను పోలి ఉంటాయి.
DataFramesలో చేరడానికి, మీరు వీటిని ఉపయోగించవచ్చు pandas.DataFrame.join() పద్ధతి.
డిఫాల్ట్ జాయిన్ ఎడమ చేరడాన్ని నిర్వహిస్తుంది, అయితే విలీన ఫంక్షన్ అంతర్గత చేరికను నిర్వహిస్తుంది.

పైథాన్ చేరడానికి డిఫాల్ట్ సింటాక్స్ క్రింది విధంగా ఉంటుంది:

DataFrame.join(other, on=None, how='left/right/inner/outer', lsuffix='', rsuffix='', 
   sort=False)

మొదటి డేటాఫ్రేమ్‌లో చేరిక పద్ధతిని ప్రారంభించండి మరియు రెండవ డేటాఫ్రేమ్‌ను దాని మొదటి పారామీటర్‌గా పాస్ చేయండి, ఇతర . మిగిలిన వాదనలు:

పై , ఇది ఒకటి కంటే ఎక్కువ ఉంటే, చేరడానికి సూచికకు పేరు పెడుతుంది.
ఎలా , ఏది లోపలి, బాహ్య, ఎడమ మరియు కుడితో సహా చేరిక రకాన్ని నిర్వచిస్తుంది.
పదప్రత్యయం , ఏది మీ నిలువు వరుస పేరు యొక్క ఎడమ ప్రత్యయం స్ట్రింగ్‌ను నిర్వచిస్తుంది.
పదప్రత్యయం , ఏది మీ నిలువు వరుస పేరు యొక్క కుడి ప్రత్యయం స్ట్రింగ్‌ను నిర్వచిస్తుంది.
క్రమబద్ధీకరించు , ఏది ఫలితంగా వచ్చే డేటాఫ్రేమ్‌ను క్రమబద్ధీకరించాలా వద్దా అని సూచించే బూలియన్.

పైథాన్‌లో వివిధ రకాల చేరికలను ఉపయోగించడం నేర్చుకోండి

పైథాన్ కొన్ని చేరిక ఎంపికలను కలిగి ఉంది, మీరు గంట అవసరాన్ని బట్టి వ్యాయామం చేయవచ్చు. చేరిక రకాలు ఇక్కడ ఉన్నాయి:

ఒకరి గురించి ఎలా తెలుసుకోవాలి

1. ఎడమ చేరండి

ఎడమ చేరిక మొదటి డేటాఫ్రేమ్ విలువలను చెక్కుచెదరకుండా ఉంచుతుంది మరియు రెండవ దాని నుండి సరిపోలే విలువలను తీసుకువస్తుంది. ఉదాహరణకు, మీరు నుండి సరిపోలే విలువలను తీసుకురావాలనుకుంటే బి , మీరు దానిని ఈ క్రింది విధంగా నిర్వచించవచ్చు:

c = a.join(b, how="left", lsuffix = "_left", rsuffix = "_right", sort = True) 
print(c)

ప్రశ్నను అమలు చేసినప్పుడు, అవుట్‌పుట్ కింది నిలువు వరుస సూచనలను కలిగి ఉంటుంది:

ID_ఎడమ
పేరు
పేరు
ID_కుడి
జీతం

ఈ చేరిక మొదటి డేటాఫ్రేమ్ నుండి మొదటి మూడు నిలువు వరుసలను మరియు రెండవ డేటాఫ్రేమ్ నుండి చివరి రెండు నిలువు వరుసలను లాగుతుంది. ఇది ఉపయోగించింది పదప్రత్యయం మరియు పదప్రత్యయం రెండు డేటాసెట్ల నుండి ID నిలువు వరుసల పేరు మార్చడానికి విలువలు, ఫలితంగా ఫీల్డ్ పేర్లు ప్రత్యేకంగా ఉన్నాయని నిర్ధారిస్తుంది.

అవుట్పుట్ క్రింది విధంగా ఉంది:

పైథాన్‌లో ఎడమ చేరడాన్ని చూపుతున్న కోడ్'s dataframes

2. కుడి చేరండి

మొదటి పట్టిక నుండి సరిపోలే విలువలను తీసుకువస్తున్నప్పుడు కుడి చేరిక రెండవ డేటాఫ్రేమ్ విలువలను అలాగే ఉంచుతుంది. ఉదాహరణకు, మీరు నుండి సరిపోలే విలువలను తీసుకురావాలనుకుంటే a , మీరు దానిని ఈ క్రింది విధంగా నిర్వచించవచ్చు:

c = b.join(a, how="right", lsuffix = "_right", rsuffix = "_left", sort = True) 
print(c)

అవుట్పుట్ క్రింది విధంగా ఉంది:

పైథాన్‌లో కుడి చేరడాన్ని చూపుతున్న కోడ్'s dataframes

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

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

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

3. ఇన్నర్ జాయిన్

ఒక అంతర్గత చేరిక రెండు డేటాఫ్రేమ్‌ల నుండి సరిపోలే ఎంట్రీలను అందిస్తుంది. చేరడం వరుసలను సరిపోల్చడానికి సూచిక సంఖ్యలను ఉపయోగిస్తుంది కాబట్టి, లోపలి చేరడం సరిపోలే అడ్డు వరుసలను మాత్రమే అందిస్తుంది. ఈ ఉదాహరణ కోసం, కింది రెండు డేటాఫ్రేమ్‌లను ఉపయోగించుకుందాం:

a = pd.DataFrame({"ID": ["001", "002", "003", "004", "005", "006", "007"], 
    "Fname": ["Ron", "John", "Helen", "Jenny", "Kenny", "Daryl", "Cathy"], 
    "Lname": ["Keith", "Harley", "Smith", "Kerr-Hislop", "Barber", "Hooper", "Hope"]}) 
b = pd.DataFrame({"ID": ["001", "002", "003", "004", "005"], 
    "Salary": [100000, 700000, 80000, 904750, 604772]}) 
  
print(a) 
print(b)

అవుట్పుట్ క్రింది విధంగా ఉంది:

ఎక్సెల్‌లో వచనాన్ని ఎలా దాచాలి

పైథాన్‌లో కొత్త డేటాఫ్రేమ్‌లను సృష్టించండి

మీరు ఈ క్రింది విధంగా అంతర్గత చేరికను ఉపయోగించవచ్చు:

c = a.join(b, lsuffix="_left", rsuffix="_right", how='inner') 
print(c)

ఫలిత అవుట్‌పుట్ రెండు ఇన్‌పుట్ డేటాఫ్రేమ్‌లలో ఉన్న అడ్డు వరుసలను మాత్రమే కలిగి ఉంటుంది:

పైథాన్‌లో అంతర్గత చేరికను చూపుతున్న కోడ్'s dataframes

4. ఔటర్ జాయిన్

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

పైన పేర్కొన్న అదే డేటాఫ్రేమ్‌ని ఉపయోగించి, ఔటర్ జాయిన్ కోసం ఇక్కడ కోడ్ ఉంది:

c = a.join(b, lsuffix="_left", rsuffix="_right", how='outer') 
print(c)

పైథాన్‌లో ఔటర్ జాయిన్‌ని చూపుతున్న కోడ్'s dataframes

పైథాన్‌లో జాయిన్‌లను ఉపయోగించడం

జాయిన్స్, వాటి కౌంటర్‌పార్ట్ ఫంక్షన్‌లు, మెర్జ్ మరియు కన్‌కాట్ వంటివి సాధారణ చేరిక కార్యాచరణ కంటే ఎక్కువ మార్గాన్ని అందిస్తాయి. దాని ఎంపికలు మరియు ఫంక్షన్ల శ్రేణిని బట్టి, మీరు మీ అవసరాలకు అనుగుణంగా ఎంపికలను ఎంచుకోవచ్చు.

మీరు పైథాన్ అందించే ఫ్లెక్సిబుల్ ఆప్షన్‌లతో, జాయిన్ ఫంక్షన్‌తో లేదా లేకుండా ఫలిత డేటాసెట్‌లను సాపేక్షంగా సులభంగా క్రమబద్ధీకరించవచ్చు.