ज़िप का उपयोग करके समानांतर में पुनरावृत्तियों को कैसे संसाधित करें

परिचय

सूची की समझ से स्रोत सूची लेना आसान हो जाता है और व्यंजक लागू करके व्युत्पन्न सूची प्राप्त करना आसान हो जाता है। उदाहरण के लिए, मान लें कि मैं सूची में प्रत्येक तत्व को 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]

एक सूची समझ के साथ, मैं अभिव्यक्ति और इनपुट अनुक्रम को लूप ओवर निर्दिष्ट करके समान परिणाम प्राप्त कर सकता हूं।

# List comprehension
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]

अब, मान लें कि आपके पास जोड़ने के लिए कुछ सूचियाँ हैं।

# 1 . Create a List of Numbers
list1 = [100, 200, 300, 400]
list2 = [500, 600, 700, 800]

# 2. Add the two lists to create a new list
list3 = []

# Using a Loop.
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]

अब यहां जो महत्वपूर्ण है वह यह है कि जोड़े गए मूल्यों की व्युत्पन्न सूची (हमारे मामले में सूची 3) में आइटम सीधे स्रोत सूची में आइटम्स से उनकी अनुक्रमणिका द्वारा संबंधित हैं।

अब जहाँ तक ज़िपिंग की बात है, यहाँ समान सूची पूर्णांकों के लिए एक ज़िप समाधान है। इस मामले में, पूर्णांकों की दो सूचियाँ, जिनमें से एक में 100, 200, 300 और 400 हैं, और एक में 500, 600, 700 और 800 हैं। और निश्चित रूप से, हम उन्हें परिभाषित कर सकते हैं और उन्हें चर के लिए असाइन कर सकते हैं। और जरूरी नहीं कि वे सूचियां हों।

वे अन्य अनुक्रम हो सकते हैं, जैसे टुपल्स, इत्यादि।

तो हम जो करने जा रहे हैं, उनमें से तत्वों के जोड़े को एक साथ ज़िप करें, इसलिए सूची 1 से 100 और सूची 2 से 500 को एक साथ ज़िप किया जाएगा, और इसी तरह। प्रत्येक टपल के लिए, जैसा कि हम उनके माध्यम से पुनरावृति करते हैं, हम टपल को वेरिएबल a और b में अनपैक करेंगे।

list4 = []
list4 = [(a + b) for a, b in zip(list1, list2)]
print(f"Output \n*** {list4}")

आउटपुट

*** [600, 800, 1000, 1200]

अब उपरोक्त समाधान वास्तव में अच्छा लग रहा है, हालांकि एक गंभीर समस्या है जिसे आपको अपने कोड में लागू करने से पहले जानना आवश्यक है।

zip बिल्ट-इन फ़ंक्शन अजीब तरह से व्यवहार करता है यदि इनपुट इटरेटर अलग-अलग लंबाई के होते हैं। आइए उन्हें आजमाएं।

# add a new number to the list
list1.append(1000)
print(f"Output \n*** Length of List1 is {len(list1)} , Length of List2 is {len(list2)}")

# run the zip against the list for addition.
list5 = [(a + b) for a, b in zip(list1, list2)]
print(f"*** {list5}")

आउटपुट

*** Length of List1 is 9 , Length of List2 is 4
*** [600, 800, 1000, 1200]

अब जब हम सूची 3 से प्रत्येक जोड़े गए नंबर का प्रिंट आउट लेते हैं, तो आप देखेंगे कि सूची 1 में जोड़ा गया नंबर गायब है, भले ही हमने इसे वहां जोड़ा है और यह सूची 1 में है, यह ज़िप के आउटपुट में दिखाई नहीं देता है।

और यह है कि ज़िप कैसे काम करता है। यह आपको तब तक टुपल्स में रखता है जब तक कि कोई भी इटरेटर समाप्त नहीं हो जाता। तो भले ही सूची 1 में सूची 2 की तुलना में अधिक जाना है, यह पहले समाप्त हो जाता है और फिर लूप बाहर निकलता है।

हैरानी की बात है कि आपको किसी अपवाद के साथ सूचित नहीं किया जाता है। इसलिए आपको उत्पादन में ज़िप के साथ बहुत सावधान रहना होगा।

आपके पास इस समस्या के लिए पाइथॉन फंक्शन में एक विकल्प है जिसे जिप लॉन्गेस्ट कहा जाता है।

यह ज़िप सबसे लंबी है, यह तब भी चलती रहती है जब एक इटरेटर समाप्त हो गया हो।

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}")

<< do your logic here >>
<< do your logic here >>
<< do your logic here >>
<< do your logic here >>
<< do your logic here >>

आउटपुट

*** [600, 800, 1000, 1200]

निष्कर्ष:

• यदि आप समानांतर में एकाधिक पुनरावृत्तियों पर पुनरावृति करना चाहते हैं तो ज़िप फ़ंक्शन बहुत आसान है।

• जब आप अलग-अलग लंबाई के इटरेटर पास करते हैं तो ज़िप फ़ंक्शन अलग तरह से काम करता है।

• यदि आप अलग-अलग लंबाई के इटरेटर का उपयोग करना चाहते हैं तो zip_longest के साथ जाएं।