पायथन, ज़िप () फ़ंक्शन का उपयोग करना: एक साथ कई सूचियों के तत्व प्राप्त करना

पायथन का अंतर्निहित फ़ंक्शन ज़िप () कई चलने योग्य वस्तुओं (सूचियों, टुपल्स, आदि) के तत्वों को जोड़ता है और लूप के लिए कई सूचियों के तत्वों को पुनः प्राप्त करने के लिए उपयोग किया जाता है।

• zip() — Built-in Functions — Python 3.10.1 Documentation

यह खंड ज़िप () फ़ंक्शन के निम्नलिखित उपयोग का वर्णन करता है।

• लूप के लिए एकाधिक सूचियों के तत्व प्राप्त करें।
• तत्वों की विभिन्न संख्या से निपटना
  • zip():फ़ंक्शन उन तत्वों को अनदेखा कर देगा जो बहुत अधिक हैं।
  • itertools.zip_longest():यह फ़ंक्शन लापता तत्वों को भर देगा।
• एकाधिक पुनरावृत्तियों के तत्वों के टुपल्स की सूची प्राप्त करें।

लूप के लिए एकाधिक सूचियों के तत्व प्राप्त करें।

यदि आप लूप के लिए एक ही समय में एक से अधिक चलने योग्य वस्तुओं (सूचियों, टुपल्स, आदि) के तत्वों को पुनः प्राप्त करना और उनका उपयोग करना चाहते हैं, तो उन्हें ज़िप () फ़ंक्शन के लिए तर्क के रूप में निर्दिष्ट करें।

names = ['Alice', 'Bob', 'Charlie']
ages = [24, 50, 18]

for name, age in zip(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18

न केवल दो, बल्कि तीन या अधिक भी।

points = [100, 85, 90]

for name, age, point in zip(names, ages, points):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 90

तत्वों की विभिन्न संख्या से निपटना

ज़िप () फ़ंक्शन बड़ी संख्या में तत्वों की उपेक्षा करता है।

ज़िप () फ़ंक्शन में, यदि प्रत्येक सूची में तत्वों की संख्या भिन्न होती है, तो तत्वों की कम (छोटी) संख्या वापस कर दी जाएगी, और बड़ी संख्या को अनदेखा कर दिया जाएगा।

names = ['Alice', 'Bob', 'Charlie', 'Dave']
ages = [24, 50, 18]

for name, age in zip(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18

itertools.zip_longest() फ़ंक्शन लापता तत्वों को भर देगा।

मानक पुस्तकालय itertools मॉड्यूल में zip_longest () का उपयोग करते हुए, लापता तत्वों को मनमाने मूल्यों से भरना संभव है जब प्रत्येक सूची में तत्वों की संख्या भिन्न होती है।

• itertools — Functions creating iterators for efficient looping — Python 3.10.1 Documentation

डिफ़ॉल्ट रूप से, यह कोई नहीं से भरा होता है।

from itertools import zip_longest

names = ['Alice', 'Bob', 'Charlie', 'Dave']
ages = [24, 50, 18]

for name, age in zip_longest(names, ages):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18
# Dave None

यदि fillvalue तर्क निर्दिष्ट किया गया है, तो यह उस मान से भर जाएगा।

for name, age in zip_longest(names, ages, fillvalue=20):
    print(name, age)
# Alice 24
# Bob 50
# Charlie 18
# Dave 20

यहां तक ​​​​कि अगर लापता तत्वों के साथ कई सूचियां हैं, तो भरा जाने वाला मान एक समान है। विभिन्न मूल्यों को निर्दिष्ट करना संभव नहीं है।

points = [100, 85]

for name, age, point in zip_longest(names, ages, points, fillvalue=20):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 20
# Dave 20 20

zip_longest () के अंदर zip_longest () का उपयोग करके एक अलग मान निर्दिष्ट करना संभव है, लेकिन यह व्यावहारिक नहीं है क्योंकि आपको पहले से पता होना चाहिए कि सूची के कौन से तत्व गायब हैं।

यदि आप कई सूचियों को अज्ञात संख्या में तत्वों से भरना चाहते हैं, प्रत्येक एक अलग मूल्य के साथ, निम्नलिखित प्रक्रिया पर विचार किया जा सकता है।

1. सभी सूचियों को भरने के लिए मान निर्धारित करें।
2. तत्वों की अधिकतम संख्या प्राप्त करें
3. सभी सूचियों को तत्वों की अधिकतम संख्या तक भरें
4. ज़िप () फ़ंक्शन का उपयोग करना

fill_name = 'XXX'
fill_age = 20
fill_point = 50

len_names = len(names)
len_ages = len(ages)
len_points = len(points)

max_len = max(len_names, len_ages, len_points)

names = names + [fill_name] * (max_len - len_names)
ages = ages + [fill_age] * (max_len - len_ages)
points = points + [fill_point] * (max_len - len_points)

print(names)
print(ages)
print(points)
# ['Alice', 'Bob', 'Charlie', 'Dave']
# [24, 50, 18, 20]
# [100, 85, 50, 50]

for name, age, point in zip(names, ages, points):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 50
# Dave 20 50

तत्वों की सबसे बड़ी संख्या तक भरने की प्रक्रिया में, हम निम्नलिखित कार्य करते हैं।

• एक मनमाना मूल्य और तत्वों की संख्या के साथ एक सूची शुरू करना
• + ऑपरेटर एक साथ सूचियों में शामिल होने के लिए

अगर हम इसे एक फंक्शन में बदलते हैं, तो यह इस तरह दिखता है। मूल सूची और सूची को भरने वाले मान क्रमशः पुनरावृत्तीय (सूची या टपल) तर्क के रूप में निर्दिष्ट हैं।

def my_zip_longest(iterables, fillvalues):
    max_len = max(len(i) for i in iterables)
    return zip(*[list(i) + [v] * (max_len - len(i)) for i, v in zip(iterables, fillvalues)])

for name, age, point in my_zip_longest((names, ages, points), ('XXX', 20, 50)):
    print(name, age, point)
# Alice 24 100
# Bob 50 85
# Charlie 18 50
# Dave 20 50

यह * द्वारा सूची समझ संकेतन और सूची विस्तार का उपयोग करता है।

• संबंधित आलेख:पायथन सूची समझ संकेतन का उपयोग करना

एकाधिक पुनरावृत्तियों के तत्वों के टुपल्स की सूची प्राप्त करें।

ज़िप () फ़ंक्शन एक पुनरावर्तक (ज़िप ऑब्जेक्ट) देता है जो कई पुनरावर्तनीय वस्तुओं के तत्वों का एक टपल है।
इसका उपयोग लूप के बाहर भी किया जा सकता है, और लक्ष्य सूचियों तक सीमित नहीं है।

names = ['Alice', 'Bob', 'Charlie']
ages = (24, 50, 18)

z = zip(names, ages)
print(z)
print(type(z))
# <zip object at 0x10b57b888>
# <class 'zip'>

यदि आप एक टुपल के रूप में कई चलने योग्य वस्तुओं के तत्वों की सूची प्राप्त करना चाहते हैं, तो सूची बनाने के लिए सूची () का उपयोग करें।

l = list(zip(names, ages))
print(l)
print(type(l))
print(type(l[0]))
# [('Alice', 24), ('Bob', 50), ('Charlie', 18)]
# <class 'list'>
# <class 'tuple'>