Python၊ zip() လုပ်ဆောင်ချက်ကို အသုံးပြုခြင်း- စာရင်းများစွာ၏ အစိတ်အပိုင်းများကို တစ်ပြိုင်နက် ရယူခြင်း။

Python ၏ built-in function zip() သည် ထပ်၍ရနိုင်သော အရာများစွာ (lists, tuples, etc.) ၏ဒြပ်စင်များကို ပေါင်းစပ်ပြီး for loop တစ်ခုအတွင်းရှိ စာရင်းများစွာ၏ဒြပ်စင်များကို ပြန်လည်ရယူရန်အတွက် အသုံးပြုပါသည်။

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

ဤကဏ္ဍသည် zip() လုပ်ဆောင်ချက်၏ အောက်ပါအသုံးပြုမှုကို ဖော်ပြသည်။

• for loop တစ်ခုတွင် စာရင်းများစွာ၏ အစိတ်အပိုင်းများကို ရယူပါ။
• ကွဲပြားခြားနားသောဒြပ်စင်များနှင့်အတူကိုင်တွယ်ဖြေရှင်း
  • zip():လုပ်ဆောင်ချက်သည် အလွန်များသော အစိတ်အပိုင်းများကို လျစ်လျူရှုပါမည်။
  • itertools.zip_longest():ဤလုပ်ဆောင်ချက်သည် ပျောက်ဆုံးနေသောဒြပ်စင်များကို ဖြည့်ပေးလိမ့်မည်။
• ထပ်၍ရနိုင်သော အစိတ်အပိုင်းများစွာ၏ tuples စာရင်းကို ရယူပါ။

for loop တစ်ခုတွင် စာရင်းများစွာ၏ အစိတ်အပိုင်းများကို ရယူပါ။

for loop တစ်ခုတွင် ထပ်တူရနိုင်သော အရာများစွာ (စာရင်းများ၊ tuple စသည်တို့) ၏ဒြပ်စင်များကို ပြန်လည်ရယူပြီး အသုံးပြုလိုပါက၊ ၎င်းတို့အား 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

ဒြပ်စင် အရေအတွက် အများဆုံးအထိ ဖြည့်သွင်းသည့် လုပ်ငန်းစဉ်တွင်၊ ကျွန်ုပ်တို့ အောက်ပါအတိုင်း လုပ်ဆောင်ပါသည်။

• အများသူငှာတန်ဖိုးနှင့် ဒြပ်စင်အရေအတွက်ဖြင့် စာရင်းတစ်ခုကို အစပြုခြင်း။
• + စာရင်းများကိုအတူတကွပူးပေါင်းရန်အော်ပရေတာ

ဒါကို function တစ်ခုအဖြစ်ပြောင်းလိုက်ရင်၊ ဒီပုံပါပဲ။ မူရင်းစာရင်းနှင့် စာရင်းကိုဖြည့်သည့်တန်ဖိုးများကို iterables (list or tuple) arguments များအဖြစ် သတ်မှတ်ထားပါသည်။

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

၎င်းသည် စာရင်းနားလည်မှုအမှတ်အသားနှင့် * ဖြင့် စာရင်းချဲ့ထွင်ခြင်းကို အသုံးပြုသည်။

• ဆက်စပ်ဆောင်းပါးများ-Python list ၏ နားလည်နိုင်စွမ်း အမှတ်အသားကို အသုံးပြုခြင်း။

ထပ်၍ရနိုင်သော အစိတ်အပိုင်းများစွာ၏ tuples စာရင်းကို ရယူပါ။

ဇစ်() လုပ်ဆောင်ချက်သည် ထပ်တလဲလဲလုပ်နိုင်သော အရာများစွာ၏ ဒြပ်စင်တစ်ခုဖြစ်သည့် iterator (zip object) ကို ပြန်ပေးသည်။
၎င်းကို for loop ပြင်ပတွင်လည်း အသုံးပြုနိုင်ပြီး ပစ်မှတ်သည် စာရင်းများအတွက် အကန့်အသတ်မရှိပါ။

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

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

tuple အဖြစ် ထပ်၍သုံးနိုင်သော အရာများစွာ၏ ဒြပ်စင်များစာရင်းကို ရယူလိုပါက စာရင်းတစ်ခုပြုလုပ်ရန် 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'>