రెండు వేర్వేరు జాబితాల నుండి ఒక్కొక్క మూలకాన్ని తీసుకొని వాటిని ఒక జతగా చేసి కొత్త జాబితాలో ఎలా ఉంచగలమని ఎప్పుడైనా ఆలోచిస్తున్నారా? ఆసక్తికరంగా ఉండటమే కాకుండా ఈ భావన చాలా స్పెషలైజేషన్ విభాగాలలో చాలా ఉపయోగకరంగా ఉంటుంది. కింది క్రమంలో పైథాన్‌లో జిప్ ఫంక్షన్‌కు పరిచయం చేద్దాం:
పైథాన్‌లో జిప్ ఫంక్షన్
జిప్ () ఫంక్షన్ అంతర్నిర్మిత ఫంక్షన్ మరియు ఇది ఎన్ని పునరావృతాలను తీసుకుంటుంది మరియు టుపుల్స్ జాబితాను అందిస్తుంది. ప్రతి పునరుక్తి నుండి ith మూలకాన్ని ఉపయోగించి టుపుల్ యొక్క ith మూలకం సృష్టించబడుతుంది.
list_A = [1, 2, 3, 4] listB = ['a', 'b', 'c', 'd'] zl = zip (listA, listB) print zl
అవుట్పుట్:
[(1, ‘అ’), (2, ‘బి’), (3, ‘సి’), (4, ‘డి’)]
పైథాన్ 3 లో జిప్ చేయండి
పైథాన్ 3 లో, మేము పై కోడ్‌ను అమలు చేసినప్పుడు, మాకు అదే ఫలితం రాదు. బదులుగా, మేము పొందుతాము:
ప్రయత్నించి చూడండి!
ఎందుకంటే జిప్ పద్ధతులు జాబితాకు బదులుగా జిప్ వస్తువును తిరిగి ఇస్తాయి. ఈ జిప్ ఆబ్జెక్ట్ ఒక ఇరేటర్. మరో మాటలో చెప్పాలంటే, అన్ని కంటైనర్ల నుండి మ్యాప్ చేసిన విలువలను కలిగి ఉన్న ఒకే ఇటరేటర్ వస్తువును తిరిగి ఇస్తుంది. కాబట్టి విలువలను పొందడానికి, మేము zl (పై కోడ్ నుండి) జాబితా, సెట్ లేదా ఏదైనా మార్చాము.
listA = [1, 2, 3, 4] listB = ['a', 'b', 'c', 'd'] zl = zip (listA, listB) zl = list (zl) print (zl)
అవుట్పుట్:
[(1, ‘అ’), (2, ‘బి’), (3, ‘సి’), (4, ‘డి’)]
పైథాన్‌లో అన్జిప్పింగ్
అన్జిప్పింగ్ అంటే జిప్ చేసిన విలువలను తిరిగి వ్యక్తిగత స్వీయంలోకి మార్చడం. ఇది “*” ఆపరేటర్ సహాయంతో జరుగుతుంది. కాబట్టి ఇప్పుడు, పాత విలువలను జిప్డ్ జాబితా zl నుండి listA మరియు listB లోకి ఉంచాలనుకుంటే, అప్పుడు మేము zl ను అన్జిప్ చేయాలి.
listA = [1, 2, 3, 4] listB = ['a', 'b', 'c', 'd'] #zipAA మరియు listB మరియు ఒక జాబితాలో ఉంచండి zl zl = zip (listA, listB) zl = list (zl) print (zl) #unzip zl మరియు విలువలను listA మరియు listB listA, listB = zip (* zl) print (listA) print (listB)
అవుట్పుట్:
ప్రాధాన్యత క్యూ c ++ ను అమలు చేయండి
[(1, ‘అ’), (2, ‘బి’), (3, ‘సి’), (4, ‘డి’)]
(1, 2, 3, 4)
('ఎ బి సి డి')
వ్యత్యాసాన్ని స్పష్టంగా అర్థం చేసుకోవడానికి, మేము రెండు కొత్త వేరియబుల్స్ తీసుకొని, అన్జిప్డ్ డేటాను అందులో ఉంచాము.
listA = [1, 2, 3, 4] listB = ['a', 'b', 'c', 'd'] zl = zip (listA, listB) zl = list (zl) printC (zl) listC, listD = జిప్ (* zl) ప్రింట్ (listC) ప్రింట్ (listD) ప్రింట్ (listA) ప్రింట్ (listB)
అవుట్పుట్:
[(1, ‘అ’), (2, ‘బి’), (3, ‘సి’), (4, ‘డి’)]
(1, 2, 3, 4, 5)
('ఎ బి సి డి ఇ')
[1, 2, 3, 4, 5]
['ఎ బి సి డి ఇ']
మీరు గమనిస్తే, listA మరియు listB లు జాబితాలు మరియు listC మరియు listD అవుట్‌పుట్‌గా చూపబడిన టుపుల్స్‌గా చూపబడతాయి. ఇది చిన్న తేడా మాత్రమే.
దీనితో, పైథాన్ వ్యాసంలో ఈ జిప్ ఫంక్షన్ ముగింపుకు వచ్చాము. మీరు భావనలను బాగా నేర్చుకున్నారని మరియు అందువల్ల మరింత ఖచ్చితమైనదిగా ప్రయత్నించండి అని నేను ఆశిస్తున్నాను.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “పైథాన్‌లో జిప్ ఫంక్షన్” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.
పైథాన్ యొక్క వివిధ అనువర్తనాలతో పాటు లోతైన జ్ఞానం పొందడానికి, మీరు చేయవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో మా ప్రత్యక్ష ఆన్‌లైన్ శిక్షణతో.