பைதான், zip() செயல்பாட்டைப் பயன்படுத்துதல்: பல பட்டியல்களின் கூறுகளை ஒரே நேரத்தில் பெறுதல்

வணிக

பைத்தானின் உள்ளமைக்கப்பட்ட செயல்பாடு zip() ஆனது பல திரும்பச் செய்யக்கூடிய பொருள்களின் (பட்டியல்கள், டூப்பிள்கள், முதலியன) கூறுகளை ஒருங்கிணைக்கிறது மற்றும் ஒரு for loop இல் உள்ள பல பட்டியல்களின் கூறுகளை மீட்டெடுக்கப் பயன்படுகிறது.

இந்த பகுதி 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() செயல்பாடு அதிக எண்ணிக்கையிலான உறுப்புகளை புறக்கணிக்கிறது.

ஜிப்() செயல்பாட்டில், ஒவ்வொரு பட்டியலிலும் உள்ள உறுப்புகளின் எண்ணிக்கை வேறுபட்டால், குறைவான (குறைந்த) உறுப்புகள் வரை திருப்பி அனுப்பப்படும், மேலும் அதிக எண்ணிக்கை புறக்கணிக்கப்படும்.

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() ஐப் பயன்படுத்தி, ஒவ்வொரு பட்டியலிலும் உள்ள உறுப்புகளின் எண்ணிக்கை வேறுபட்டால், விடுபட்ட உறுப்புகளை தன்னிச்சையான மதிப்புகளுடன் நிரப்ப முடியும்.

முன்னிருப்பாக, இது எதுவும் இல்லை என நிரப்பப்பட்டுள்ளது.

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'>