Chapter 9: Nested List များ (Nested Lists and Matrices)

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

---

Nested List ဆိုတာဘာလဲ (What is a Nested List?)

List ထဲမှာ နောက်ထပ် list တွေ ထည့်ထားတာကို nested list လို့ ခေါ်ပါတယ်။ ဒီလို ထည့်လိုက်တာနဲ့ အချက်အလက် ဖွဲ့စည်းပုံမှာ dimension အသစ် တစ်ခု ထပ်တိုးလာပါတယ် — စာရင်းတစ်ခုတည်း မဟုတ်တော့ဘဲ "ဇယားကွက်" ပုံစံ ဖြစ်လာတာပေါ့။

ဥပမာ ရုပ်ရှင်ရုံ ထိုင်ခုံ အတန်းတွေကို ကိုယ်စားပြုကြည့်ရအောင်။

# ထိုင်ခုံ ၃ တန်း၊ တစ်တန်းမှာ ၃ လုံး
seats = [["A1", "A2", "A3"],
         ["B1", "B2", "B3"],
         ["C1", "C2", "C3"]]

# list တစ်ခုလုံး print ထုတ်
print(seats)

Output:

[['A1', 'A2', 'A3'], ['B1', 'B2', 'B3'], ['C1', 'C2', 'C3']]

Nested list ထဲက list တစ်ခုချင်းစီကို အပြင် index တစ်ခုတည်းနဲ့ ခေါ်နိုင်ပါတယ်။

print(seats[0])   # ပထမ အတန်း
print(seats[1])   # ဒုတိယ အတန်း
print(seats[2])   # တတိယ အတန်း

Output:

['A1', 'A2', 'A3']
['B1', 'B2', 'B3']
['C1', 'C2', 'C3']

---

Chained Indexing ဖြင့် အရာဝတ္ထုများ ရယူခြင်း

အတွင်းဆုံး အရာဝတ္ထု တစ်ခုချင်းစီကို ရောက်ဖို့ဆိုရင် square bracket [ ] ကို နှစ်ထပ် သုံးရပါတယ် — ဒါကို chained indexing လို့ ခေါ်ပါတယ်။ ပထမ [ ] က အပြင် list ထဲက ဘယ် list လဲဆိုတာ ရွေးပြီး၊ ဒုတိယ [ ] က အဲဒီ အတွင်း list ထဲက ဘယ်အရာလဲဆိုတာ ရွေးပါတယ်။

seats = [["A1", "A2", "A3"],
         ["B1", "B2", "B3"],
         ["C1", "C2", "C3"]]

print(seats[1][2])   # ဒုတိယအတန်း (index 1) ရဲ့ တတိယခုံ (index 2)
print(seats[0][0])   # ပထမအတန်း ပထမခုံ
print(seats[2][-1])  # တတိယအတန်း နောက်ဆုံးခုံ

Output:

B3
A1
C3

နေရာမှာ တင် ပြင်ဆင်ခြင်း (In-place Modification)

Nested list ရဲ့ အတွင်းတန်ဖိုးတွေကို တိုက်ရိုက် ပြင်ဆင်နိုင်ပါတယ်။ List တွေက mutable ဖြစ်တဲ့အတွက် အဆင်ပြေပါတယ်။

marks = [[70, 80, 90],
         [85, 75, 95],
         [60, 88, 77]]

# ပထမကျောင်းသား ဒုတိယဘာသာ အမှတ်ကို ပြင်တာ
marks[0][1] = 82

# တတိယကျောင်းသား ပထမဘာသာကို bonus ၅ မှတ် ပေါင်းတာ
marks[2][0] += 5

print(marks[0])
print(marks[2])

Output:

[70, 82, 90]
[65, 88, 77]

---

Nested List ကို ပတ်ကြည့်ခြင်း (Iteration Styles)

Nested list ကို ပတ်ကြည့်ဖို့ နည်းလမ်း သုံးမျိုး ရှိပါတယ်။ သုံးခုလုံး ရလဒ်တူပေမဲ့ အခြေအနေအလိုက် တစ်ခုခုက ပိုအဆင်ပြေတတ်ပါတယ်။

နည်းလမ်း ၁: for-each (အတန်းလိုက်)

menu = [["rice", "curry"],
        ["noodle", "soup"],
        ["bread", "tea"]]

for row in menu:
    print(row)

Output:

['rice', 'curry']
['noodle', 'soup']
['bread', 'tea']

အတန်းနံပါတ်ပါ တွဲပြချင်ရင် enumerate() ကို သုံးနိုင်ပါတယ်။

for i, row in enumerate(menu):
    print(f"အတန်း {i}: {row}")

Output:

အတန်း 0: ['rice', 'curry']
အတန်း 1: ['noodle', 'soup']
အတန်း 2: ['bread', 'tea']

enumerate(menu) က အတန်းတစ်ခုချင်းစီကို သူ့ရဲ့ index နံပါတ်နဲ့ တွဲပေးပါတယ်။ Index နံပါတ် လိုအပ်ပေမဲ့ range(len(...)) လို ရှည်ရှည်ရေးစရာ မလိုတဲ့အခါ ဒီနည်းက ပိုသန့်ပါတယ်။

နည်းလမ်း ၂: index-based (index နဲ့)

for i in range(len(menu)):
    print(menu[i])

Output က အပေါ်နဲ့ အတူတူပါပဲ။ Index နံပါတ် ကိုယ်တိုင် လိုအပ်တဲ့အခါ (ဥပမာ "အတန်း ၁၊ အတန်း ၂" လို့ နံပါတ်တပ်ပြီး ပြချင်တဲ့အခါ) ဒီနည်းက ပိုအဆင်ပြေပါတယ်။

နည်းလမ်း ၃: nested for (အရာတစ်ခုချင်းစီ)

အတွင်းဆုံး အရာဝတ္ထု တစ်ခုချင်းစီကို ရောက်ချင်ရင် for loop ကို နှစ်ထပ် သုံးရပါတယ်။

for i in range(len(menu)):
    for j in range(len(menu[i])):
        print(menu[i][j], end=" | ")
    print()   # တစ်တန်း ပြီးတိုင်း စာကြောင်းသစ်

Output:

rice | curry |
noodle | soup |
bread | tea |

end=" | " က print တိုင်း စာကြောင်းသစ် မဆင်းဘဲ | နဲ့ ဆက်ရေးစေတာပါ။ အတန်း တစ်တန်း ပြီးမှ print() အလွတ်နဲ့ စာကြောင်းသစ် ဆင်းတာပါ။

---

append() ဖြင့် Nested List တည်ဆောက်ခြင်း

Nested list ကို တစ်ခါတည်း အပြီးရေး မဟုတ်ဘဲ append() နဲ့ တစ်တန်းချင်း ထည့်သွားလို့လည်း ရပါတယ်။ အချက်အလက် အသစ်တွေ တဖြည်းဖြည်း ရောက်လာတဲ့အခါ ဒီနည်းက အသုံးဝင်ပါတယ်။

groups = []

groups.append(["Aung", "May"])
print(groups)

groups.append(["Zaw", "Hla", "Ko"])
print(groups)

groups.append(["Su"])
print(groups)

Output:

[['Aung', 'May']]
[['Aung', 'May'], ['Zaw', 'Hla', 'Ko']]
[['Aung', 'May'], ['Zaw', 'Hla', 'Ko'], ['Su']]

အတန်းတိုင်း အရှည်တူဖို့ မလိုဘူးဆိုတာ ဒီနမူနာမှာ ရှင်းရှင်းလင်းလင်း မြင်ရပါတယ် — ပထမအတန်းမှာ ၂ ယောက်၊ ဒုတိယမှာ ၃ ယောက်၊ တတိယမှာ ၁ ယောက်ပါ။

---

Matrix အဖြစ် အသုံးပြုခြင်း (Nested Lists as Matrices)

တခြား programming language တွေမှာ matrix (ဇယားကွက် ကိန်းဂဏန်း) ကို 2-dimensional array နဲ့ ကိုယ်စားပြုပါတယ်။ Python မှာတော့ nested list ကို သုံးပြီး matrix ကို ကိုယ်စားပြုနိုင်ပါတယ်။ သတိထားရမှာက ပထမ index က 0 ကနေ စတယ်ဆိုတာပါ။

Matrix ရဲ့ element တစ်ခုချင်းစီကို index နှစ်ခုနဲ့ ခေါ်ပါတယ် — ပထမတစ်ခုက row နံပါတ်၊ ဒုတိယတစ်ခုက column နံပါတ် ပါ။

# 2x2 matrix
matrixA = [[4, 7],
           [2, 9]]
print("matrixA[0][1] =", matrixA[0][1])   # ပထမ row, ဒုတိယ column

# 3x3 matrix
matrixB = [[1.5, 2.0, 3.5],
           [4.0, 5.5, 6.0],
           [7.5, 8.0, 9.5]]

nRow = len(matrixB)       # row အရေအတွက်
nCol = len(matrixB[0])    # column အရေအတွက်

for row in range(nRow):
    for col in range(nCol):
        print(matrixB[row][col], end="  ")
    print()

Output:

matrixA[0][1] = 7
1.5  2.0  3.5
4.0  5.5  6.0
7.5  8.0  9.5

Column တစ်ခုတည်းကို ဆွဲထုတ်ကြည့်ချင်ရင်လည်း လွယ်ပါတယ် — row တိုင်းရဲ့ တူညီတဲ့ column index ကို ခေါ်ရုံပါပဲ။

# ဒုတိယ column (index 1) ကို ဆွဲထုတ်တာ
for row in range(nRow):
    print(matrixB[row][1])

Output:

2.0
5.5
8.0

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

---

လက်တွေ့ ဥပမာ: စာမေးပွဲ အမှတ်စာရင်း

Nested list ရဲ့ တကယ့် အသုံးဝင်ပုံကို စာမေးပွဲ အမှတ်စာရင်းနဲ့ ကြည့်ရအောင်။ Row တစ်တန်းက ကျောင်းသားတစ်ယောက်၊ column တစ်ခုက ဘာသာရပ်တစ်ခုကို ကိုယ်စားပြုပါတယ်။

# Row = ကျောင်းသား, Column = ဘာသာရပ် (Math, Science, English)
scores = [
    [80, 75, 90],   # Aung
    [95, 88, 92],   # May
    [70, 82, 78]    # Zaw
]
names = ["Aung", "May", "Zaw"]
subjects = ["Math", "Science", "English"]

# ကျောင်းသားတစ်ယောက်ချင်းစီရဲ့ စုစုပေါင်းနဲ့ ပျမ်းမျှ (row အလိုက်)
for i in range(len(scores)):
    total = sum(scores[i])
    avg = total / len(scores[i])
    print(f"{names[i]}: total={total}, average={avg:.1f}")

print()

# ဘာသာရပ်တစ်ခုချင်းစီရဲ့ ပျမ်းမျှ (column အလိုက်)
for j in range(len(subjects)):
    total = 0
    for i in range(len(scores)):
        total += scores[i][j]
    print(f"{subjects[j]} average: {total / len(scores):.1f}")

Output:

Aung: total=245, average=81.7
May: total=275, average=91.7
Zaw: total=230, average=76.7

Math average: 81.7
Science average: 81.7
English average: 86.7

Row အလိုက် ပတ်တာက လွယ်ပါတယ် — scores[i] က ကျောင်းသားတစ်ယောက်ရဲ့ အမှတ်တွေ အကုန်ပါတဲ့ list ဖြစ်နေလို့ပါ။ Column အလိုက် ပတ်တာကျတော့ အပြင် loop က column (j) ကို ထိန်းပြီး အတွင်း loop က row တိုင်းကို ဆင်းရပါတယ်: scores[i][j]။ ဒီ "row-major vs column-major" ပတ်ပုံ နှစ်မျိုးကို ကွဲကွဲပြားပြား နားလည်ထားရင် matrix အလုပ်တိုင်းမှာ အဆင်ပြေပါလိမ့်မယ်။

---

Matrix နှစ်ခု ပေါင်းခြင်း

Matrix တွေကို သင်္ချာနည်းနဲ့ ပေါင်းတာလည်း nested loop နဲ့ လုပ်လို့ရပါတယ်။ တူညီတဲ့ အနေအထား (row, column) က တန်ဖိုးနှစ်ခုကို ပေါင်းတာပါ။

A = [[1, 2],
     [3, 4]]
B = [[5, 6],
     [7, 8]]

C = []
for i in range(len(A)):
    row = []
    for j in range(len(A[0])):
        row.append(A[i][j] + B[i][j])
    C.append(row)

print(C)

Output:

[[6, 8], [10, 12]]

အတွင်း loop က row အသစ်တစ်ခု (row) တည်ဆောက်ပြီး၊ အပြင် loop က အဲဒီ row ကို ရလဒ် matrix C ထဲ append() လုပ်ပါတယ်။ ဒါက အခန်း ၈ ရဲ့ append() နဲ့ အခန်း ၉ ရဲ့ nested loop ကို တွဲသုံးတဲ့ ပုံစံပါပဲ — အခန်းတွေ တစ်ခုနဲ့တစ်ခု ဘယ်လို ဆက်စပ်သွားလဲဆိုတာ ဒီမှာ မြင်ရပါတယ်။

စိန်ခေါ်မှု အတွက်: အပေါင်းအစား အနုတ်ကို တွက်တဲ့ version ကို ကိုယ်တိုင် ရေးကြည့်ပါ — A[i][j] + B[i][j] နေရာမှာ - ပြောင်းရုံပါပဲ။ Matrix မြှောက်ခြင်း (multiplication) ကျတော့ ပုံစံ နည်းနည်း ကွာပါတယ် — စိတ်ဝင်စားရင် "matrix multiplication Python nested loop" လို့ ရှာဖတ်ကြည့်ပါ။

---

Nested List မိတ္တူကူးခြင်း သတိပြုရန်

အခန်း ၈ မှာ copy() က မိတ္တူကူးပေးတယ်လို့ သင်ခဲ့ပါတယ်။ ဒါပေမဲ့ nested list မှာတော့ copy() က အပြင် list ကိုပဲ ကူးတာပါ — အတွင်း list တွေကိုတော့ မကူးဘဲ မူလနဲ့ အတူတူ မျှဝေသုံးပါတယ်။

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

shallow[0][0] = 99
print("shallow:", shallow)
print("original:", original)   # မူလပါ လိုက်ပြောင်းသွားတယ်!

Output:

shallow: [[99, 2], [3, 4]]
original: [[99, 2], [3, 4]]

shallow[0] နဲ့ original[0] က list တစ်ခုတည်းကို ညွှန်းနေလို့ပါ။ အတွင်းအထိ လုံးဝ သီးခြား မိတ္တူကူးချင်ရင် copy module ရဲ့ deepcopy() ကို သုံးရပါတယ်။

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

deep[0][0] = 99
print("deep:", deep)
print("original:", original)   # မူလက မပြောင်းဘူး

Output:

deep: [[99, 2], [3, 4]]
original: [[1, 2], [3, 4]]

---

Input ဖြင့် Nested List တည်ဆောက်ခြင်း

အသုံးပြုသူဆီက အချက်အလက်တွေ ယူပြီး nested list တည်ဆောက်တာက လက်တွေ့ program တွေမှာ အဖြစ်များပါတယ်။

students = []
n = int(input("ကျောင်းသား အရေအတွက်: "))

for i in range(n):
    name = input(f"ကျောင်းသား {i+1} အမည်: ")
    mark = int(input(f"{name} ရဲ့ အမှတ်: "))
    students.append([name, mark])

print("\n--- မှတ်တမ်းများ ---")
for s in students:
    print(f"{s[0]}: {s[1]} မှတ်")

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

ကျောင်းသား အရေအတွက်: 2
ကျောင်းသား 1 အမည်: Aung
Aung ရဲ့ အမှတ်: 85
ကျောင်းသား 2 အမည်: May
May ရဲ့ အမှတ်: 92

--- မှတ်တမ်းများ ---
Aung: 85 မှတ်
May: 92 မှတ်

အရေးကြီးတဲ့ အချက်က students.append([name, mark]) ပါ — list အသစ် [name, mark] တစ်ခုကို ဖန်တီးပြီး အပြင် list ထဲ ထည့်တာပါ။ Loop တစ်ပတ်ချင်းစီမှာ [name, mark] အသစ် ဖြစ်နေတာကြောင့် အတန်းတိုင်းက သီးခြား list တွေ ဖြစ်ပါတယ်။

---

Nested List မှာ ရှာဖွေခြင်း (Searching)

Nested list ထဲက တန်ဖိုးတစ်ခုကို ရှာတာလည်း nested loop နဲ့ပဲ လုပ်ပါတယ်။ တွေ့တာနဲ့ break နှစ်ထပ် ထွက်ဖို့ flag variable သုံးရပါတယ်။

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

target = 5
found = False

for i in range(len(grid)):
    for j in range(len(grid[i])):
        if grid[i][j] == target:
            print(f"{target} ကို row {i}, column {j} မှာ တွေ့ပြီ")
            found = True
            break
    if found:
        break

if not found:
    print(f"{target} မတွေ့ပါ")

Output:

5 ကို row 1, column 1 မှာ တွေ့ပြီ

အတွင်း break က အတွင်း loop ကိုပဲ ရပ်တာမို့လို့ အပြင် loop ကို ရပ်ဖို့ if found: break ထပ်လိုပါတယ်။ ဒါက nested loop ရဲ့ သဘာဝပါ — loop အလွှာ တစ်ခုချင်းစီကို သီးခြား ထိန်းချုပ်ရပါတယ်။

---

Matrix Transpose (Row နဲ့ Column လဲခြင်း)

Matrix ရဲ့ row တွေကို column အဖြစ် လဲလိုက်တာကို transpose လို့ ခေါ်ပါတယ်။ Nested loop နဲ့ တည်ဆောက်ပုံကို နားလည်ဖို့ အကောင်းဆုံး လေ့ကျင့်ခန်းတစ်ခုပါ။

m = [[1, 2, 3],
     [4, 5, 6]]

t = []
for c in range(len(m[0])):    # မူလ column တိုင်းအတွက်
    row = []
    for r in range(len(m)):    # မူလ row တိုင်းကနေ တန်ဖိုး ဆွဲထုတ်
        row.append(m[r][c])
    t.append(row)

print(t)

Output:

[[1, 4], [2, 5], [3, 6]]

မူလ matrix က 2 row × 3 column ဖြစ်ပြီး transpose လုပ်ပြီးတော့ 3 row × 2 column ဖြစ်သွားပါတယ်။ အပြင် loop က column (c) ကို ထိန်းပြီး အတွင်း loop က row တိုင်းကို ဆင်းတာ — "column အလိုက် ပတ်ခြင်း" အပိုင်းမှာ သင်ခဲ့တဲ့ နည်းနဲ့ အတူတူပါပဲ။ ရလဒ်ကို row အသစ်တွေအဖြစ် ပြန်စုတာပါ။

ဒီ transpose နည်းစနစ်က data science နဲ့ image processing တို့မှာ အခြေခံကျတဲ့ operation တစ်ခုပါ။ Nested list နဲ့ ကိုယ်တိုင် ရေးတတ်သွားရင် NumPy လို library တွေရဲ့ .T ကို သုံးတဲ့အခါ နောက်ကွယ်မှာ ဘာဖြစ်နေလဲဆိုတာ နားလည်နေပါလိမ့်မယ်။

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

---

Matrix Diagonal ပေါင်းခြင်း

Square matrix (row အရေအတွက်နဲ့ column အရေအတွက် တူတဲ့ matrix) မှာ ထောင့်ဖြတ် diagonal တန်ဖိုးတွေကို ပေါင်းတာက nested list indexing ရဲ့ လှပတဲ့ ဥပမာတစ်ခုပါ။ Diagonal ပေါ်က element တိုင်းရဲ့ row index နဲ့ column index က တူနေပါတယ် — m[0][0], m[1][1], m[2][2]။

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

diag_sum = 0
for i in range(len(m)):
    diag_sum += m[i][i]

print("Diagonal sum:", diag_sum)

Output:

Diagonal sum: 15

1 + 5 + 9 = 15 ပါ။ Loop တစ်ထပ်တည်းနဲ့ ရတာကို သတိထားပါ — nested loop မလိုပါဘူး၊ ဘာလို့လဲဆိုတော့ diagonal ရဲ့ သဘောတရားအရ index နှစ်ခုက အမြဲ တူညီနေလို့ပါ။ ဒီလို "ပုံစံကို သတိထားမိပြီး loop ကို ရိုးရှင်းအောင် လျှော့တာ" က programmer တစ်ယောက်ရဲ့ အရေးကြီးတဲ့ skill ပါ။

---

အခန်း အကျဉ်းချုပ်

• Nested list ဆိုတာ list ထဲမှာ list တွေ ထပ်ထည့်ထားတာပါ — dimension အသစ် တစ်ခု တိုးလာပါတယ်။
• အတွင်းဆုံး တန်ဖိုးတွေကို chained indexing (seats[1][2]) နဲ့ ခေါ်ပါတယ်။
• Nested list က mutable ဖြစ်တဲ့အတွက် အတွင်းတန်ဖိုးတွေကို နေရာမှာ တင် ပြင်နိုင်ပါတယ်။
• ပတ်နည်း သုံးမျိုး: for-each (အတန်းလိုက်)၊ index-based၊ nested for (အရာတစ်ခုချင်းစီ)။
• append() နဲ့ တစ်တန်းချင်း တည်ဆောက်နိုင်ပါတယ်။
• Matrix အဖြစ် သုံးနိုင်ပါတယ် — row/column အလိုက် ပတ်တာ၊ ပေါင်းတာ၊ transpose လုပ်တာ၊ diagonal ပေါင်းတာတွေ လုပ်နိုင်ပါပြီ။
• copy() က အပြင် list ကိုပဲ ကူးတာမို့ အတွင်းအထိ သီးခြားလိုချင်ရင် deepcopy() သုံးပါ။

နောက်အခန်းမှာ list ရဲ့ "အမွှာ" — tuple ကို လေ့လာပါမယ်။ အယူအဆ အများစုက အတူတူပါပဲ၊ ကွာခြားတာက ပြင်ဆင်လို့ မရတာပါ။ ဒီအခန်းက nested loop ကျွမ်းကျင်မှုက အဲဒီမှာလည်း တိုက်ရိုက် အသုံးဝင်ပါလိမ့်မယ်။

---

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

1. (လွယ်) 3x3 matrix တစ်ခု ကိုယ်တိုင်ဖန်တီးပြီး nested for loop နှစ်ထပ်နဲ့ ဇယားကွက်ပုံစံ print ထုတ်ပါ။ တန်ဖိုးတွေကို ကိုယ်ကြိုက်သလို ရွေးချယ်ပါ။

2. (အလတ်) data = [[3, 1, 4], [1, 5, 9], [2, 6, 5]] ထဲက အကြီးဆုံး တန်ဖိုးနဲ့ အငယ်ဆုံး တန်ဖိုးကို ရှာထုတ်ပါ။ (max()/min() မသုံးရပါ)

3. (အလတ်) nums = [[10, 20], [30, 40, 50], [60]] — အထဲက ကိန်းအားလုံးရဲ့ စုစုပေါင်းကို တွက်ထုတ်ပါ။

4. (ခက်) nested = [[1, 2], [3, 4, 5], [6]] ကို "flatten" လုပ်ပါ — ဆိုလိုတာက [1, 2, 3, 4, 5, 6] ဆိုတဲ့ list အပြား တစ်ခုတည်း ဖြစ်အောင် ပြောင်းပါ။ append() သုံးရပါမယ်။

5. (စိန်ခေါ်မှု) 3x3 matrix တစ်ခုရဲ့ transpose (row နဲ့ column လဲထားတာ) ကို nested list အသစ်အဖြစ် ဖန်တီးပါ။ ဥပမာ [[1, 2, 3], [4, 5, 6], [7, 8, 9]] ရဲ့ transpose က [[1, 4, 7], [2, 5, 8], [3, 6, 9]] ဖြစ်ရပါမယ်။