परिचय
लिस्ट कॉम्प्रिहेंशन एक सोर्स लिस्ट लेकर और एक एक्सप्रेशन लागू करके एक डेराइव्ड लिस्ट प्राप्त करना आसान बनाता है। उदाहरण के लिए, मान लीजिए मैं एक लिस्ट में प्रत्येक तत्व को 5 से गुणा करना चाहता हूं।
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
multiply_by_5 = []
for x in a:
multiply_by_5.append(x*5)
print(f"Output \n *** {multiply_by_5}")
आउटपुट: [5, 10, 15, 20, 25, 30, 35, 40, 45, 50]
लिस्ट कॉम्प्रिहेंशन के साथ, मैं एक्सप्रेशन और लूप करने के लिए इनपुट सीक्वेंस निर्दिष्ट करके वही परिणाम प्राप्त कर सकता हूं।
multiply_by_5 = [x*2 for x in a]
print(f"Output \n *** {multiply_by_5}")
आउटपुट: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
दो लिस्ट्स को जोड़ने के लिए zip का उपयोग
# 1. नंबरों की लिस्ट बनाएं
list1 = [100, 200, 300, 400]
list2 = [500, 600, 700, 800]
# 2. दो लिस्ट्स को जोड़कर नई लिस्ट बनाएं
list3 = []
for i in range(len(list1)):
added_value = list1[i] + list2[i]
list3.append(added_value)
print(f"Output \n*** {list3}")
आउटपुट: [600, 800, 1000, 1200]
अब जहां तक जिपिंग का सवाल है, यहां उसी लिस्ट इंटीजर्स के लिए एक zip समाधान है। इस मामले में, इंटीजर्स की दो लिस्ट्स, एक में 100, 200, 300 और 400, और दूसरी में 500, 600, 700 और 800।
हम उन जोड़ियों के एलिमेंट्स को एक साथ ज़िप करने जा रहे हैं, इसलिए list1 से 100 और list2 से 500 एक साथ ज़िप होंगे, और इसी तरह। प्रत्येक टपल के लिए, जैसे ही हम उनके माध्यम से पुनरावृति करते हैं, हम टपल को वेरिएबल्स a और b में अनपैक करेंगे।
list4 = []
list4 = [(a + b) for a, b in zip(list1, list2)]
print(f"Output \n*** {list4}")
आउटपुट: [600, 800, 1000, 1200]
महत्वपूर्ण समस्या: अलग-अलग लंबाई के इटरेटर्स के साथ zip का व्यवहार
zip बिल्ट-इन फंक्शन अजीब व्यवहार करता है अगर इनपुट इटरेटर्स अलग-अलग लंबाई के हैं।
# list1 में एक नया नंबर जोड़ें
list1.append(1000)
print(f"Output \n*** Length of List1 is {len(list1)} , Length of List2 is {len(list2)}")
# एडिशन के लिए लिस्ट के खिलाफ zip चलाएं
list5 = [(a + b) for a, b in zip(list1, list2)]
print(f"*** {list5}")
आउटपुट: [600, 800, 1000, 1200] (list1 में जोड़ा गया अतिरिक्त एलिमेंट गायब है)
zip कैसे काम करता है: यह आपको टपल्स में तब तक रखता है जब तक कि कोई भी इटरेटर समाप्त नहीं हो जाता। इसलिए भले ही list1 में list2 की तुलना में अधिक है, list2 पहले समाप्त हो जाता है और फिर लूप निकल जाता है।
आश्चर्यजनक रूप से, आपको किसी एक्सेप्शन के साथ सूचित नहीं किया जाता। इसलिए प्रोडक्शन में zip के साथ बहुत सावधान रहना होगा।
समाधान: itertools से zip_longest
zip_longest तब भी चलता रहता है जब एक इटरेटर समाप्त हो चुका होता है।
from itertools import zip_longest
list6 = []
for a, b in zip_longest(list1, list2):
if b is None:
print(f" << do your logic here >>")
elif a is None:
print(f" << do your logic here >>")
else:
list6.append(a + b)
print(f"Output \n*** {list6}")
आउटपुट: [600, 800, 1000, 1200]
निष्कर्ष
zipफंक्शन बहुत उपयोगी है अगर आप कई इटरेटर्स पर समानांतर में पुनरावृति करना चाहते हैं।zipफंक्शन अलग-अलग लंबाई के इटरेटर्स पास करने पर अलग तरह से काम करता है।- अगर आप अलग-अलग लंबाई के इटरेटर्स का उपयोग करना चाहते हैं तो
zip_longestके साथ जाएं।