ఖండన
ఈ ట్యుటోరియల్ ప్రారంభించడానికి ముందు, ఖండన భావన వివరించబడుతుంది. క్రింద, రెండు ఉదాహరణగా ఇవ్వబడ్డాయి:
జాబితా 1= [4, 7, 2. 3, 9, 6, పదకొండు]
జాబితా 2= [6, 5, 1, ఇరవై, 9, 7, 4, 3]
ఖండనను వర్తింపజేసిన తరువాత, ఫలితం మరొక జాబితాలో నిల్వ చేయబడితే, బహుశా జాబితా 3 అని పిలువబడితే, అది క్రింది డేటాను కలిగి ఉంటుంది.
జాబితా 3= [4, 6, 7, 9]
జాబితా 3 యొక్క గ్రాఫికల్ ప్రాతినిధ్యం క్రింద చూపబడింది:
ఉదాహరణ 1: సెట్ () పద్ధతి ద్వారా జాబితాలను ఖండించండి
కింది ఉదాహరణ మీరు ఉపయోగించి రెండు జాబితాలను ఎలా ఖండించవచ్చో చూపుతుంది సెట్ () పద్ధతి మరియు & ఆపరేటర్. జాబితా 1 మరియు జాబితా 2 అనే రెండు జాబితాలు ఇక్కడ ప్రకటించబడ్డాయి. ఈ రెండు జాబితాలలో సంఖ్యా విలువలు ఉన్నాయి. మూడవ జాబితా జాబితా 1 మరియు జాబితా 2 ని సెట్ ద్వారా సెట్‌లోకి మార్చడం ద్వారా రూపొందించబడింది () పద్ధతి మరియు విభజనను ఉపయోగించి దరఖాస్తు చేయడం & ఆపరేటర్. తరువాత, మూడు జాబితాల విలువలు ముద్రించబడతాయి.
#!/usr/bin/env పైథాన్ 3# జాబితా 1 ని నిర్వచించండి
జాబితా 1= [22, 8, నాలుగు ఐదు, పదకొండు, 3. 4, 9, ఇరవై, 7]
# జాబితా 2 నిర్వచించండి
జాబితా 2= [12, 9, ఇరవై, 78, 53, 8, 2, 30,31]
# జాబితా 1 మరియు జాబితా 2 ను ఖండించడం ద్వారా జాబితా 3 ని సృష్టించండి
జాబితా 3= జాబితా(సెట్(జాబితా 1)&సెట్(జాబితా 2))
# ప్రింట్ జాబితా 1
ముద్రణ(జాబితా 1 యొక్క విలువలు: n',జాబితా 1)
# ప్రింట్ జాబితా 2
ముద్రణ(జాబితా 2 యొక్క విలువలు: n',జాబితా 2)
# ప్రింట్ జాబితా 3
ముద్రణ(జాబితా 1 మరియు జాబితా 2 ను కలిసిన తర్వాత జాబితా 3 యొక్క విలువలు: n',జాబితా 3)
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. రెండు జాబితాలకు మూడు విలువలు సాధారణం. ఈ విలువలు 8, 9 మరియు 20, మరియు మూడవ జాబితాలోని కంటెంట్‌లో చూపబడతాయి.
ఉదాహరణ 2: ఖండన () పద్ధతి ద్వారా ఖండన జాబితాలు
రెండు జాబితాల మధ్య ఖండన విలువలను తెలుసుకోవడానికి జాబితా వస్తువు కోసం ప్రత్యక్ష, అంతర్నిర్మిత పద్ధతి లేదు. అయితే, సెట్‌లో అంతర్నిర్మిత పద్ధతి ఉంది, పేరు పెట్టబడింది ఖండన () , సెట్ల మధ్య సాధారణ విలువలను తెలుసుకోవడానికి. ఒక అనుకూల ఫంక్షన్, పేరు పెట్టబడింది ఖండన జాబితాలు () , రెండు జాబితాల మధ్య సాధారణ విలువలను తెలుసుకోవడానికి క్రింది స్క్రిప్ట్‌లో నిర్వచించబడింది. ఈ సెట్ యొక్క ఒక పరిమితి ఏమిటంటే ఇది సంఖ్యాపరమైన డేటాను మాత్రమే కలిగి ఉంటుంది. లిస్ట్ వేరియబుల్ స్క్రిప్ట్‌లో సంఖ్యా, బూలియన్ మొదలైన వాటితో సహా వివిధ రకాల డేటా స్ట్రింగ్‌ను కలిగి ఉంటుంది, జాబితా 1 మరియు జాబితా 2 టెక్స్ట్‌తో సహా అన్ని స్ట్రింగ్ డేటాను కలిగి ఉంటుంది. స్క్రిప్ట్ అన్ని సాధారణ స్ట్రింగ్ మరియు సంఖ్యా విలువలను మధ్య ప్రింట్ చేస్తుంది జాబితా 1 మరియు జాబితా 2 .
#!/usr/bin/env పైథాన్ 3# రెండు జాబితాల ఖండనను తిరిగి ఇవ్వడానికి ఫంక్షన్‌ను నిర్వచించండి
డెఫ్ఖండన జాబితాలు(జాబితా 1,జాబితా 2):
తిరిగి సెట్(జాబితా 1).ఖండన(జాబితా 2)
# జాబితా 1 ని నిర్వచించండి
జాబితా 1= ['హలో','7','8','10','2']
# జాబితా 2 నిర్వచించండి
జాబితా 2= ['8','3. 4','హలో','2','ఇరవై ఒకటి','1',10]
'' 'నిల్వ చేయడానికి అనుకూల ఫంక్షన్‌కు కాల్ చేయండి
జాబితా 1 మరియు జాబితా 2 యొక్క ఖండన ఫలితం
జాబితా 3 '' 'లోకి
జాబితా 3=ఖండన జాబితాలు(జాబితా 1,జాబితా 2)
# ప్రింట్ జాబితా 1
ముద్రణ(జాబితా 1 యొక్క విలువలు: n',జాబితా 1)
# ప్రింట్ జాబితా 2
ముద్రణ(జాబితా 2 యొక్క విలువలు: n',జాబితా 2)
# ప్రింట్ జాబితా 3
ముద్రణ(జాబితా 1 మరియు జాబితా 2 ను కలిసిన తర్వాత జాబితా 3 యొక్క విలువలు: n',జాబితా 3)
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ, రెండు జాబితాల మధ్య సాధారణ విలువలు '2', '8' మరియు 'హలో'.
ఉదాహరణ 3: లూప్ పద్ధతి ద్వారా ఖండన జాబితాలు
మునుపటి రెండు ఉదాహరణలు అంతర్నిర్మిత ఫంక్షన్లను ఉపయోగించి జాబితా ఖండనను చూపుతాయి. కింది ఉదాహరణ ఏ అంతర్నిర్మిత ఫంక్షన్ లేకుండా జాబితా ఖండనను చూపుతుంది. లూప్ ఉపయోగించి దీనిని సాధించవచ్చు. టెక్స్ట్ డేటా యొక్క రెండు జాబితాలు స్క్రిప్ట్‌లో ప్రకటించబడ్డాయి. ది కోసం మధ్య సాధారణ టెక్స్ట్ విలువలను తెలుసుకోవడానికి లూప్ ఇక్కడ ఉపయోగించబడుతుంది జాబితా 1 మరియు జాబితా 2, మరియు అవి వేరియబుల్‌లో నిల్వ చేయబడతాయి, జాబితా 3 . తరువాత, ఈ మూడు జాబితా వేరియబుల్స్ విలువలు ముద్రించబడతాయి.
#!/usr/bin/env పైథాన్ 3# జాబితా 1 ని నిర్వచించండి
జాబితా 1= ['ఫర్హాన్','అబిర్','ఆకాష్','మీనా','మజెర్']
# జాబితా 2 నిర్వచించండి
జాబితా 2= ['మీనా','మోయ్నా','నోబెల్','దగ్గరగా','అబిర్','ఫర్హీన్']
# లూప్ కోసం ఉపయోగించి ఖండనను కనుగొని ఫలితాన్ని జాబితా 3 లో నిల్వ చేయండి
జాబితా 3= [విలువకోసంవిలువలోజాబితా 1ఉంటేవిలువలోజాబితా 2]
# ప్రింట్ జాబితా 1
ముద్రణ(జాబితా 1 యొక్క విలువలు: n',జాబితా 1)
# ప్రింట్ జాబితా 2
ముద్రణ(జాబితా 2 యొక్క విలువలు: n',జాబితా 2)
# ప్రింట్ జాబితా 3
ముద్రణ(జాబితా 1 మరియు జాబితా 2 ను కలిసిన తర్వాత జాబితా 3 యొక్క విలువలు: n',జాబితా 3)
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. ఇక్కడ, రెండు జాబితాల యొక్క సాధారణ టెక్స్ట్ విలువలు 'అబిర్' మరియు 'మీనా.'
ఉదాహరణ 4: వడపోత () పద్ధతి ద్వారా సరళమైన మరియు నెస్టెడ్ జాబితాలను విడదీయడం
కింది ఉదాహరణ సాధారణ జాబితా మరియు సమూహ జాబితా మధ్య ఖండనను చూపుతుంది. ది ఫిల్టర్ () పద్ధతి మరియు లాంబ్డా జాబితా 1 మరియు జాబితా 2 మధ్య ఖండనను నిర్వహించడానికి స్క్రిప్ట్‌లో ఫంక్షన్ ఉపయోగించబడుతుంది. జాబితా ఒకటి లేదా అంతకంటే ఎక్కువ జాబితాలను జాబితా అంశాలుగా కలిగి ఉన్నప్పుడు, ఆ జాబితాను సమూహ జాబితా అంటారు. ఇక్కడ, జాబితా 1 ఒక సాధారణ జాబితా, మరియు జాబితా 2 ఒక గూడు జాబితా, అయితే జాబితా 3 యొక్క ఖండన విలువలను కలిగి ఉంటుంది జాబితా 1 మరియు జాబితా 2 .
#!/usr/bin/env పైథాన్ 3# సాధారణ జాబితాను నిర్వచించండి
జాబితా 1= [22, 8, నాలుగు ఐదు, పదకొండు, 3. 4, 9, ఇరవై, 7]
# సమూహ జాబితాను నిర్వచించండి
జాబితా 2= [[12, 9, ఇరవై], [78, పదకొండు, 53, 8], [2, 30, 31, నాలుగు ఐదు]]
# వడపోత () ఉపయోగించి జాబితా 1 మరియు జాబితా 2 ను విభజించడం ద్వారా జాబితా 3 ని సృష్టించండి
జాబితా 3= [జాబితా(వడపోత(లాంబ్డాn: ఎన్లోజాబితా 1,స్లిస్ట్)) కోసంస్లిస్ట్లోజాబితా 2]
# ప్రింట్ జాబితా 1
ముద్రణ(జాబితా 1 యొక్క విలువలు: n',జాబితా 1)
# ప్రింట్ జాబితా 2
ముద్రణ(జాబితా 2 యొక్క విలువలు: n',జాబితా 2)
# ప్రింట్ జాబితా 3
ముద్రణ(జాబితా 1 మరియు జాబితా 2 ను కలిసిన తర్వాత జాబితా 3 యొక్క విలువలు: n',జాబితా 3)
అవుట్‌పుట్
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. జాబితా 2 వేరియబుల్ జాబితా అంశాలుగా మూడు ఇతర జాబితాలను కలిగి ఉంది. కాబట్టి, జాబితా 1 తో జాబితా 2 యొక్క ఈ మూడు ఉప-జాబితాల మధ్య ఖండనను ఫలితం చూపుతుంది.
ముగింపు
పెద్ద సంఖ్యలో జాబితా అంశాలను కలిగి ఉన్న జాబితాల మధ్య ఉమ్మడి విలువలను కనుగొనడానికి జాబితా ఖండన ఉపయోగకరమైన మార్గం. అంతర్నిర్మిత ఫంక్షన్లతో మరియు లేకుండా జాబితా ఖండనను నిర్వహించే పద్ధతులు ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి. ఈ కథనాన్ని చదివిన తర్వాత, జాబితా ఖండన యొక్క భావన స్పష్టంగా ఉండాలి మరియు ఈ ట్యుటోరియల్‌లో చూపిన ఏదైనా మార్గాన్ని అనుసరించడం ద్వారా మీరు మీ స్క్రిప్ట్‌లోని జాబితా ఖండనను వర్తింపజేయగలగాలి.