Python, zip() फंक्शन वापरणे: एकाच वेळी अनेक सूचीचे घटक मिळवणे

Python चे अंगभूत फंक्शन zip() एकापेक्षा जास्त पुनरावृत्ती करण्यायोग्य ऑब्जेक्ट्सचे घटक एकत्र करते (याद्या, ट्यूपल्स, इ.) आणि एक फॉर लूपमध्ये एकाधिक सूचीचे घटक पुनर्प्राप्त करण्यासाठी वापरले जाते.

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

हा विभाग zip() फंक्शनच्या खालील वापराचे वर्णन करतो.

• एक फॉर लूपमध्ये एकाधिक सूचीचे घटक मिळवा.
• घटकांच्या भिन्न संख्येसह व्यवहार करणे
  • zip():फंक्शन खूप जास्त असलेल्या घटकांकडे दुर्लक्ष करेल.
  • itertools.zip_longest():हे फंक्शन गहाळ घटक भरेल.
• एकाधिक पुनरावृत्तीच्या घटकांच्या ट्युपल्सची सूची मिळवा.

एक फॉर लूपमध्ये एकाधिक सूचीचे घटक मिळवा.

जर तुम्हाला अनेक पुनरावृत्ती करता येण्याजोग्या वस्तूंचे घटक (याद्या, ट्यूपल्स, इ.) एकाच वेळी एक फॉर लूपमध्ये परत मिळवायचे असतील आणि वापरायचे असतील, तर त्यांना zip() फंक्शनमध्ये वितर्क म्हणून निर्दिष्ट करा.

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

घटकांच्या भिन्न संख्येसह व्यवहार करणे

zip() फंक्शन मोठ्या प्रमाणात घटकांकडे दुर्लक्ष करते.

zip() फंक्शनमध्ये, प्रत्येक यादीतील घटकांची संख्या भिन्न असल्यास, घटकांची कमी (लहान) संख्या परत केली जाईल आणि मोठ्या संख्येकडे दुर्लक्ष केले जाईल.

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

डीफॉल्टनुसार, ते None ने भरलेले असते.

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

फिलव्हॅल्यू आर्ग्युमेंट निर्दिष्ट केल्यास, ते त्या मूल्याने भरले जाईल.

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. zip() फंक्शन वापरणे

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

हे सूची आकलन नोटेशन आणि * द्वारे सूची विस्तार वापरते.

• संबंधित लेख:पायथन सूची आकलन संकेतन वापरणे

एकाधिक पुनरावृत्तीच्या घटकांच्या ट्युपल्सची सूची मिळवा.

zip() फंक्शन एक इटरेटर (झिप ऑब्जेक्ट) मिळवते जे एकापेक्षा जास्त पुनरावृत्ती करण्यायोग्य ऑब्जेक्ट्सच्या घटकांचे एक टपल असते.
हे फॉर लूपच्या बाहेर देखील वापरले जाऊ शकते आणि लक्ष्य सूचीपुरते मर्यादित नाही.

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

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

जर तुम्हाला एकापेक्षा जास्त पुनरावृत्ती करता येण्याजोग्या वस्तूंच्या घटकांची सूची ट्यूपल म्हणून मिळवायची असेल, तर सूची बनवण्यासाठी list() वापरा.

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