Chapter 8: List များ (Lists)

↻ ပြန်ဖွင့်ရန်

---

Array နှင့် List (Array နဲ့ List ဘာကွာလဲ)

Java, C++ လို programming language တွေမှာ array ဆိုတာ အသုံးများတဲ့ အယူအဆတစ်ခုပါ။ Array ဆိုတာ အမျိုးအစား တူညီတဲ့ အရာဝတ္ထုတွေကို စုစည်းထားတဲ့ collection တစ်ခုပါ။ ဥပမာ ကိန်းပြည့်တွေချည်းပဲ၊ ဒါမှမဟုတ် စာလုံးတွေချည်းပဲ သိမ်းထားတာမျိုးပေါ့။

ဒါပေမဲ့ Python မှာတော့ array ကို အသုံးသိပ်မများပါဘူး။ Python အသုံးပြုသူတွေက "array" လို့ ပြောရင် အများအားဖြင့် list ကိုပဲ ရည်ညွှန်းကြပါတယ်။ Python ရဲ့ list ဟာ array ထက် ပိုပြီး flexible ဖြစ်ပါတယ်။

Array (Java/C++)	Python List
အမျိုးအစား တူညီတဲ့ အရာဝတ္ထုတွေပဲ ထည့်လို့ရတယ်	အမျိုးအစား အမျိုးမျိုး ရောထည့်လို့ရတယ် (ကိန်း၊ စာသား၊ True/False အကုန်ရော)
အရွယ်အစား ကြိုသတ်မှတ်ရတတ်တယ်	အရွယ်အစား ကြိုသတ်မှတ်စရာ မလိုဘူး၊ ကြီးလာနိုင်/သေးလာနိုင်တယ်
Type တူတာကြောင့် memory သုံးစွဲမှု ထိရောက်တယ်	အသုံးပြုရတာ ပိုလွယ်ကူပြီး flexible ဖြစ်တယ်

---

List ဖန်တီးခြင်း (Creating a List)

List တစ်ခုကို ဖန်တီးတာက လွယ်ကူပါတယ်။ အရာဝတ္ထုတွေအားလုံးကို square bracket [ ] ထဲမှာ ထည့်ပြီး ကော်မာ , နဲ့ ခြားလိုက်ရုံပါပဲ။

# list အလွတ်
basket = []

# ကိန်းပြည့်တွေချည်းပဲ ပါတဲ့ list
scores = [85, 92, 78, 90, 66]

# အမျိုးအစား အမျိုးမျိုး ရောထားတဲ့ list
profile = ["Aung", 24, 5.9, True]
print(profile)

Output:

['Aung', 24, 5.9, True]

တွေ့လား? "Aung" (string)၊ 24 (int)၊ 5.9 (float)၊ True (bool) — အမျိုးအစားအမျိုးမျိုး တစ်ခုတည်း list ထဲမှာ နေနိုင်တယ်။ ဒါက Java/C++ array နဲ့ အကြီးဆုံး ကွာခြားချက်ပါပဲ။

---

Index ဖြင့် အရာဝတ္ထုများကို ရယူခြင်း (Indexing)

List ထဲက အရာဝတ္ထု တစ်ခုချင်းစီကို index နဲ့ ခေါ်ထုတ်နိုင်ပါတယ်။ Index ဆိုတာ အရာဝတ္ထုရဲ့ နေရာနံပါတ်ပါ။ Python မှာ index က 0 ကနေ စတယ် ဆိုတာ မမေ့ပါနဲ့။ အရာဝတ္ထု ၅ ခု ပါတဲ့ list ဆိုရင် index က 0 ကနေ 4 အထိပဲ ရှိပါတယ်။

fruits = ["apple", "banana", "mango", "orange", "papaya"]

print(fruits[0])   # ပထမဆုံး အရာ
print(fruits[2])   # တတိယမြောက် အရာ

Output:

apple
mango

List ထဲက အရာဝတ္ထုတွေအားလုံးကို နည်းလမ်းနှစ်မျိုးနဲ့ ပတ်ကြည့်လို့ရပါတယ်။ ရလဒ်က အတူတူပါပဲ။

colors = ["red", "green", "blue"]

# နည်းလမ်း ၁: index နဲ့ ပတ်တာ
for i in range(len(colors)):
    print(colors[i])

# နည်းလမ်း ၂: အရာဝတ္ထုတိုင်းကို တိုက်ရိုက် ပတ်တာ
for color in colors:
    print(color)

Output:

red
green
blue
red
green
blue

Negative Indexing

Python ရဲ့ အထူးအချက်တစ်ခုကတော့ negative index သုံးလို့ရတာပါ။ -1 ဆိုတာ နောက်ဆုံးက အရာ၊ -2 ဆိုတာ နောက်ဆုံးက ဒုတိယမြောက် အရာကို ဆိုလိုပါတယ်။

temps = [31, 33, 29, 35, 32]

print(temps[-1])   # နောက်ဆုံး: 32
print(temps[-5])   # ပထမဆုံး: 31

Output:

32
31

---

Slicing (အပိုင်းဖြတ်ယူခြင်း)

Slicing ဆိုတာ list ရဲ့ အပိုင်းအစ တစ်ခုခုကို ဖြတ်ယူတဲ့ နည်းပါ။ Colon : ကို သုံးပါတယ်။ အခြေခံပုံစံက myList[start:stop:step] ပါ — start ကနေ စပြီး stop မတိုင်ခင်အထိ၊ step ခုန်ပြီး ယူတာပါ။

days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]

print(days[2:5])    # index 2 ကနေ 4 အထိ
print(days[::2])    # တစ်ခု ခြားပြီး ယူ
print(days[1::2])   # index 1 ကနေ တစ်ခု ခြားယူ
print(days[-3:])    # နောက်ဆုံး ၃ ခု
print(days[::-1])   # ပြောင်းပြန်

Output:

['Wed', 'Thu', 'Fri']
['Mon', 'Wed', 'Fri', 'Sun']
['Tue', 'Thu', 'Sat']
['Fri', 'Sat', 'Sun']
['Sun', 'Sat', 'Fri', 'Thu', 'Wed', 'Tue', 'Mon']

---

List ကို ပြင်ဆင်ခြင်း (Updating a List)

List ရဲ့ အကောင်းဆုံးအချက်တစ်ခုကတော့ ပြင်ဆင်လို့ရတယ် (mutable) ဆိုတာပါ။ Index တစ်ခုကို = နဲ့ တန်ဖိုးအသစ် ပေးလိုက်ရုံပါပဲ။

grades = ["A", "B", "C", "D"]

# အရာ တစ်ခုတည်း ပြင်တာ
grades[1] = "B+"
print(grades)

# slice တစ်ခုလုံး ပြင်တာ (slice assignment)
grades[1:3] = ["B", "C+"]
print(grades)

Output:

['A', 'B+', 'C', 'D']
['A', 'B', 'C+', 'D']

append() vs extend()

List ထဲကို အရာအသစ် ထည့်ဖို့ method နှစ်ခု ရှိပါတယ်။ ဒီနှစ်ခုကို ရောထွေးတတ်ကြပါတယ်။

• append(x) — အရာ တစ်ခုကို list အဆုံးမှာ ထည့်တယ်
• extend(iterable) — list တစ်ခုရဲ့ အရာဝတ္ထုတွေအားလုံးကို အဆုံးမှာ ဆက်ထည့်တယ်

tasks = ["read", "write"]

tasks.append("code")
print(tasks)

tasks.extend(["test", "debug"])
print(tasks)

Output:

['read', 'write', 'code']
['read', 'write', 'code', 'test', 'debug']

ဒါဆို append() နဲ့ list တစ်ခုလုံး ထည့်ရင် ဘာဖြစ်မလဲ? ကြည့်ပါ။

tasks.append(["eat", "sleep"])
print(tasks)

Output:

['read', 'write', 'code', 'test', 'debug', ['eat', 'sleep']]

append() က ["eat", "sleep"] list ကြီးကို အရာ တစ်ခုတည်း အနေနဲ့ ထည့်လိုက်တာပါ။ extend() သုံးရင်တော့ "eat" နဲ့ "sleep" ကို သီးခြားအရာတွေအနေနဲ့ ထည့်မှာပါ။ ဒီကွာခြားချက်က အရေးကြီးပါတယ်။

↻ ပြန်ဖွင့်ရန်

---

List ထဲက အရာဝတ္ထုများ ဖျက်ခြင်း (Deleting Items)

List ထဲက အရာဝတ္ထုတွေကို ဖျက်ဖို့ နည်းလမ်း လေးမျိုး ရှိပါတယ်။ တစ်ခုချင်းစီရဲ့ အလုပ်လုပ်ပုံ မတူပါဘူး။

del — index နဲ့ ဖျက်တာ

books = ["Python", "Java", "C++", "Rust", "Go"]

del books[3]        # index 3 က "Rust" ကို ဖျက်
print(books)

del books[0:2]      # index 0 နဲ့ 1 ကို ဖျက်
print(books)

Output:

['Python', 'Java', 'C++', 'Go']
['C++', 'Go']

remove() — တန်ဖိုးနဲ့ ဖျက်တာ

remove(x) က တန်ဖိုးနဲ့ ရှာပြီး ပထမဆုံး တွေ့တဲ့အရာကို ဖျက်ပါတယ်။ ဖျက်ပြီးတဲ့ တန်ဖိုးကို ပြန်မပေးပါဘူး။

names = ["Aung", "May", "Zaw", "May"]

names.remove("May")   # ပထမဆုံး "May" ကို ဖျက်
print(names)

Output:

['Aung', 'Zaw', 'May']

ဒုတိယ "May" က ကျန်နေသေးတာ သတိထားပါ — remove() က ပထမဆုံး တွေ့တာတစ်ခုပဲ ဖျက်ပါတယ်။

pop() — ဖျက်ပြီး ပြန်ပေးတာ

pop() က အရာကို ဖျက်ရုံတင်မကဘူး၊ ဖျက်လိုက်တဲ့ တန်ဖိုးကို ပြန်ပေးတယ်။ Index မပေးရင် နောက်ဆုံးက အရာကို ယူပါတယ်။

queue = ["Aung", "May", "Zaw"]

served = queue.pop()      # နောက်ဆုံးက "Zaw" ကို ဖယ် + ပြန်ပေး
print(served)
print(queue)

first = queue.pop(0)      # ပထမဆုံး အရာကို ဖယ် + ပြန်ပေး
print(first)
print(queue)

Output:

Zaw
['Aung', 'May']
Aung
['May']

ဒါကြောင့် remove() နဲ့ pop() ရဲ့ ကွာခြားချက်က:

	remove()	pop()
ရှာပုံ	တန်ဖိုးနဲ့ ရှာတယ်	index နဲ့ ရှာတယ် (မပေးရင် နောက်ဆုံး)
ပြန်ပေးတာ	ဘာမှ ပြန်မပေးဘူး	ဖျက်လိုက်တဲ့ အရာကို ပြန်ပေးတယ်
မတွေ့ရင်	ValueError တက်တယ်	IndexError တက်တယ်

clear() — အားလုံး ဖျက်တာ

cart = ["milk", "bread", "eggs"]
cart.clear()
print(cart)   # []

Output:

[]

clear() ပြီးရင် list အလွတ် [] ပဲ ကျန်ပါတယ်။ del cart လို့ list နာမည်ကိုယ်တိုင်ကို ဖျက်တာနဲ့ မတူပါဘူး — အဲဒါက variable ကိုပါ ဖျက်ပစ်တာပါ။

---

List Method များ (List Methods Reference)

အပေါ်မှာ လေ့လာခဲ့တဲ့ method တွေအပြင် ကျန်တဲ့ အသုံးဝင် method တွေကို ဆက်ကြည့်ရအောင်။

insert() — ကြားထဲ ထည့်တာ

append() က အဆုံးမှာပဲ ထည့်နိုင်ပေမဲ့ insert(i, x) ကတော့ index i နေရာမှာ ထည့်နိုင်ပါတယ်။

cities = ["Yangon", "Mandalay", "Naypyidaw"]
cities.insert(1, "Bago")
print(cities)

Output:

['Yangon', 'Bago', 'Mandalay', 'Naypyidaw']

index() နဲ့ count()

• index(x) — x ပထမဆုံး ပေါ်တဲ့ index ကို ပြန်ပေးတယ်
• count(x) — x ဘယ်နှစ်ခါ ပါလဲ ရေတွက်ပေးတယ်

nums = [5, 3, 5, 7, 5, 9]

print(nums.index(7))   # 7 ပထမဆုံး ဘယ် index မှာလဲ
print(nums.count(5))   # 5 ဘယ်နှစ်ခါ ပါလဲ

Output:

3
3

sort() နဲ့ reverse()

points = [45, 12, 78, 23]

points.sort()      # အငယ်ကနေ အကြီးကို စီ
print(points)

points.reverse()   # ပြောင်းပြန် လှန်
print(points)

Output:

[12, 23, 45, 78]
[78, 45, 23, 12]

sort() မှာ ရွေးချယ်စရာ (option) နှစ်ခု ထပ်ရှိပါတယ်။

nums = [5, 1, 9, 3]
nums.sort(reverse=True)   # အကြီးကနေ အငယ်ကို စီ
print(nums)

words = ["banana", "kiwi", "apple", "fig"]
words.sort(key=len)       # အရှည်အလိုက် စီ
print(words)

Output:

[9, 5, 3, 1]
['fig', 'kiwi', 'apple', 'banana']

reverse=True က အကြီးကနေ အငယ်ကို စီစေပြီး၊ key=len က "ဘယ်အရာနဲ့ နှိုင်းယှဉ်ပြီး စီမလဲ" ဆိုတာကို သတ်မှတ်ပေးတာပါ။ ဒီနေရာမှာ စကားလုံးရဲ့ အရှည် (len) နဲ့ စီခိုင်းထားတာပါ။

copy() — မိတ္တူ ကူးတာ

original = [1, 2, 3]
backup = original.copy()

backup.append(99)
print(original)   # မူလက မပြောင်းဘူး
print(backup)

Output:

[1, 2, 3]
[1, 2, 3, 99]

Method များ အကျဉ်းချုပ်

Method	အလုပ်
append(x)	အဆုံးမှာ အရာ တစ်ခု ထည့်တယ်
extend(iterable)	list တစ်ခုရဲ့ အရာအားလုံးကို အဆုံးမှာ ဆက်ထည့်တယ်
insert(i, x)	index i နေရာမှာ ထည့်တယ်
remove(x)	တန်ဖိုး x (ပထမဆုံး တွေ့တာ) ကို ဖျက်တယ်
pop([i])	index i က အရာကို ဖျက်ပြီး ပြန်ပေးတယ် (မပေးရင် နောက်ဆုံး)
clear()	အရာအားလုံး ဖျက်တယ်
index(x)	x ပထမဆုံး ပေါ်တဲ့ index ကို ပြန်ပေးတယ်
count(x)	x ပါတဲ့ အကြိမ်ရေ ရေတွက်ပေးတယ်
sort()	အစဉ်လိုက် စီတယ် (မူလ list ပြောင်းတယ်)
reverse()	ပြောင်းပြန် လှန်တယ် (မူလ list ပြောင်းတယ်)
copy()	list မိတ္တူ အသစ် ပြန်ပေးတယ်

---

Mini Project: To-Do List

အခန်းမှာ သင်ခဲ့သမျှကို စုပေါင်းပြီး လက်တွေ့ program လေး တစ်ခု ရေးကြည့်ရအောင် — ရိုးရှင်းတဲ့ To-Do List program ပါ။ အလုပ် ထည့်တာ (append)၊ ကြည့်တာ (loop)၊ ဖျက်တာ (pop) အားလုံး ပါဝင်ပါတယ်။

todo = []

while True:
    print("\n--- To-Do List ---")
    print("1. အလုပ်အသစ် ထည့်ရန်")
    print("2. အလုပ်များ ကြည့်ရန်")
    print("3. အလုပ် ဖျက်ရန်")
    print("4. ထွက်ရန်")
    choice = input("ရွေးချယ်ပါ (1-4): ")

    if choice == "1":
        task = input("အလုပ်အမည်: ")
        todo.append(task)
        print("ထည့်ပြီးပါပြီ!")
    elif choice == "2":
        if not todo:
            print("အလုပ်မရှိသေးပါ။")
        else:
            for i, task in enumerate(todo, 1):
                print(f"{i}. {task}")
    elif choice == "3":
        n = int(input("ဖျက်မည့် အလုပ်နံပါတ်: "))
        if 1 <= n <= len(todo):
            removed = todo.pop(n - 1)
            print(f"'{removed}' ကို ဖျက်ပြီးပါပြီ။")
        else:
            print("နံပါတ် မမှန်ပါ။")
    elif choice == "4":
        print("ထွက်ပါပြီ။")
        break
    else:
        print("1 မှ 4 အတွင်း ရွေးပါ။")

နမူနာ အသုံးပြုပုံ:

--- To-Do List ---
1. အလုပ်အသစ် ထည့်ရန်
2. အလုပ်များ ကြည့်ရန်
3. အလုပ် ဖျက်ရန်
4. ထွက်ရန်
ရွေးချယ်ပါ (1-4): 1
အလုပ်အမည်: Python စာအုပ်ဖတ်
ထည့်ပြီးပါပြီ!

--- To-Do List ---
...
ရွေးချယ်ပါ (1-4): 2
1. Python စာအုပ်ဖတ်

---

List နှင့် String ချိတ်ဆက်ခြင်း (split နဲ့ join)

အခန်း ၇ မှာ သင်ခဲ့တဲ့ string method တွေနဲ့ list ကို တွဲသုံးလို့ရပါတယ်။ အသုံးအများဆုံးက split() နဲ့ join() ပါ။

split() က string တစ်ခုကို ခွဲပြီး list အဖြစ် ပြောင်းပေးပါတယ်။

# string ကနေ list
text = "apple banana mango"
fruits = text.split()
print(fruits)

# အသုံးပြုသူ ရိုက်ထည့်တာကနေ list တည်ဆောက်တာ
nums = input("ကိန်းတွေ ရိုက်ပါ (space ခြား): ").split()
print(nums)

Output:

['apple', 'banana', 'mango']

(ဒုတိယ နမူနာမှာ အသုံးပြုသူက 10 20 30 လို့ ရိုက်ရင် ['10', '20', '30'] ရပါတယ် — string တွေအနေနဲ့ရတာမို့ ကိန်းအဖြစ် သုံးချင်ရင် int() နဲ့ ပြောင်းရပါမယ်။)

join() ကတော့ ပြောင်းပြန် — list ထဲက စကားလုံးတွေကို ဆက်ပြီး string တစ်ခု ပြန်ထုတ်ပေးပါတယ်။

words = ["I", "love", "Python"]
sentence = " ".join(words)
print(sentence)

codes = ["09", "771", "234567"]
phone = "-".join(codes)
print(phone)

Output:

I love Python
09-771-234567

" ".join(words) ဆိုတာ စကားလုံးတွေကြားမှာ space " " ခံပြီး ဆက်ပါလို့ ပြောတာပါ။ "-".join(codes) ဆိုရင် - နဲ့ ဆက်ပါတယ်။

---

List Operator များ (+ နှင့် *)

Tuple အခန်းမှာ တွေ့ရမယ့် + နဲ့ * operator တွေက list မှာလည်း အလုပ်လုပ်ပါတယ်။

a = [1, 2]
b = [3, 4]

print(a + b)   # list နှစ်ခု ဆက်
print(a * 2)   # ၂ ခါ ထပ်

Output:

[1, 2, 3, 4]
[1, 2, 1, 2]

a + b က list အသစ် ဖန်တီးပေးပြီး မူလ a နဲ့ b ကို မထိခိုက်ပါဘူး။ extend() နဲ့ ကွာခြားတာက extend() က မူလ list ကို တိုက်ရိုက်ပြင်တာဖြစ်ပြီး + က အသစ်ဖန်တီးတာပါ။

---

အမှားများ ရှောင်ရန် (Common Pitfalls)

List သုံးတဲ့အခါ beginner တွေ ခဏခဏ မှားတတ်တဲ့ အချက် လေးခုကို စုစည်းထားပါတယ်။

၁. Index တစ်လုံး လွဲတာ (Off-by-one)

fruits = ["apple", "banana", "mango"]
# print(fruits[3])   # IndexError! index က 0, 1, 2 ပဲ ရှိတယ်
print(fruits[len(fruits) - 1])   # နောက်ဆုံးကို ယူတဲ့ အမှန်နည်း
print(fruits[-1])                # ဒါမှမဟုတ် ဒီနည်း

Output:

mango
mango

၂. append() ရဲ့ return value ကို သုံးမိတာ

nums = [1, 2, 3]
result = nums.append(4)
print(result)   # None! append က ဘာမှ ပြန်မပေးဘူး
print(nums)     # [1, 2, 3, 4] — list ကိုယ်တိုင်က ပြောင်းသွားတယ်

Output:

None
[1, 2, 3, 4]

၃. မိတ္တူကူးတယ်ထင်ပြီး alias လုပ်မိတာ

a = [1, 2, 3]
b = a          # မိတ္တူ မဟုတ်ဘူး — တူညီတဲ့ list ကို ညွှန်းတာ
b.append(99)
print(a)       # [1, 2, 3, 99] — aပါ လိုက်ပြောင်းသွားတယ်!

Output:

[1, 2, 3, 99]

တကယ့် မိတ္တူလိုချင်ရင် b = a.copy() လို့ ရေးရပါမယ်။

၄. မရှိတဲ့ တန်ဖိုးကို remove() လုပ်မိတာ

colors = ["red", "blue"]
if "green" in colors:
    colors.remove("green")
else:
    print("green မရှိဘူး — မဖျက်ဘူး")

Output:

green မရှိဘူး — မဖျက်ဘူး

remove() မခေါ်ခင် in နဲ့ ရှိမရှိ အရင်စစ်တာက ValueError မတက်အောင် ကာကွယ်တဲ့ အလေ့အကျင့်ကောင်းပါ။

---

လေ့ကျင့်ခန်းများ

1. (လွယ်) prices = [1200, 500, 3400, 800] ဆိုတဲ့ စျေးနှုန်း list တစ်ခုရှိတယ်။ sum() function ကို မသုံးဘဲ for loop နဲ့ စုစုပေါင်း တွက်ထုတ်ပါ။

2. (အလတ်) words = ["apple", "ant", "banana", "avocado", "cherry"] ထဲက "a" နဲ့ စတဲ့ စကားလုံးတွေကို ဖျက်ထုတ်ပြီး ကျန်တဲ့ စကားလုံးတွေကို print ထုတ်ပါ။ (အကြံပြု: list အသစ်တစ်ခု တည်ဆောက်ပါ)

3. (အလတ်) rolls = [4, 6, 4, 2, 6, 4, 6] — အန်စာတုံး ပစ်မှတ်ထားတာ။ count() သုံးပြီး 6 ဘယ်နှစ်ခါ ကျလဲ ရှာပါ။ ပြီးရင် index() သုံးပြီး 2 ပထမဆုံး ဘယ် index မှာ ပေါ်လဲ ရှာပါ။

4. (ခက်) [3, 1, 2, 3, 1, 5, 2] ထဲက ထပ်နေတဲ့ တန်ဖိုးတွေကို ဖယ်ပြီး [3, 1, 2, 5] လို unique တန်ဖိုးတွေချည်းပဲ ပါတဲ့ list အသစ် ဖန်တီးပါ။ set နဲ့ sort() ကို မသုံးရပါ။

5. (စိန်ခေါ်မှု) data = [10, 20, 30, 40, 50] ကို slicing တစ်ခုတည်းနဲ့ ပြောင်းပြန်လှန်ပါ။ ပြီးရင် reverse() method ရလဒ်နဲ့ နှိုင်းယှဉ်ပြီး ဘယ်ဟာက မူလ list ကို ထိခိုက်လဲ စမ်းကြည့်ပါ။