జిప్ ఫంక్షన్ గురించి
ముందే చెప్పినట్లుగా, బహుళ పునరుత్పాదక వస్తువుల మూలకాల నుండి జతలను సృష్టించడానికి జిప్ ఫంక్షన్ ఉపయోగించబడుతుంది. జిప్ ఫంక్షన్ యొక్క ప్రాథమిక వాక్యనిర్మాణం మరియు వినియోగాన్ని అర్థం చేసుకోవడానికి క్రింది ఉదాహరణను పరిశీలించండి:
జాబితా 1= ['కు', 'b', 'సి']
జాబితా 2= ['ఆపిల్', 'బంతి', 'పిల్లి']
జిప్ చేయబడింది= జిప్(జాబితా 1,జాబితా 2)
ముద్రణ (జాబితా(జిప్ చేయబడింది))
పై కోడ్ నమూనాలోని మొదటి రెండు స్టేట్‌మెంట్‌లు కొన్ని మూలకాలను కలిగి ఉన్న రెండు జాబితాలను నిర్వచిస్తాయి. తరువాత, జాబితా 1 మరియు జాబితా 2 వేరియబుల్స్‌ను ఆర్గ్యుమెంట్‌లుగా పాస్ చేయడం ద్వారా జిప్ ఫంక్షన్ ఉపయోగించబడుతుంది. ఇది జిప్ ఫంక్షన్ యొక్క ప్రధాన వాక్యనిర్మాణం. మీరు లిస్ట్‌లు లేదా ఇతర చెల్లుబాటు అయ్యే ఆర్డర్ చేసిన ఐటరబుల్‌లను ఆర్గ్యుమెంట్‌లుగా పాస్ చేయాలి, దీని అంశాలు మీరు మిళితం చేయాలనుకుంటున్నారు. చివరగా, ప్రింట్ స్టేట్మెంట్ జిప్ చేయబడిన వేరియబుల్ యొక్క అవుట్పుట్ పొందడానికి ఉపయోగించబడుతుంది. పైన పేర్కొన్న కోడ్ నమూనాను అమలు చేసిన తర్వాత, మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందాలి:
[('a', 'ఆపిల్'), ('b', 'బంతి'), ('c', 'పిల్లి')]
జిప్ ఫంక్షన్ జిప్ రకం వస్తువును అందిస్తుంది మరియు జాబితా కాదు. పై ప్రింట్ స్టేట్‌మెంట్‌లో చూపిన విధంగా మీరు దాన్ని ఇటరబుల్ రకానికి మార్చాలి.
సరళంగా చెప్పాలంటే, జిప్ ఫంక్షన్ ఒకే ఇండెక్స్‌లోని ఎలిమెంట్‌లను రెండు లిస్ట్‌ల నుండి ఎంచుకుంటుంది మరియు వాటిని జతగా జతచేస్తుంది. కాబట్టి జాబితా 1 నుండి 0 వ మూలకం జాబితా 2 యొక్క 0 వ మూలకంతో, జాబితా 1 నుండి 1 వ మూలకం జాబితా 2 యొక్క 1 వ మూలకంతో కలిపి ఉంటుంది. జిప్ ఫంక్షన్ ఎడమ నుండి కుడికి కదులుతుంది మరియు జత మూలకాలను కలిగి ఉన్న టపుల్ వాటిలో నిల్వ చేయబడిన మూలకాల మాదిరిగానే ఉంటుంది.
ఐటరబుల్స్‌లో ఒకే మూలకాల సంఖ్య లేనప్పుడు జిప్‌ను ఉపయోగించడం
పైన పేర్కొన్న ఉదాహరణలో, రెండు జాబితాలు సమాన సంఖ్యలో మూలకాలను కలిగి ఉంటాయి. ఒకవేళ మీరు రెండు కోడ్‌లు ఒకే సంఖ్యలో మూలకాలు లేని కొన్ని కోడ్‌తో వ్యవహరిస్తున్నట్లయితే, జిప్ ఫంక్షన్ అతి తక్కువ సంఖ్యలో మూలకాలను కలిగి ఉన్న జాబితాలోని చివరి మూలకం వద్ద ఆగిపోతుంది.
దిగువ ఉదాహరణలో, జాబితా 2 లో మరో మూలకం ఉన్నప్పటికీ, సి ఫంక్షన్ సి మూలకం వద్ద ఆగిపోతుంది.
జాబితా 1= ['కు', 'b', 'సి']
జాబితా 2= ['ఆపిల్', 'బంతి', 'పిల్లి', 'బొమ్మ']
జిప్ చేయబడింది= జిప్(జాబితా 1,జాబితా 2)
ముద్రణ (జాబితా(జిప్ చేయబడింది))
పైన పేర్కొన్న కోడ్ నమూనాను అమలు చేసిన తర్వాత, మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందాలి:
[('a', 'ఆపిల్'), ('b', 'బంతి'), ('c', 'పిల్లి')]జిప్ ఫంక్షన్ ఉపయోగిస్తున్నప్పుడు మీరు రెండు కంటే ఎక్కువ ఐటరబుల్స్ ఉపయోగించవచ్చు
సాధారణంగా, రెండు ఫంక్షన్‌లను పోల్చడానికి జిప్ ఫంక్షన్ ఉపయోగించబడుతుంది. అయితే, మీరు జిప్ ఫంక్షన్‌కి వాదనలుగా ఎన్ని ఐటరబుల్స్ అయినా పాస్ చేయవచ్చు. చిన్న జాబితాలోని చివరి మూలకం వద్ద ఆపే సూత్రం ఇప్పటికీ వర్తిస్తుంది.
జాబితా 1= ['కు', 'b', 'సి']జాబితా 2= ['ఆపిల్', 'బంతి', 'పిల్లి', 'బొమ్మ']
జాబితా 3= ['5', '3']
జిప్ చేయబడింది= జిప్(జాబితా 1,జాబితా 2,జాబితా 3)
ముద్రణ (జాబితా(జిప్ చేయబడింది))
పైన పేర్కొన్న కోడ్ నమూనాను అమలు చేసిన తర్వాత, మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందాలి:
[('a', 'ఆపిల్', '5'), ('b', 'బాల్', '3')]జిప్ రకం వస్తువు నుండి వ్యక్తిగత జాబితాలను సృష్టించడం
మీరు ఇప్పటికే జిప్ ఆబ్జెక్ట్ కలిగి ఉంటే, ముందుగా జిప్ ఫంక్షన్‌ను పిలిచినప్పుడు గతంలో ఉపయోగించిన వ్యక్తిగత లిస్ట్‌లను రీపోపుల్ చేయడానికి మీరు దాన్ని ఉపయోగించవచ్చు.
జాబితా 1= ['కు', 'b', 'సి']జాబితా 2= ['ఆపిల్', 'బంతి', 'పిల్లి', 'బొమ్మ']
జాబితా 3= ['5', '3']
జిప్ చేయబడింది= జిప్(జాబితా 1,జాబితా 2,జాబితా 3)
l1,l2,l3= జిప్(*జిప్ చేయబడింది)
ముద్రణ (జాబితా(l1), జాబితా(l2), జాబితా(l3))
పైన పేర్కొన్న కోడ్ నమూనాను అమలు చేసిన తర్వాత, మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందాలి:
['a', 'b'] ['ఆపిల్', 'బాల్'] ['5', '3']పై కోడ్ నమూనాలో, జిప్ ఆబ్జెక్ట్ * ఆపరేటర్‌ని ఉపయోగించి తొలగించబడుతుంది. అసమాన జాబితాలను సృష్టించే జిప్ ఫంక్షన్‌కు మరొక కాల్‌కి డీఫ్లేటెడ్ ఫలితాలు అందించబడతాయి. మొదటిసారి జిప్ ఆబ్జెక్ట్ సృష్టించబడినప్పుడు అసమాన పొడవు జాబితాలు ఉపయోగించినట్లయితే మీరు అసలు ఎలిమెంట్‌లలో అన్ని ఎలిమెంట్‌లను తిరిగి పొందలేరని గమనించండి.
ఎలిమెంట్స్‌ని సుదీర్ఘకాలం గుర్తుండిపోయేలా ఉంచాలనుకున్నప్పుడు జిప్‌ని ఉపయోగించడం
పై బహుళ ఉదాహరణలలో, డిఫాల్ట్‌గా జిప్ ఫంక్షన్ అతి తక్కువ ఇట్రేబుల్ యొక్క చివరి మూలకం వద్ద ఆగిపోతుందని మీరు గమనించి ఉండవచ్చు. పొడవైన ఇటరబుల్ యొక్క చివరి మూలకాన్ని చేరుకునే వరకు ఇది పునరావృతం కావాలని మీరు కోరుకుంటే?
అటువంటప్పుడు, మీరు పైథాన్ యొక్క ఇర్టూల్స్ మాడ్యూల్ నుండి జిప్_లాంగెస్ట్ () పద్ధతిని ఉపయోగించాల్సి ఉంటుంది. ఇది జిప్ ఫంక్షన్ మాదిరిగానే పనిచేస్తుంది, ఒక చిన్న వ్యత్యాసంతో ఇది పొడవైన ఇటరబుల్ రకం చివరి మూలకం వద్ద ఆగిపోతుంది.
నుండి itertools దిగుమతిzip_ పొడవాటిజాబితా 1= ['కు', 'b', 'సి']
జాబితా 2= ['ఆపిల్', 'బంతి', 'పిల్లి', 'బొమ్మ']
జాబితా 3= ['5', '3']
జిప్ చేయబడింది=zip_ పొడవాటి(జాబితా 1,జాబితా 2,జాబితా 3)
ముద్రణ (జాబితా(జిప్ చేయబడింది))
పైన పేర్కొన్న కోడ్ నమూనాను అమలు చేసిన తర్వాత, మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందాలి:
[('a', 'ఆపిల్', '5'), ('b', 'బాల్', '3'), ('c', 'పిల్లి', ఏదీ లేదు), (ఏదీ, 'బొమ్మ', ఏదీ కాదు) ]తప్పిపోయిన విలువలు ఏ విధమైన వస్తువులుగా లేవు. అదనపు పూరక విలువ వాదనను zip_longest పద్ధతికి పంపడం ద్వారా మీరు మీ స్వంత విలువను కూడా పూరించవచ్చు.
నుండి itertools దిగుమతిzip_ పొడవాటిజాబితా 1= ['కు', 'b', 'సి']
జాబితా 2= ['ఆపిల్', 'బంతి', 'పిల్లి', 'బొమ్మ']
జాబితా 3= ['5', '3']
జిప్ చేయబడింది=zip_ పొడవాటి(జాబితా 1,జాబితా 2,జాబితా 3,పూరక విలువ='నా_విలువ')
ముద్రణ (జాబితా(జిప్ చేయబడింది))
పైన పేర్కొన్న కోడ్ నమూనాను అమలు చేసిన తర్వాత, మీరు ఈ క్రింది అవుట్‌పుట్‌ను పొందాలి:
[('a', 'ఆపిల్', '5'), ('b', 'బాల్', '3'), ('c', 'పిల్లి', 'my_value'), ('my_value', 'బొమ్మ ',' my_value ')]ముగింపు
జిప్ ఫంక్షన్‌ను కొన్ని లూప్‌లు మరియు షరతుల స్టేట్‌మెంట్‌లను ఉపయోగించి అనుకరించవచ్చు. అయితే, అనవసరమైన వెర్బొసిటీ మరియు పునరావృత ప్రకటనలను తీసివేయడం ద్వారా కోడ్‌ను క్రమబద్ధంగా మరియు క్లీనర్‌గా ఉంచడంలో ఇది సహాయపడుతుంది.