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

စီးပွားရေးလုပ်ငန်း

Python တွင်၊ စာရင်းအသစ်တစ်ခုဖန်တီးသည့်အခါ list comprehensions notation ကိုအသုံးပြုရန် ရိုးရှင်းပါသည်။(List comprehensions)

ဤဆောင်းပါးတွင်၊ အောက်ပါတို့ကို ဦးစွာဆွေးနွေးပါမည်။

  • စာရင်းနားလည်မှုမှတ်စု၏ အခြေခံအမျိုးအစား
  • အခြေအနေအလိုက် အကိုင်းအခက်များကို if ဖြင့် နားလည်နိုင်မှုအမှတ်အသားကို စာရင်းပြုစုပါ။
  • ပြင်ပအော်ပရေတာများနှင့် ပေါင်းစပ်ခြင်း (အခြားလုပ်ဆောင်ခြင်းကဲ့သို့)၊
  • zip()၊enumerate()ဒါတွေနဲ့ ပေါင်းစပ်ပါ။
  • nested list တွင်ပါဝင်သည့် သင်္ကေတ

ထို့နောက်၊ နမူနာကုဒ်ဖြင့် စာရင်းနားလည်မှုမှတ်စုအစုကို ရှင်းပြပါမည်။

  • inclusion notation သတ်မှတ်ပါ။(Set comprehensions)
  • အဘိဓာန်တွင် ထည့်သွင်းဖော်ပြချက်(Dict comprehensions)
  • မီးစက်အမျိုးအစား(Generator expressions)

စာရင်းနားလည်မှုမှတ်စု၏ အခြေခံအမျိုးအစား

list comprehension notation ကို အောက်ပါအတိုင်း ရေးထားပါတယ်။

[Expression for Any Variable Name in Iterable Object]

၎င်းသည် စာရင်းတစ်ခု၊ tuple သို့မဟုတ် အပိုင်းအခြားကဲ့သို့ တူညီနိုင်သော အရာတစ်ခုစီ၏ ဒြပ်စင်တစ်ခုစီကို ကာမဆန္ဒပြောင်းလဲနိုင်သောအမည်တစ်ခုဖြင့် ယူကာ ၎င်းကို စကားရပ်တစ်ခုဖြင့် အကဲဖြတ်သည်။ အစိတ်အပိုင်းတစ်ခုအနေဖြင့် အကဲဖြတ်ရလဒ်ပါရှိသော စာရင်းအသစ်ကို ပြန်ပေးပါသည်။

ဥပမာတစ်ခုသည် ကြေငြာချက်နှင့် ညီမျှသည်။

squares = [i**2 for i in range(5)]
print(squares)
# [0, 1, 4, 9, 16]

squares = []
for i in range(5):
    squares.append(i**2)

print(squares)
# [0, 1, 4, 9, 16]

တူညီသောလုပ်ငန်းစဉ်ကို map() ဖြင့်လုပ်ဆောင်နိုင်သော်လည်း list comprehension notation ကို ၎င်း၏ရိုးရှင်းမှုနှင့် ရှင်းလင်းမှုအတွက် ဦးစားပေးပါသည်။

အခြေအနေအလိုက် အကိုင်းအခက်များကို if ဖြင့် နားလည်နိုင်မှုအမှတ်အသားကို စာရင်းပြုစုပါ။

အခြေအနေအရ အကိုင်းအခက်ခွဲခြင်းလည်း ဖြစ်နိုင်သည်။ postfix တွင် if ကို အောက်ပါအတိုင်းရေးပါ။

[Expression for Any Variable Name in Iterable Object if Conditional Expression]

အခြေအနေအရ ဖော်ပြချက်သည် မှန်သော ထပ်ကာထပ်ကာဖြစ်နိုင်သော အရာဝတ္ထု၏ အစိတ်အပိုင်းများကိုသာ စကားရပ်ဖြင့် အကဲဖြတ်ပြီး ရလဒ်ဖြစ်သည့် ဒြပ်စင်များဖြစ်သော စာရင်းအသစ်တစ်ခု။

conditional expression တွင် မည်သည့် variable name ကိုမဆို သင်သုံးနိုင်သည်။

ဥပမာတစ်ခုသည် ကြေငြာချက်နှင့် ညီမျှသည်။

odds = [i for i in range(10) if i % 2 == 1]
print(odds)
# [1, 3, 5, 7, 9]

odds = []
for i in range(10):
    if i % 2 == 1:
        odds.append(i)

print(odds)
# [1, 3, 5, 7, 9]

တူညီသောလုပ်ငန်းစဉ်ကို filter() ဖြင့်လုပ်ဆောင်နိုင်သော်လည်း list comprehension notation သည် ၎င်း၏ရိုးရှင်းမှုနှင့်ရှင်းလင်းမှုအတွက်ဦးစားပေးသည်။

ပြင်ပအော်ပရေတာများနှင့် ပေါင်းစပ်ခြင်း (အခြားလုပ်ဆောင်ခြင်းကဲ့သို့)၊

အထက်ဖော်ပြပါ ဥပမာတွင်၊ စံသတ်မှတ်ချက်များနှင့် ပြည့်မီသော အစိတ်အပိုင်းများကိုသာ စီမံဆောင်ရွက်ပြီး သတ်မှတ်ချက်များနှင့် မကိုက်ညီသော အရာများကို စာရင်းအသစ်တွင် ဖယ်ထုတ်ထားသည်။

အခြေအနေပေါ်မူတည်၍ လုပ်ငန်းစဉ်ကို ပြောင်းလိုပါက သို့မဟုတ် အခြားအခြေအနေတွင်ကဲ့သို့ ကွဲပြားစွာ မကျေနပ်နိုင်သော အစိတ်အပိုင်းများကို လုပ်ဆောင်လိုပါက ternary operator ကို အသုံးပြုပါ။

Python တွင် ternary operator ကို အောက်ပါအတိုင်း ရေးသားနိုင်ပါသည်။

Value When True if Conditional Expression else Value When False

၎င်းကို အောက်ဖော်ပြပါအတိုင်း စာရင်းနားလည်မှုမှတ်စု၏ စကားရပ်တွင် အသုံးပြုသည်။

[Value When True if Conditional Expression else Value When False for Any Variable Name in Iterable Object]

ဥပမာတစ်ခုသည် ကြေငြာချက်နှင့် ညီမျှသည်။

odd_even = ['odd' if i % 2 == 1 else 'even' for i in range(10)]
print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

odd_even = []
for i in range(10):
    if i % 2 == 1:
        odd_even.append('odd')
    else:
        odd_even.append('even')

print(odd_even)
# ['even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd', 'even', 'odd']

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

အခြေအနေအား ကျေနပ်ပါက၊ အချို့သော စီမံဆောင်ရွက်မှု ပြီးသွားသည်၊ သို့မဟုတ်ပါက မူရင်းထပ်၍ရနိုင်သော အရာဝတ္ထု၏ တန်ဖိုးသည် မပြောင်းလဲဘဲ ကျန်နေပါသည်။

odd10 = [i * 10 if i % 2 == 1 else i for i in range(10)]
print(odd10)
# [0, 10, 2, 30, 4, 50, 6, 70, 8, 90]

zip() နှင့် enumerate() တို့ဖြင့် ပေါင်းစပ်ခြင်း

ကြေငြာချက်အတွက် မကြာခဏအသုံးပြုလေ့ရှိသော အသုံးဝင်သောလုပ်ဆောင်ချက်များတွင် အများအပြားထပ်၍မရနိုင်သော zip() နှင့် ၎င်း၏အညွှန်းနှင့်အတူ တန်ဖိုးတစ်ခုကို ပြန်ပေးသည့် enumerate() တို့ပါဝင်သည်။

စာရင်းနားလည်မှုအမှတ်အသားဖြင့် zip() နှင့် enumerate() ကိုသုံးနိုင်သည်။ ၎င်းသည် အထူးအထားအသိုမဟုတ်သော်လည်း for statement နှင့် စာပေးစာယူကို ထည့်သွင်းစဉ်းစားပါက ခက်ခဲမည်မဟုတ်ပေ။

zip() ၏ ဥပမာ။

l_str1 = ['a', 'b', 'c']
l_str2 = ['x', 'y', 'z']

l_zip = [(s1, s2) for s1, s2 in zip(l_str1, l_str2)]
print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

l_zip = []
for s1, s2 in zip(l_str1, l_str2):
    l_zip.append((s1, s2))

print(l_zip)
# [('a', 'x'), ('b', 'y'), ('c', 'z')]

enumerate() ၏ ဥပမာ။

l_enu = [(i, s) for i, s in enumerate(l_str1)]
print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

l_enu = []
for i, s in enumerate(l_str1):
    l_enu.append((i, s))

print(l_enu)
# [(0, 'a'), (1, 'b'), (2, 'c')]

if ကိုသုံးတဲ့ အခါ အရင် က စိတ်ကူး အတိုင်းပါပဲ။

l_zip_if = [(s1, s2) for s1, s2 in zip(l_str1, l_str2) if s1 != 'b']
print(l_zip_if)
# [('a', 'x'), ('c', 'z')]

ဒြပ်စင်အသစ်တစ်ခုကို တွက်ချက်ရန်အတွက်လည်း ဒြပ်စင်တစ်ခုစီကို အသုံးပြုနိုင်သည်။

l_int1 = [1, 2, 3]
l_int2 = [10, 20, 30]

l_sub = [i2 - i1 for i1, i2 in zip(l_int1, l_int2)]
print(l_sub)
# [9, 18, 27]

nested list တွင်ပါဝင်သည့် သင်္ကေတ

ကွင်းဆက်များအတွက် nesting ကဲ့သို့၊ list comprehension notation ကိုလည်း nested လုပ်နိုင်ပါသည်။

[Expression for Variable Name 1 in Iterable Object 1
    for Variable Name 2 in Iterable Object 2
        for Variable Name 3 in Iterable Object 3 ... ]

အဆင်ပြေစေရန်အတွက်၊ စာကြောင်းခွဲခြင်းနှင့် ကုဒ်များထည့်ထားသော်လည်း သဒ္ဒါအတွက် မလိုအပ်ပါ။ တစ်ကြောင်းတည်းနဲ့ ဆက်လို့ရပါတယ်။

ဥပမာတစ်ခုသည် ကြေငြာချက်နှင့် ညီမျှသည်။

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

flat = [x for row in matrix for x in row]
print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

flat = []
for row in matrix:
    for x in row:
        flat.append(x)

print(flat)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

များစွာသော variable များကိုလည်း အသုံးပြုနိုင်သည်။

cells = [(row, col) for row in range(3) for col in range(2)]
print(cells)
# [(0, 0), (0, 1), (1, 0), (1, 1), (2, 0), (2, 1)]

အခြေအနေအရ အကိုင်းအခက်များကိုလည်း ပြုလုပ်နိုင်သည်။

cells = [(row, col) for row in range(3)
         for col in range(2) if col == row]
print(cells)
# [(0, 0), (1, 1)]

ထပ်ကာထပ်ကာ ပြုလုပ်နိုင်သော အရာတစ်ခုစီအတွက် အခြေအနေအရ ကိုင်းဆက်ရန်လည်း ဖြစ်နိုင်သည်။

cells = [(row, col) for row in range(3) if row % 2 == 0
         for col in range(2) if col % 2 == 0]
print(cells)
# [(0, 0), (2, 0)]

inclusion notation သတ်မှတ်ပါ။(Set comprehensions)

စတုရန်းကွင်းစကွက်များ [] ကို list comprehension notation တွင် curly brackets {} သို့ပြောင်းခြင်းသည် set (set-type object) ကို ဖန်တီးသည်။

{Expression for Any Variable Name in Iterable Object}

s = {i**2 for i in range(5)}

print(s)
# {0, 1, 4, 9, 16}

အဘိဓာန်တွင် ထည့်သွင်းဖော်ပြချက်(Dict comprehensions)

အဘိဓာန်များ (သတ်ပုံအမျိုးအစားအရာဝတ္ထုများ)ကိုလည်း နားလည်သဘောပေါက်သော အမှတ်အသားဖြင့် ထုတ်ပေးနိုင်သည်။

{}၊ နှင့် စကားရပ်အပိုင်းရှိ သော့နှင့်တန်ဖိုးကို သော့-တန်ဖိုးအဖြစ် သတ်မှတ်ပါ။

{Key: Value for Any Variable Name in Iterable Object}

မည်သည့် expression ကိုမဆို key နှင့် value အတွက် သတ်မှတ်နိုင်ပါသည်။

l = ['Alice', 'Bob', 'Charlie']

d = {s: len(s) for s in l}
print(d)
# {'Alice': 5, 'Bob': 3, 'Charlie': 7}

သော့များနှင့် တန်ဖိုးများစာရင်းမှ အဘိဓာန်အသစ်ဖန်တီးရန် zip() လုပ်ဆောင်ချက်ကို အသုံးပြုပါ။

keys = ['k1', 'k2', 'k3']
values = [1, 2, 3]

d = {k: v for k, v in zip(keys, values)}
print(d)
# {'k1': 1, 'k2': 2, 'k3': 3}

မီးစက်အမျိုးအစား(Generator expressions)

စာရင်းရှိ စတုရန်းကွင်းပိတ်များ [] ကို နားလည်နိုင်စွမ်းရှိသော အမှတ်အသားကို အဝိုင်းကွင်းကွင်း () အဖြစ် အသုံးပြုပါက၊ ဂျင်နရေတာအား tuple အစား ပြန်ပေးသည်။ ဒါကို Generator expressions လို့ခေါ်ပါတယ်။

စာရင်းနားလည်မှုမှတ်စု၏ ဥပမာ။

l = [i**2 for i in range(5)]

print(l)
# [0, 1, 4, 9, 16]

print(type(l))
# <class 'list'>

Generator expression ၏ ဥပမာ။ အကယ်၍ သင်သည် print() ဂျင်နရေတာကဲ့သို့ပင်ဖြစ်ပါက၊ ၎င်းသည် ၎င်း၏အကြောင်းအရာများကို print ထုတ်မည်မဟုတ်သော်လည်း၊ သင်သည် ၎င်းကို for statement ဖြင့် run ပါက အကြောင်းအရာများကို သင်ရရှိနိုင်မည်ဖြစ်သည်။

g = (i**2 for i in range(5))

print(g)
# <generator object <genexpr> at 0x10af944f8>

print(type(g))
# <class 'generator'>

for i in g:
    print(i)
# 0
# 1
# 4
# 9
# 16

Generator expressions များသည် conditional branching နှင့် nesting ကို if နှင့် list comprehension notation ကို အသုံးပြု၍လည်း ခွင့်ပြုပါသည်။

g_cells = ((row, col) for row in range(0, 3)
           for col in range(0, 2) if col == row)

print(type(g_cells))
# <class 'generator'>

for i in g_cells:
    print(i)
# (0, 0)
# (1, 1)

ဥပမာအားဖြင့်၊ အကယ်၍ list comprehension notation ကိုသုံးပြီး list comprehension notation ကို အသုံးပြုပြီး ကိန်းဂဏန်းတစ်ခုနဲ့ လှည့်ပတ်နေပါက၊ list comprehension notation ကိုအသုံးပြုပါက၊ list comprehension notation ကိုအသုံးပြုပါက အစတွင် element များအားလုံးပါဝင်သော list ကိုထုတ်ပေးမည်ဖြစ်ပါသည်။ အခြားတစ်ဖက်တွင်၊ သင်သည် generator expression ကိုအသုံးပြုပါက၊ loop ကိုထပ်ခါတလဲလဲလုပ်တိုင်း element များကိုတစ်ခုပြီးတစ်ခုထုတ်ပေးသည်၊ ထို့ကြောင့်အသုံးပြုသော memory ပမာဏကိုလျှော့ချသည်။

generator expression သည် function ၏ တစ်ခုတည်းသော argument ဖြစ်ပါက၊ round brackets () ကို ချန်လှပ်နိုင်ပါသည်။

print(sum([i**2 for i in range(5)]))
# 30

print(sum((i**2 for i in range(5))))
# 30

print(sum(i**2 for i in range(5)))
# 30

လုပ်ဆောင်မှု မြန်နှုန်းအတွက်၊ ဒြပ်စင်အားလုံးကို စီမံဆောင်ရွက်သောအခါတွင်၊ စာရင်းနားလည်မှု အမှတ်အသားသည် ဂျင်နရေတာ အမှတ်အသားထက် မကြာခဏ မြန်ဆန်သည်။

သို့သော်လည်း၊ ဥပမာအားဖြင့် all() သို့မဟုတ် any() ဖြင့် စီရင်သောအခါ၊ ရလဒ်သည် false သို့မဟုတ် true ရှိနေသောအခါတွင် ဆုံးဖြတ်သည်၊ ထို့ကြောင့် generator expressions ကိုအသုံးပြုခြင်းသည် list comprehension notation ကိုအသုံးပြုခြင်းထက် ပိုမိုမြန်ဆန်ပေမည်။

tuple comprehension notation မရှိသော်လည်း tuple() ၏ argument အဖြစ် generator expression ကို အသုံးပြုပါက၊ comprehension notation တွင် tuple တစ်ခုကို ဖန်တီးနိုင်သည်။

t = tuple(i**2 for i in range(5))

print(t)
# (0, 1, 4, 9, 16)

print(type(t))
# <class 'tuple'>