Python Data Structure မေးခွန်းများ

List နှင့် သက်ဆိုင်သည့် မေးခွန်း (၄၅)ခုကို စုစည်းဖော်ပြထားသည်။ မေးခွန်းများသည် အတွေးတချို့ လှုံဆော်ပေးသည်။ နားလည်ထားမှုကို ပြန်လည်သုံးသပ်စေသည်။ Data Structure တွင် list သည် အများဆုံးအသုံးပြုသည် အမျိုးအစားဖြစ်သောကြောင့် list မေးခွန်းများ အဓိကပါဝင်သော်လည်း tuple, dictionary နှင့် set ဒေတာအမျိုးအစားများအကြောင်းလည်းပါဝင်သည်။

(၁) List တစ်ခုမှာ မိမိသိလိုသည့် element တစ်ခု ပါ မပါကို စစ်ဆေးပါ။
"in" operator ကို အသုံးပြု၍ စစ်ဆေးနိုင်သည်။

In [1]:
li = [1,2,3, 'a', 'b', 'c']
'a' in li  #True
Out[1]:
True

၂။ List (၂) ခုထက် ပိုများတဲ့ List တွေကို တပြိုင်နက် ဘယ်လို iterate မလဲ
List နှစ်ခု သို့မဟုတ် (၃)ခုကို အတွင်းရှိ item များကို တစ်ပြိုင်နက် iterate လုပ်ရန်အတွက် zip() ရပါမည်။ အောက်တွင် list (၃)ခုကို zip() method ဖြင့် အတူတွဲပြီးနောက် for loop ဖြင့် iterate လုပ်ပါသည်။

In [2]:
name = ['Snowball', 'Chewy', 'Bubbles', 'Gruff']
animal = ['Cat', 'Dog', 'Fish', 'Goat']
age = [1, 2, 2, 6]
z = zip(name, animal, age)
z
Out[2]:
<zip at 0x5b1de48>
In [3]:
for name,animal,age in z:
    print("%s the %s is %s" % (name, animal, age))

Snowball the Cat is 1
Chewy the Dog is 2
Bubbles the Fish is 2
Gruff the Goat is 6

(၃) ဘယ်လိုနေရာမှာ dictionaryကို အသုံးပြုမလဲ။ ဘယ်လိုနေရာမှာ list ကို အသုံးပြုမလဲ။
List - ဒေတာများကို သိမ်းထားသည့် နေရာ အစီအစဉ်(order)နှင့်တကွ သိမ်းဆည်းရန်လိုအပ်ပါက list ကို သုံးပါ။
Dictionary - ဒေတာများ၏ သိမ်းထားသည့် နေရာ အစီအစဉ်(order) ကို မလိုအပ်ဘဲ key နှင့် value များကို တွဲ၍ သိမ်းထားလိုပါက သုံးပြုပါ။ ဥပမာ-အိမ်မွေး နာမည်(key)နှင့် တိရစ္ဆာန် အကောင်အရေအတွက်(value)ကို တွဲ၍ သိမ်းထားရန် dictionary ကို သုံးသည်။

In [4]:
ids = [23,1,7,9]
print(ids)
pets = {'dogs':2,'cats':1,'fish':5}
print(pets)

[23, 1, 7, 9]
{'dogs': 2, 'cats': 1, 'fish': 5}

(၄) List ထဲတွင် ပါဝင်နေသည့် item များကို ပြင်ရန် ပြောင်းရန် ဖြစ်နိုင်ပါသလား?( Is a list mutable?)
Yes.

(၅) List ထဲတွင် မတူညီသည့် ဒေတာအမျိုးအစား ထည့်ထားရန် ဖြစ်နိုင်ပါသလား။
တစ်မျိုးတည်း(homogeneous)သာ ဖြစ်ရပါမည်လား?
အမျိုးအစားများမတူသော ဒေတာများ(different types of object)ကို list တစ်ခုထဲတွင် list အတူတကွ ရောထွေး သိမ်းဆည်းနိုင်ပါသည်။ List ထဲတွင် တခြားသော list များကို ထပ်ထည့်ထားလို့ရသည်။

In [5]:
a = [1, 'a', 3.517 , [] ] # 1 သည် integer အမျိုးအစား၊ 'a' သည် string ၊ 3.517 သည် floatဒေတာအမျိုးအစား ဖြစ်သည်။

(၆) append နှင့် extend တို့၏ ခြားနားချက်ကို ရှင်းပြပါ။?
.append() သည် ထည့်ခိုင်းသည့် item ကို list ၏ နောက်ဆုံးနေရာတွင် ထည့်သည်။ (adds an object to the end of a list.)

In [6]:
a = [1,2,3]
a.append(4)
a
Out[6]:
[1, 2, 3, 4]

တခြားသော list တစ်ခုကို single element အဖြစ်သတ်မှတ်ပြီး list တစ်ခု ထဲသို့ ထည့်နိုင်သည်။

In [7]:
a.append([5,6])
a
Out[7]:
[1, 2, 3, 4, [5, 6]]

.extend() ကို သုံး၍ list တစ်ခု ထဲသို့ တခြားသော list တစ်ခုကို ထည့်သည့်အခါ (extend လုပ်သည့်အခါ) single element အဖြစ်ရောက်မသွားလဲ ဒုတိယ list များ element များအားလုံးသည် element တစ်ခုချင်းစီအဖြစ် ဝင်ရောက်သွားသည်။

In [8]:
b = [1,2,3]
b.extend([5,6])
b #=> [1, 2, 3, 5, 6]
Out[8]:
[1, 2, 3, 5, 6]

(၇) Python list သည် တန်ဖိုးများကို သိမ်ဆည်းပါသလား? Pointer ကို သိမ်းဆည်းပါလား?
Python list သည် တန်ဖိုးများကို မသိမ်းဆည်းပါ။ List ထဲတွင် value များကို သိမ်းဆည်းထားသည့် မှတ်ဉာဏ်(memory) နေရာကို ညွှန်ပြသည့် pointer များကိုသာ သိမ်းဆည်းထားသည်။ ထိုသို့ memory နေရာကို ညွှန်ပြသည့် pointer များကိုသာ သိမ်းဆည်းထားသောကြောင့် ပြင်နိုင် ပြောင်းနိုင်ခြင်းဖြစ်သည်။ (mutable ဖြစ်သည်။)

Value များ ဖြစ်သည့် integer 1 နှင့် 2 တို့၏ initialize လုပ်ပြီး identity (unique integer) ဖတ်ယူသည်။ ထို့နောက် integer 1 နှင့် 2 ပါသည့် list တစ်ခုကို တည်ဆောက်သည်။ List ၏ နေရာများ၏ identity (unique integer) ဖတ်ယူသည်။

In [9]:
print( id(1) ) #The id() function returns identity (unique integer) of an object.
print( id(2) ) #object တစ်ခု၏ identity (unique integer)ကို သိလိုပါက id() function ကို အသုံးပြုရသည်။ 

8791073067840
8791073067872
In [10]:
a = [1,2,3]
print( id(a) ) 
print( id(a[0]) )
print( id(a[1]) ) 

94647816
8791073067840
8791073067872

List တွင် ကိုယ်ပိုင် memory address ရှိသည်။ (list has its own memory address)။ List အတွင်းရှိ integer 1 နှင့် 2 သည် memory ပေါ်တွင် ရှိသည့် integer 1 နှင့် 2 သိမ်းထားသည့်နေရာကို ညွှန်ပြ(point လုပ်)သည်။ ထို့ကြောင့် list တွင် value များကို သိမ်းဆည်းထားသည့်မှတ်ဉာဏ် (memory) နေရာကို သိမ်းဆည်းထားသည်။

(၈) Del ကို မည်ကဲ့သို့ သုံးမည်နည်း?
list ထဲမှ ဖယ်ထုတ်လိုသည့် item များကို index နံပါတ်ပေး၍ ဖျက်ဖြစ်နိုင်သည်။ del a[:] သည် item အားလုံးကို ဖျက်ပေး(delete လုပ်) ပေးသည်။

In [11]:
a = ['w', 'X', 'y', 'z']
print(a)
del a[1]
print(a)

['w', 'X', 'y', 'z']
['w', 'y', 'z']

Del သည် ဖယ်ထုတ်လိုက်သည့် item ကို ပြန်မပေးပါ။ (does not return the removed element)
(၉) “remove” နှင့် “pop” တို့၏ ကွာခြားချက်ကို ရှင်းပြပါ။
.remove () သည် ဖယ်ထုတ်လိုသည့် item များထဲမှ ပထမဆုံးတွေ့သည့် index နံပါတ်(အနည်းဆုံး)ကို ဖယ်ထုတ် ပေးသည်။(.remove() removes the first instance of a matching object) ဥပမာ - အောက်တွင် ပထမဆုံးတွေ့သည့် b ကို ဖယ်ထုတ်သည်။

In [12]:
a = ['a', 'a', 'b', 'c', 'c', 'b', 'd', 'e']
print(a)
a.remove('b')
print(a)

['a', 'a', 'b', 'c', 'c', 'b', 'd', 'e']
['a', 'a', 'c', 'c', 'b', 'd', 'e']

.pop() သည် index နံပါတ်အတိုင်း ဖယ်ရှားပေးပါသည်။ (removes an object by its index)။ “remove” နှင့် “pop” တို့၏ ကွာခြားချက်မှာ pop သည့် ဖယ်ရှားလိုက်သည့် element ကို ပြန်ပေးသည်။ ထို element ကို သိနိုင်သည်။ (pop returns the popped element)

In [13]:
a = ['a', 'a', 'b', 'b', 'c', 'c']
a.pop(4) 
print(a)
print(a.pop(4) ) #pop returns the popped element

['a', 'a', 'b', 'b', 'c']
c

.pop()ကို သုံး၍ element ဖယ်ထုတ်သည့်အခါ index နံပါတ်ကို ထည့်မပေးပါက နောက်ဆုံးမှ element ကို ဖယ်ရှားသည်။ (By default, pop removes the last element from a list if an index isn’t specified.)

(၁၀) List တစ်ခု အတွင်းမှ တူညီနေသည့်(duplicate) item များကို ဖယ်ရှားရန် မည်သို့ပြုလုပ် မည်နည်း။
List ကို set အဖြစ်ပြောင်းပါ။ ထိုအခါ list အတွင်းမှ တူညီနေသည့်(duplicate) item များကို ဖယ်ရှားပစ်လိမ့်မည်။ ထိုနောက် set အဖြစ် ပြန်ပြောင်းပါ။ (converting to a set and back to a list)။ List ၏ အစဥ(order) ကို ထိန်းသိမ်းထားရန် မဖြစ်နိုင်ပါ။

In [14]:
li = [3, 2, 2, 1, 1, 1]
list(set(li)) #=> [1, 2, 3]
Out[14]:
[1, 2, 3]

(၁၁) List တစ်ခုအတွင်းသို့ ရှာလိုသည့် element တစ်ခု ထည့်ပေးပြီး ပထမဆုံးတွေ့သည့် element ၏ index နံပါတ်ကို ရှာပါ။ (Find the index of the 1st matching element)
.index() method ကိုသုံး၍ ရှာသည်။

In [15]:
fruit = ['pear', 'orange', 'apple', 'grapefruit', 'apple', 'pear']
fruit.index('apple') #''apple'နှစ်ခုတွင် ပထမဆုံးတွေ့သည့် index နံပါတ်ကို ပေးသည်။
Out[15]:
2
In [16]:
fruit.index('pear') # pear' နှစ်ခုတွင် ပထမဆုံးတွေ့သည့် index နံပါတ်ကို ပေးသည်။
Out[16]:
0

(၁၂) List တစ်ခုအတွင်း element များ အားလုံးကို ဖယ်ရှားပါ။
.clear() method ကိုသုံး၍ list တစ်ခုအတွင်း element များ အားလုံးကို ဖယ်ရှားနိုင်သည်။ empty list အဖြစ် ကျန်ခဲ့လိမ့်မည်။

In [17]:
fruit = ['pear', 'orange', 'apple']
print( fruit )       # ['pear', 'orange', 'apple']
print( id(fruit) ) # list id()

['pear', 'orange', 'apple']
95541256
In [18]:
fruit.clear()
print( fruit )     # empty list
print( id(fruit) ) # list id()

[]
95541256

Del ကို သုံး၍လည်း list တစ်ခုအတွင်း element များ အားလုံးကို ဖျက်နိုင်သည်။

In [19]:
fruit = ['pear', 'orange', 'apple']
print( fruit )     #=> ['pear', 'orange', 'apple']
print( id(fruit) ) #=> 4581166792

['pear', 'orange', 'apple']
47386312
In [20]:
del fruit[:]
print( fruit )     #=> []
print( id(fruit) ) #=> 4581166792

[]
47386312

(၁၃) List တစ်ခုအတွင်းရှိ item များအားလုံး၏ value နှင့် ၎င်းတို့၏ နံပါတ်များ(their indices)ကို ဖော်ပြပါ။ Iterate လုပ်ပါ။

enumerate() သည် List တစ်ခုအတွင်း သို့ဝင်ရောက်လာသည့် argument မျာကို ရေတွက်ပေးသည်။ (enumerate() adds a counter to the list passed as an argument.)။ List တစ်ခု၏ value နှင့် index နှစ်မျိုးလုံးကို ထည့်၍ iterate လုပ်သည်။

In [21]:
grocery_list = ['flour','cheese','carrots']
for idx,val in enumerate(grocery_list):
    print("%s : %s" % (idx, val))

0 : flour
1 : cheese
2 : carrots

(၁၄) List နှစ်ခုကို ဆက်ပါ။

+ operator ကိုသုံး၍ list နှစ်ခုကို ဆက်နိုင်သည်။ Concatenate လုပ်နိုင်သည်။

In [22]:
one = ['a', 'b', 'c']
two = [1, 2, 3]
one + two #=> ['a', 'b', 'c', 1, 2, 3]
Out[22]:
['a', 'b', 'c', 1, 2, 3]

List နှစ်ခုတည်းသာမက နှစ်ခုထက်ပိုများသည့် list များကိုလည်း ဆက်နိုင်သည်။ concatenate လုပ်နိုင်သည်။

In [23]:
one = ['a', 'b', 'c']
two = [1, 2, 3]
three = ['x', 'y', 'z']
one + two + three
Out[23]:
['a', 'b', 'c', 1, 2, 3, 'x', 'y', 'z']

(၁၅) List comprehension နည်းဖြင့် list တစ်ခုအတွင်းရှိ element များကို ပေါင်း၊ နုတ်၊ မြှောက် စားလုပ်ပါ။ (manipulate ပါ။)
အောက်တွင် list တစ်ခုအတွင်းရှိ ကိန်းများကို တစ်ပေါင်း၍ list အသစ် တစ်ခုတည်ဆောက်ထားပုံကို ဥပမာ ပြထားသည်။

In [24]:
li = [0,25,50,100]
[i+1 for i in li]
Out[24]:
[1, 26, 51, 101]

(၁၆) List တစ်ခုအတွင်းရှိ object တစ်ခု ပါဝင်နေသည့် အကြိမ်အရေအတွက်(occurrence of a specific object)ကို ရှာပါ။
count() method ဖြင့် list တစ်ခုအတွင်းရှိ object တစ်ခု ပါဝင်နေသည့် အကြိမ်အရေအတွက်(occurrence of a specific object)ကို ရှာနိုင်သည်။ Pets ဆိုသည့် list ထဲတွင် “fish” ဆိုသည့် object ပါရှိသည့် အကြိမ် အရေအတွက်ရှာပုံကို ဥပမာ ပြထားသည်။

In [25]:
pets = ['dog','cat','fish','fish','cat']
pets.count('fish')
Out[25]:
2

(၁၇) List တစ်ခုကို shallow copy ကော်ပီကူးပါ။
.copy() ကိုသုံး၍ list ကို shallow copy ကူးနိုင်သည်။ အောက်တွင် round2 သည် round1 ၏ shallow copy ဖြစ်သည်။ round2 ထဲမှ string sonny chiba. ကို ဖယ်ထုတ်(remove)သည်။ shallow copy မရှိလျှင် round1 နှင့် round2 တို့သည် memory ပေါ်တွင်ရှိသည့် list တစ်ခုတည်း၏ နေရာကို ညွှန်ပြနေကြလိမ့်မည်။ (round1 and round2 are just names pointing to the same list in memory.) အောက်တွင် round2 သည် round1 ၏ shallow copy ဖြစ်သည်။

In [26]:
round1 = ['chuck norris', 'bruce lee', 'sonny chiba']
round2 = round1
round2.remove('sonny chiba')
print(round1) #=> ['chuck norris', 'bruce lee']
print(round2) #=> ['chuck norris', 'bruce lee']

['chuck norris', 'bruce lee']
['chuck norris', 'bruce lee']

(၁၈) List နှင့် tuple ရဲ့ ကွာခြားချက်က ဘာတွေလဲ
Tuple ကို pdate လုပ်လို့မရပါ. Adding/removing/updating လုပ်လို့ရပါ။ Lists တွေကို modifiy လုပ်လို့ရပါတယ်။ List နှင့် tuple နှစ်ခုစလုံးက sequence တွေဖြစ်ကြပြီး value တူ တွေကို လက်ခံပါတယ်။ (allow duplicate values)

(၁၉) List တစ်ခုရဲ့ အရှည် သို့မဟုတ် list တစ်ခုထဲမှာ ပါတဲ့ ကိန်းအရေအတွက်ကို ဘယ်လို ရှာမလဲ။

Len() ဖြင့် list တစ်ခုရဲ့ အရှည် သို့မဟုတ် list တစ်ခုထဲမှာ ပါတဲ့ ကိန်းအရေအတွက်(length of a list)ကို ရှာနိုင်သည်။

In [27]:
li = ['a', 'b', 'c', 'd', 'e']
len(li)
Out[27]:
5

Top level object တွေကိုပဲ ရေတွက်သည်ကို သတိပြုပါ။ Nested list ဖြစ်လျှင် sub-list အတွင်းရှိ item များကို မရေတွက်ပါ။

In [28]:
li = [[1,2],[3,4,5]]
len(li)
Out[28]:
2

(၂၀) List နှင့် set တို့၏ ကွာခြားချက်ကို ပြောပါ။

List တွင် order သည် အရေးကြီးသည်။ List ၏ အသက်သည် order ဖြစ်သည်။ Duplicate item များကို ခွင့်ပြုသည်။
Set တွင် order သည် အရေးမကြီးသည့်အရာ ဖြစ်သည်။ Unique value များကိုသာ သိမ်းဆည်းပေးသည်။ Duplicate item များကို ခွင့်မပြုပါ။

(၂၁) List တစ်ခုအတွင်း၌ မိမိသိလိုသည့် element တစ်ခု ရှိ မရှိ ဘယ်လိုစစ်မလဲ။

in" operator ကို အသုံးပြု၍ စစ်နိုင်သည်။

In [29]:
li = [1,2,3,4]
print(5 not in li) #=> True
print(4 not in li) #=> False

True
False

(၂၂) List တစ်ခုအတွင်းရှိ element များအားလုံးကို (၅)ဆ တိုးထားသည့် list အသစ်တစ်ခု တည်ဆောက်ပါ။

In [30]:
numbers = [1, 2, 3, 4, 5] # ပေးထားသည့် list 
new_list = [ ]        # (၅)ဖြင့် မြှောက်ထားသည့်ကိန်းများ ထည့်ရန်( append လုပ်ရန်) တည်ဆောက်ထားသည့် empty list
for number in numbers: 
    new_list.append(5 * number) # ကိန်းတစ်လုံးချင်းကို (၅)ဖြင့် မြှောက်သည်။ 
print(new_list)

[5, 10, 15, 20, 25]

(၂၃) List နှစ်ခုမှ item များကို တစ်ခုချင်းစီတွဲပြီး item နှစ်ခုပါသည့် tuple များတည်ဆောက်ပါ။ ထို့နောက် tuple များပါသည့် list အသစ်တစ်ခု တည်ဆောက်ပြပါ။

zip() သည် sequence များစွာထဲမှ item များကို တစ်ခုချင်းစီတွဲပြီး tuple တစ်ခု အဖြစ်တည်ဆောက်ပေးနိုင်သည်။(တူညီသည့် index နံပါတ်များမှ value များကိုတွဲပြီး)။

In [31]:
alphabet = ['a', 'b', 'c']
integers = [1, 2, 3]
list(zip( integers,  alphabet))
Out[31]:
[(1, 'a'), (2, 'b'), (3, 'c')]
In [32]:
list(zip(alphabet, alphabet))
Out[32]:
[('a', 'a'), ('b', 'b'), ('c', 'c')]
In [33]:
list(zip(alphabet, integers))
Out[33]:
[('a', 1), ('b', 2), ('c', 3)]
In [34]:
alphabet = ['a', 'b', 'c']
integers = [1, 2, 3]
alphabet2 = ['x', 'y', 'z']
list(zip(integers,alphabet, alphabet2))
Out[34]:
[(1, 'a', 'x'), (2, 'b', 'y'), (3, 'c', 'z')]

(၂၄) List တစ်ခုအတွင်းမှ မိမိအလိုရှိသည့် index နံပါတ်တစ်ခုတွင် မိမိအလိုရှိသည့် value ထည့်သွင်းပါ။
List တစ်ခုအတွင်းမှ မိမိအလိုရှိသည့် index နံပါတ်တစ်ခုတွင် မိမိအလိုရှိသည့် value ထည့်သွင်းပါ။ ထိုသို့ထည့်သွင်းလိုက်ခြင်းကြောင့် အရင်နေရာဟောင်းမှ value သည် နောက်သို့ ရွှေ့သွားသည်။ မိမိအလိုရှိသည့် value တန်ဖိုးကို list အတွင်းသို့ index နံပါတ်မှ တစ်ဆင့် ထည့်သည်။ insert() method ကို သုံးသည့်အခါ ထည့်မည့်နေရာ၏ index နံပါတ် နှင့် ထို့နေရာတွင်ထည့်မည့် value ကို ထည့်ပေးရသည်။ Overwritten လုပ်လိုက်ခြင်း မဟုတ်ပါ။ Insert လုပ်ခြင်းကြောင့် ကိန်းအလုံးရေ(length) ပိုတိုးလာလိမ့်မည်။

In [35]:
li = ['a','b','c','d','e']
li.insert(2, 'HERE')
li #=> ['a', 'b', 'HERE', 'c', 'd', 'e']
Out[35]:
['a', 'b', 'HERE', 'c', 'd', 'e']

(၂၅) reduce() function ကို သုံး၍ list ထဲမှ value များကို subtract လုပ်ပါ။

In [36]:
from functools import reduce
def subtract(a,b):
    return a - b

numbers = [100,10,5,1,2,7,5]
reduce(subtract, numbers) #=> 70
Out[36]:
70

(၂၆) List တစ်ခုထဲမှ အနုတ်ကိန်းများကို ဖယ်ထုတ်ပါ။

In [37]:
numbers = [-10, 27, 1000, -1, 0, -30] # ပေးထားသည့် list 
positive_number = [ ]        # ပေါင်းကိန်းများ ထည့်ရန်( append လုပ်ရန်) တည်ဆောက်ထားသည့် empty list
for number in numbers: 
    if number >= 0:              # ကိန်းတစ်လုံးချင်းကို ပေါင်းကိန်း ဖြစ် မဖြစ် စစ်သည်။ 
        positive_number.append(number) # ေါင်းကိန်း ဖြစ်လျှင် positive_number  list ထဲသို့ထည့်သည်။ 
print(positive_number)

[27, 1000, 0]

(၂၇) List ထဲမှ element များကို key အဖြစ်ထားပြီး dictionary အဖြစ်သို့ ပြောင်းပါ။
Dictionary comprehension နည်းကို အသုံးပြုသည်။

In [38]:
li = ['The', 'quick', 'brown', 'fox', 'was', 'quick']
d = {k:1 for k in li}
d #=> {'The': 1, 'quick': 1, 'brown': 1, 'fox': 1, 'was': 1}
Out[38]:
{'The': 1, 'quick': 1, 'brown': 1, 'fox': 1, 'was': 1}

(၂၈) Lambda function သုံး၍ ပေးထားသည့် list ထဲရှိ item များကို (၅)ဆတိုး၍ modify လုပ်ပါ။
map function ကို အသုံးပြုသည်။

In [39]:
a = [10,20,30,40,50]
list(map(lambda val:val*5, a))
#=> [50, 100, 150, 200, 250]
Out[39]:
[50, 100, 150, 200, 250]

(၂၉) သတ်မှတ်ထားသည့်(specific) index နံပါတ်၏ နောက်ပိုင်းမှ element များကို ဖယ်ရှားပစ်ပါ။ (Remove elements in a list after a specific index)
slice syntax ကို သုံး၍ list အသစ်တစ်ခုတည်ဆောက်သည်။ သတ်မှတ်ထားသည့်(specific) index နံပါတ်အထိသာ ပါသည်။ "li[:10]" သည် အစဆုံးမှာ item နံပါတ် 10 အထိ ဖြစ်သည်။

In [40]:
li = [0, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,10]
li[:10]
#=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Out[40]:
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

(၃၀) သတ်မှတ်ထားသည့်(specific) index နံပါတ်၏ အရှေ့မှ element များကို ဖယ်ရှားပစ်ပါ။ (Remove elements in a list before a specific index)
slice syntax ကို သုံး၍ list အသစ်တစ်ခုတည်ဆောက်သည်။ သတ်မှတ်ထားသည့်(specific) index နံပါတ်ကို start နေရာတွင်ထည်ပေးရသည်။ index နံပါတ် 15 နောက်ပိုင်း "li[15:]" element များအာလုံးကို ယူသည်။

The slice syntax can also return a new list with the values after a specified index.

In [41]:
li = [0, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,10]
li[15:]
Out[41]:
[15, 16, 17, 18, 19, 10]

(၃၁) ငယ်ရာမှ ကြီးရာသို့ စဥပါ။ (Sort a list of integers in ascending order)
sort() method ကိုသုံး၍ ငယ်ရာမှ ကြီးရာသို့(ascending order) စဥသည်။

In [42]:
li = [10,1,9,2,8,3,7,4,6,5]
li.sort()
li
Out[42]:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(၃၂) ကြီးရာမှ ငယ်ရာသို့ စဥပါ။ (Sort a list of integers in descending order)
It’s also possible to sort in descending order with sort() by adding the argument reverse=True ကို သုံး၍ ပြောင်းပြန်းစဥ နိုင်သည်။ ငယ်ရာမှ ကြီးရာသို့(ascending order) သည် default ဖြစ်သောကြောင့် ထည့်ရေးရန် မလိုပါ။

In [43]:
 li = [10,1,9,2,8,3,7,4,6,5]
li.sort(reverse=True)
li
Out[43]:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

(၃၃) List comprehension နည်းကို သုံး၍ စုံကိန်းများကို ယူပြီး list အသစ်တစ်ခု တည်ဆောက်ပါ။

Filter လုပ်ရန်အတွက် list comprehension ထဲတွင် conditional logic ထည့်ရေးသည်။ စုံကိန်းများကိုသာ ရွှေးထုတ်ရန် (၂)ဖြင့်စား(divisible by 2) ပြီး အကြွင်း သုညဖြစ်သည့်ကိန်းကိုသာ ယူသည်။

In [44]:
li = [1,2,3,4,5,6,7,8,9,10]
[i for i in li if i % 2 != 0]
Out[44]:
[1, 3, 5, 7, 9]

(၃၄) Value တစ်ခုချင်းစီ၏ ပါဝင်သည့် အကြိမ်အရေအတွက်ကို ရေတွက်ပါ။ (Count occurrences of each value in a list)
အလွယ်ဆုံးနည်းမှ collections module မှ counter class ကို import လုပ်၍ အသုံးပြုခြင်း ဖြစ်သည်။

In [45]:
li = ['blue', 'pink', 'green', 'green', 'yellow', 'pink', 'orange']
from collections import Counter  # import counter class from collections module 
print(Counter(li))

Counter({'pink': 2, 'green': 2, 'blue': 1, 'yellow': 1, 'orange': 1})

(၃၅) Nested list အတွင်းရှိ list များ၏ index နံပါတ် သုည(first element)ကို ယူ၍ list အသစ်တစ်ခု တည်ဆောက်ပါ။

In [46]:
li = [[1,2,3],[4,5,6],[7,8,9],[10,11,12],[13,14,15]] 
[i[0] for i in li]
Out[46]:
[1, 4, 7, 10, 13]

(၃၆) List အတွင်းရှိ element များကို string တစ်ခု အဖြစ် ပြောင်းပါ။ (Combine elements in a list into a single string.)
.join() ကို သုံးသည်။ join လုပ်သည့်အခါ element တစ်ခုနှင့် တစ်ခု အကြား space တစ်နေရာစာ ခြားလိုသောကြောင့် ' ' ထည့်ပေးသည်။

In [47]:
li = ['The','quick','brown', 'fox', 'jumped', 'over', 'the', 'lazy', 'dog']
' '.join(li)
Out[47]:
'The quick brown fox jumped over the lazy dog'

(၃၇) List တစ်ခုကို integer တစ်ခုနှင့် မြှောက်ပါ။

List တစ်ခုကို integer တစ်ခုနှင့် မြှောက်ခြင်းကို multiple concatenation ဟုခေါ်သည်။ (၅)နှင့် မြှောက်သည်။

In [48]:
['a','b'] * 5
Out[48]:
['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']
In [49]:
#   (၅)ခါပေါင်းခြင်းနှင့် တူညီသည်။ 
['a','b'] + ['a','b'] + ['a','b'] + ['a','b'] + ['a','b']
#=> ['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']
Out[49]:
['a', 'b', 'a', 'b', 'a', 'b', 'a', 'b', 'a', 'b']

(၃၈) List တစ်ခု၏ item အစဥ များကို ပြောင်းပြန်လှန်ပါ။ (Reverse the order of a list)
reverse() method ကို အသုံးပြု၍ item အစဥ များကို ပြောင်းပြန်လှန်နိုင်သည်။ object အသစ်တခု ပြုလုပ်ပေးခြင်း မဟုတ်သည်ကို သတိပြုပါ။

In [50]:
li = [1,2,3,4,5,6,7,8,9,10]
li.reverse()
li #=> [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Out[50]:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

(၃၉) Reverse နှင့် reversed တို့၏ ခြားနားချက်
reverse()သည် item များကို ထို list အတွင်း၌သာ ပြန်စီသည်။ (reverse() reverses the list in place.)
reversed() သည် ပြန်စီထားသည့် list အသစ်တစ်ခု ပေးသည်။ returns an iterable of the list in reverse order.

In [51]:
li = [1,2,3,4,5,6,7,8,9,10]
li.reverse()
li
Out[51]:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
In [52]:
li = [1,2,3,4,5,6,7,8,9,10]
list(reversed(li))
Out[52]:
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

(၄၀)Sort နှင့် sorted တို့၏ ခြားနားချက်
sort()သည် item များကို ထို list အတွင်း၌သာ ပြန်စီ‌ ပေးသည်။ ရှိပြီးသား list ကို modify လုပ်သည်။ (modifies the list in place)
sorted() သည် ပြန်စီထားသည့် list အသစ်တစ်ခု ပေးသည်။ (returns a new list in reverse order.)

In [53]:
li = [10,1,9,2,8,3,7,4,6,5]
print(id(li))
li.sort()
print(li)
print(id(li) , "Same id")

95711560
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
95711560 Same id
In [54]:
li = [10,1,9,2,8,3,7,4,6,5]
sorted(li) #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Out[54]:
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(၄၁) List တစ်ခု အတွင်းရှိ အငယ်ဆုံးတန်ဖိုး(minimum value)ကို ဖော်ပြပါ။
min() function သည် list တစ်ခု အတွင်းရှိ အငယ်ဆုံးတန်ဖိုး(minimum value)ကို ရှာပေးသည်။
max() function သည် list တစ်ခု အတွင်းရှိ အကြီးဆုံးတန်ဖိုး(maximum value)ကို ရှာပေးသည်။
sum() function သည် ကိန်းများအားလုံး၏ ပေါင်းခြင်းတန်ဖိုး(sum of all values in a list)ကို ရှာပေးသည်။

In [55]:
li = [10,1,9,2,8,3,7,4,6,5]
print(min(li) , "minimum value of list")
print(max(li) , "maximum  value of list")
print(sum(li) , "sum of all values in a list")

1 minimum value of list
10 maximum  value of list
55 sum of all values in a list

(၄၂) List နှစ်ခု၏ intersection ကို ရှာပါ။
List နှစ်ခုကို set() အဖြစ်ပြောင်းလဲ၍ intersection လုပ်သည်။ Ampersand(&) ကို သုံးသည်။

In [56]:
li1 = [1,2,3]
li2 = [2,3,4]
set(li1) & set(li2)
Out[56]:
{2, 3}

(၄၃) Set တစ်ခုမှ တခြား set တစ်ခုကို နုတ်(difference)ပါ။
List ထဲမှ item များကို နုတ်ခြင်း ပြုလုပ်၍ မရပါ။ ထို့ကြောင့် set အဖြစ်သို့ ပြောင်းသည်။ (we can subtract sets.)

In [57]:
li1 = [1,2,3]
li2 = [2,3,4]
print(set(li1) - set(li2)) 
print(set(li2) - set(li1))

{1}
{4}

(၄၄) Sublist (list of lists) အတွင်းမှ item များအားလုံးကို ထုတ်၍ Sublist မရှိအောင် လုပ်ပါ။
Sublist (list of lists) အတွင်းမှ item များအားလုံးကို ထုတ်၍ sublist မရှိအောင် လုပ်ပါ။ ထိုသို့ ပြုလုပ်ခြင်းကို flatten လုပ်သည်ဟုခေါ်သည်။

In [58]:
li = [[1,2,3],[4,5,6]]
[i for x in li for i in x]
#=> [1, 2, 3, 4, 5, 6]
Out[58]:
[1, 2, 3, 4, 5, 6]

(၄၅) List နှစ်ခုကို ပေါင်း၍ dictionary ဖြစ်အောင်လုပ်ပါ။

zip() ကို သုံး၍ dictionary ဖြစ်အောင် ပြောင်းသည်။ list တစ်ခုမှ item များသည် key များ ဖြစ်ကြပြီး ကျန် list တစ်ခုမှ item များသည် value ဖြစ်လိမ့်မည်။

In [59]:
name = ['Snowball', 'Chewy', 'Bubbles', 'Gruff']
animal = ['Cat', 'Dog', 'Fish', 'Goat']
dict(zip(name, animal))
Out[59]:
{'Snowball': 'Cat', 'Chewy': 'Dog', 'Bubbles': 'Fish', 'Gruff': 'Goat'}

Ref: https://towardsdatascience.com/60-questions-to-test-your-knowledge-of-python-lists-cca0ebfa0582
-End-

In [ ]: