Chapter 10: Tuple များ (Tuples)

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

---

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

Tuple ဆိုတာ Python ရဲ့ ordered ဖြစ်ပြီး immutable (ပြင်ဆင်လို့မရ) တဲ့ collection တစ်ခုပါ။ ဆက်စပ်နေတဲ့ အချက်အလက်တွေကို အုပ်စုလိုက် စုစည်းထားဖို့ သုံးလေ့ရှိပါတယ်။ List နဲ့ အတော်လေး ဆင်ပေမဲ့ အဓိက ကွာခြားချက် တစ်ခုပဲ ရှိပါတယ် — tuple ကို ဖန်တီးပြီးရင် ပြင်လို့ မရပါဘူး။

ဒီ immutability ကြောင့် tuple ဟာ program တစ်ခုလုံး လည်ပတ်နေစဉ် မပြောင်းသင့်တဲ့ အချက်အလက်တွေအတွက် အကောင်းဆုံး ရွေးချယ်မှုပါ။

Tuple ရဲ့ အဓိက လက္ခဏာတွေ:

လက္ခဏာ	အဓိပ္ပာယ်
Ordered	အရာဝတ္ထုတွေရဲ့ အစဉ်အတိုင်း ထိန်းသိမ်းထားတယ်
Immutable	ဖန်တီးပြီးရင် ထည့်/ဖျက်/ပြင် လုပ်လို့ မရဘူး
Heterogeneous	အမျိုးအစား အမျိုးမျိုး ရောသိမ်းလို့ရတယ်
Duplicates allowed	တန်ဖိုးတူ အရာတွေ ထပ်ပါလို့ရတယ်

List က mutable (ပြင်လို့ရ) ဖြစ်ပြီး tuple က immutable (ပြင်လို့မရ) ဖြစ်တယ် — ဒီတစ်ကြောင်းတည်းက အခန်းတစ်ခုလုံးရဲ့ အနှစ်သာရပါ။

---

Tuple ဖန်တီးခြင်း (Creating Tuples)

Tuple ဖန်တီးဖို့ နည်းလမ်း သုံးမျိုး ရှိပါတယ်။

နည်းလမ်း ၁: Parentheses () သုံးတာ

# tuple အလွတ်
empty_tuple = ()

# ကိန်းပြည့်တွေချည်းပဲ
int_tuple = (1, 2, 3)

# အမျိုးအစား အမျိုးမျိုး ရော
mixed_tuple = (1, "apple", 3.14, True)
print(mixed_tuple)

Output:

(1, 'apple', 3.14, True)

နည်းလမ်း ၂: Parentheses မပါဘဲ (Tuple Packing)

ကော်မာနဲ့ တန်ဖိုးတွေ ဆက်ရေးလိုက်ရုံနဲ့ Python က tuple အဖြစ် အလိုလို ထုပ်ပိုးပေးပါတယ်။ ဒါကို packing လို့ ခေါ်ပါတယ်။

# tuple packing
rgb = 255, 128, 0
print(rgb)
print(type(rgb))

Output:

(255, 128, 0)
<class 'tuple'>

rgb = 255, 128, 0 လို့ ရေးလိုက်တာနဲ့ (255, 128, 0) tuple တစ်ခု ဖြစ်သွားတာပါ။

နည်းလမ်း ၃: tuple() Constructor

ရှိပြီးသား list ဒါမှမဟုတ် string ကနေ tuple ပြောင်းချင်ရင် tuple() ကို သုံးပါတယ်။

# list ကနေ tuple
tuple_from_list = tuple([10, 20, 30])
print(tuple_from_list)

# string ကနေ tuple (စာလုံး တစ်ခုချင်းစီ ခွဲထုတ်ပေးတယ်)
tuple_from_string = tuple("cat")
print(tuple_from_string)

Output:

(10, 20, 30)
('c', 'a', 't')

not_a_tuple = (5)
print(type(not_a_tuple))   # <class 'int'>

real_tuple = (5,)
print(type(real_tuple))    # <class 'tuple'>

---

Tuple မှ အရာဝတ္ထုများ ရယူခြင်း (Indexing and Slicing)

Tuple က ordered ဖြစ်တဲ့အတွက် list လိုပဲ index နဲ့ ခေါ်ထုတ်လို့ရပါတယ်။ 0 ကနေ စတယ်၊ negative index လည်း ရပါတယ်။

scores = (88, 92, 75, 90)

# ပုံမှန် indexing (0-based)
print(scores[1])

# negative indexing (နောက်ဆုံးကနေ)
print(scores[-1])

# slicing
print(scores[1:3])

Output:

92
90
(92, 75)

Slicing ရလဒ်က tuple အသစ် တစ်ခု ပြန်ရတာကို သတိထားပါ — (92, 75) လို့ parentheses နဲ့ ပြပါတယ်။

---

Tuple Operation များ (Concatenation, Repetition, Membership)

+ — Tuple နှစ်ခု ဆက်တာ (Concatenation)

morning = (1, 2)
evening = (3, 4)
print(morning + evening)

Output:

(1, 2, 3, 4)

* — ထပ်ခါထပ်ခါ (Repetition)

pair = (10, 20)
print(pair * 3)

Output:

(10, 20, 10, 20, 10, 20)

in — ပါဝင်မှု စစ်တာ (Membership Test)

vowels = ("a", "e", "i", "o", "u")
print("e" in vowels)
print("z" in vowels)
print("z" not in vowels)

Output:

True
False
True

---

Tuple Method များ (Tuple Methods)

Tuple မှာ method နှစ်ခုပဲ ရှိပါတယ် — immutable ဖြစ်တဲ့အတွက် ပြင်ဆင်တဲ့ method တွေ (append, remove လို) လုံးဝ မပါပါဘူး။

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

t = (7, 3, 7, 9, 7)

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

Output:

3
3

Method နှစ်ခုပဲ ရှိတာက အားနည်းချက် မဟုတ်ပါဘူး — tuple ရဲ့ ရည်ရွယ်ချက်ကိုက "မပြင်ဘဲ သိမ်းထား၊ ဖတ်သုံး" သက်သက်မို့လို့ပါ။

---

Tuple ကို ဘာလို့ သုံးသင့်သလဲ (Why Use Tuples?)

"List ရှိရင် တော်ပြီလေ၊ tuple ဘာလို့ လိုသေးလဲ?" — မေးစရာ ကောင်းတဲ့ မေးခွန်းပါ။ အကြောင်း သုံးချက် ရှိပါတယ်။

၁. Immutability — အချက်အလက် ကာကွယ်မှု

မတော်တဆ ပြင်မိမှာ စိုးရိမ်ရတဲ့ အချက်အလက်တွေအတွက် tuple က အကောင်းဆုံးပါ။ ဥပမာ တစ်ပတ်ရဲ့ ရက်အမည်တွေ၊ လအမည်တွေလို ဘယ်တော့မှ မပြောင်းမယ့် အရာတွေပေါ့။

weekdays = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
# ဘယ်သူမှ မတော်တဆ ဖျက်လို့/ပြင်လို့ မရဘူး

၂. Performance — အနည်းငယ် ပိုမြန်တယ်

Tuple တွေက list တွေထက် memory နည်းနည်းသုံးပြီး အနည်းငယ် ပိုမြန်ပါတယ်။ အချက်အလက် ပမာဏ ကြီးမားတဲ့ program တွေမှာ ဒီကွာခြားချက်က သိသာလာနိုင်ပါတယ်။

၃. Semantic Meaning — အဓိပ္ပာယ် ဖော်ပြမှု

တန်ဖိုးအစုအဝေး တစ်ခုက "ပုံသေ အစုအဝေး" ဆိုတဲ့ အဓိပ္ပာယ်ကို tuple က သူ့ဘာသာ ဖော်ပြပါတယ်။ ဥပမာ မြေပုံ coordinates:

# ရန်ကုန်မြို့ရဲ့ coordinates (latitude, longitude)
yangon = (16.84, 96.17)
print(f"Yangon: {yangon[0]}, {yangon[1]}")

Output:

Yangon: 16.84, 96.17

(16.84, 96.17) ကို tuple နဲ့ ရေးထားတာကို မြင်တာနဲ့ "ဒါက တွဲဖက် တန်ဖိုးတစ်စုံ၊ ပြင်ဖို့ မရည်ရွယ်ဘူး" ဆိုတာ code ဖတ်သူက တန်းသိပါတယ်။ List နဲ့ ရေးထားရင် ဒီအဓိပ္ပာယ် ပျောက်သွားပါမယ်။

---

Unpacking (တန်ဖိုးတွေ ခွဲထုတ်ခြင်း)

Tuple ရဲ့ element တွေကို variable တွေထဲ တစ်ခါတည်း ခွဲထည့်တာကို unpacking လို့ ခေါ်ပါတယ်။

person = ("Aung", 28, "Teacher")

name, age, job = person

print(name)
print(age)
print(job)

Output:

Aung
28
Teacher

name, age, job = person တစ်ကြောင်းတည်းနဲ့ tuple ထဲက တန်ဖိုးသုံးခုက variable သုံးခုထဲ အစဉ်လိုက် ရောက်သွားပါတယ်။ Variable အရေအတွက်နဲ့ tuple အရာအရေအတွက် တူရပါမယ် — မတူရင် ValueError တက်ပါတယ်။

Unpacking က function ကနေ တန်ဖိုးအများကြီး ပြန်ပေးတဲ့အခါလည်း အရမ်း အသုံးဝင်ပါတယ်။

def get_stats(numbers):
    return min(numbers), max(numbers), sum(numbers) / len(numbers)

lowest, highest, average = get_stats([80, 95, 70, 88])
print(lowest, highest, average)

Output:

70 95 83.25

---

Mini Project: Movie Catalog Manager

အခန်းရဲ့ အနှစ်သာရကို စုစည်းပြီး Movie Catalog Manager program လေး ရေးကြည့်ရအောင်။ ရုပ်ရှင်တစ်ကားချင်းစီကို (title, genre, year) tuple အနေနဲ့ သိမ်းထားပါတယ် — ရုပ်ရှင်ရဲ့ အချက်အလက်က မပြောင်းသင့်တဲ့ "ပုံသေအစုအဝေး" မို့လို့ tuple က အကိုက်ဆုံးပါ။

movies = [
    ("Inception", "Sci-Fi", 2010),
    ("Titanic", "Romance", 1997),
    ("The Matrix", "Sci-Fi", 1999)
]

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

    if choice == "1":
        if not movies:
            print("ရုပ်ရှင် မရှိသေးပါ။")
        else:
            print("\n--- Movie List ---")
            for i, movie in enumerate(movies, 1):
                print(f"{i}. {movie[0]} | {movie[1]} | {movie[2]}")

    elif choice == "2":
        title = input("ရုပ်ရှင် ခေါင်းစဉ်: ")
        genre = input("အမျိုးအစား: ")
        year = input("ထွက်ရှိသည့် နှစ်: ")
        movies.append((title, genre, year))
        print("ထည့်ပြီးပါပြီ!")

    elif choice == "3":
        search_title = input("ရှာမည့် ခေါင်းစဉ်: ")
        found = False
        for movie in movies:
            if movie[0].lower() == search_title.lower():
                print(f"တွေ့ပြီ: Title: {movie[0]}, Genre: {movie[1]}, Year: {movie[2]}")
                found = True
                break
        if not found:
            print("မတွေ့ပါ။")

    elif choice == "4":
        print("ထွက်ပါပြီ။")
        break

    else:
        print("1 မှ 4 အတွင်း ရွေးပါ။")

နမူနာ အသုံးပြုပုံ (ရွေးချယ်မှု 3):

ရွေးချယ်ပါ (1-4): 3
ရှာမည့် ခေါင်းစဉ်: titanic
တွေ့ပြီ: Title: Titanic, Genre: Romance, Year: 1997

---

Tuple နှင့် List: ဘယ်ဟာ ရွေးမလဲ

အခန်း ၈ (list) နဲ့ အခန်း ၁၀ (tuple) ပြီး သွားတဲ့အခါ မေးစရာ ရှိလာပါပြီ — "ဘယ်အချိန်မှာ ဘယ်ဟာ သုံးရမလဲ?" ဆုံးဖြတ်ဖို့ လမ်းညွှန်ဇယားလေး ထားပေးပါမယ်။

အခြေအနေ	သုံးသင့်တာ	အကြောင်းရင်း
အချက်အလက် ထည့်/ဖျက်/ပြင် လုပ်ရမယ်	List	Mutable ဖြစ်တယ်
အချက်အလက် မပြောင်းသင့်ဘူး	Tuple	Immutable — မတော်တဆ ပြင်မိမှာ ကာကွယ်တယ်
(x, y) coordinates လို တွဲဖက်တန်ဖိုး	Tuple	"ပုံသေအစုအဝေး" ဆိုတဲ့ အဓိပ္ပာယ် ဖော်ပြတယ်
အစဉ်လိုက် စီရမယ် / ပြောင်းပြန်လှန်ရမယ်	List	sort(), reverse() method တွေရှိတယ်
Dictionary ရဲ့ key အဖြစ် သုံးချင်တယ်	Tuple	Immutable မို့လို့သာ key လုပ်လို့ရတယ် (list က မရဘူး)
အမြန်နှုန်း အနည်းငယ် ပိုလိုချင်တယ်	Tuple	Memory နည်းပြီး အနည်းငယ် ပိုမြန်တယ်

စည်းမျဉ်း အတိုချုပ်အနေနဲ့: "ပြင်ဦးမလား?" လို့ ကိုယ့်ကိုယ်ကို မေးပါ။ ပြင်မယ်ဆို list၊ မပြင်ဘူးဆို tuple။ မသေချာရင် list နဲ့ စပါ — နောက်မှ tuple ပြောင်းလို့ရပါတယ် (tuple(my_list)).

---

Unpacking အဆင့်မြင့် (Extended Unpacking နှင့် Swapping)

အခြေခံ unpacking အပြင် အဆင်ပြေတဲ့ လှည့်ကွက် နှစ်ခု ရှိပါသေးတယ်။

* ဖြင့် ကျန်တာအကုန် ယူတာ

first, *rest = (10, 20, 30, 40)
print(first)
print(rest)

Output:

10
[20, 30, 40]

*rest က ပထမတစ်ခုကလွဲပြီး ကျန်တဲ့ တန်ဖိုးအားလုံးကို list အနေနဲ့ စုယူသွားပါတယ်။ Tuple အရှည် အတိအကျ မသိတဲ့အခါ အသုံးဝင်ပါတယ်။

Variable နှစ်ခု တန်ဖိုးချင်းလဲတာ (Swapping)

တခြား language တွေမှာ variable နှစ်ခုရဲ့ တန်ဖိုးချင်းလဲဖို့ ကြားခံ variable တစ်ခု လိုပါတယ်။ Python မှာတော့ packing/unpacking နဲ့ တစ်ကြောင်းတည်း ရပါတယ်။

x, y = 5, 10
print("မလဲခင်:", x, y)

x, y = y, x   # ညာဘက်က tuple ဖန်တီးပြီး ဘယ်ဘက်ကို unpack လုပ်
print("လဲပြီးနောက်:", x, y)

Output:

မလဲခင်: 5 10
လဲပြီးနောက်: 10 5

x, y = y, x ရဲ့ ညာဘက်ခြမ်းက အရင် (10, 5) tuple အဖြစ် အကဲဖြတ်ခံရပြီး ပြီးမှ ဘယ်ဘက်ကို unpack လုပ်တာပါ။ ဒါကြောင့် တန်ဖိုးတွေ မပျောက်ဘဲ လဲသွားတာပါ။

---

Tuple တွေကို Loop နဲ့ တွဲသုံးခြင်း

Tuple တစ်ခုတည်းကို ပတ်တာအပြင်၊ tuple တွေရဲ့ list ကို unpacking နဲ့ တွဲပတ်တာက လက်တွေ့မှာ အရမ်း အသုံးဝင်ပါတယ်။

fruits = ("apple", "banana", "mango")

# enumerate နဲ့ နံပါတ်တပ် ပတ်တာ
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")

Output:

0: apple
1: banana
2: mango

Tuple တွေပါတဲ့ list ကို ပတ်တဲ့အခါ loop variable မှာတင် unpack လုပ်လို့ရပါတယ်။

scores = [("Aung", 85), ("May", 92), ("Zaw", 78)]

for name, score in scores:
    print(f"{name} got {score}")

Output:

Aung got 85
May got 92
Zaw got 78

for name, score in scores ဆိုတာ တစ်ပတ်ချင်းစီမှာ tuple တစ်ခုကို ယူပြီး name နဲ့ score အလိုလို unpack လုပ်သွားတာပါ။ ဒီပုံစံက database record တွေ၊ CSV row တွေ ကိုင်တွယ်တဲ့အခါ ခဏခဏ တွေ့ရပါလိမ့်မယ်။

---

Immutability ကို ကိုယ်တိုင် စမ်းကြည့်ခြင်း

"ပြင်လို့ မရဘူး" ဆိုတာကို စာနဲ့ဖတ်တာထက် ကိုယ်တိုင် error တက်အောင် လုပ်ကြည့်တာ ပိုမှတ်မိပါတယ်။

point = (3, 4)
point[0] = 10   # လုပ်ကြည့်ပါ — ဘာဖြစ်မလဲ?

Output:

TypeError: 'tuple' object does not support item assignment

Python က ရှင်းရှင်းလင်းလင်း ပြောပါတယ် — "tuple object က item assignment ကို ထောက်ပံ့မပေးဘူး" တဲ့။ ဒီ error ကို မြင်ဖူးထားရင် နောင်မှာ ကိုယ့် code မှာ ဒီ error ပေါ်လာရင် "အော်၊ tuple ကို ပြင်မိသွားတာကိုး" လို့ ချက်ချင်း သိပါလိမ့်မယ်။

append() လို method တွေလည်း tuple မှာ မရှိပါဘူး။

colors = ("red", "blue")
# colors.append("green")   # AttributeError: 'tuple' object has no attribute 'append'

---

count() နှင့် index() လက်တွေ့ ဥပမာ

count() နဲ့ index() နှစ်ခုတည်းနဲ့ အဖြေထုတ်လို့ရတဲ့ လက်တွေ့ ဥပမာလေး ကြည့်ရအောင် — စစ်တမ်း အဖြေတွေ ရေတွက်တာပါ။

responses = ("yes", "no", "yes", "maybe", "yes", "no", "yes")

print("yes:", responses.count("yes"))
print("no:", responses.count("no"))
print("maybe:", responses.count("maybe"))

first_no = responses.index("no")
print("ပထမဆုံး 'no' က index", first_no, "မှာ ရှိတယ်")

Output:

yes: 4
no: 2
maybe: 1
ပထမဆုံး 'no' က index 1 မှာ ရှိတယ်

Method နှစ်ခုတည်း ရှိပေမဲ့ ဒီလို အချက်အလက် အကျဉ်းချုပ် (summary) ထုတ်တဲ့ နေရာမှာ လုံလောက်ပါတယ်။ Tuple က "ဖတ်သုံး" သက်သက်မို့လို့ လိုအပ်တဲ့ tool ကလည်း ဒီနှစ်ခုပဲ ဖြစ်နေတာပါ — ဒီဇိုင်း ရည်ရွယ်ချက်နဲ့ ကိုက်ညီပါတယ်။

---

မေးလေ့ရှိတဲ့ မေးခွန်းများ (FAQ)

မေး: Tuple ထဲက element တစ်ခုကို တကယ် ပြင်ချင်ရင် ဘယ်လို လုပ်မလဲ? ဖြေ: အသန့်ရှင်းဆုံးနည်းက list အဖြစ် ပြောင်း → ပြင် → tuple ပြန်ထုပ်တာပါ (အခန်း ၁၁ မှာ အသေးစိတ် သင်ပါမယ်)။ ဒါမှမဟုတ် အစကတည်းက list သုံးပါ။

မေး: List နဲ့ tuple ဘယ်ဟာ ပိုမြန်လဲ? ဖြေ: Tuple က အနည်းငယ် ပိုမြန်ပြီး memory လည်း နည်းနည်း သက်သာပါတယ်။ ဒါပေမဲ့ program အသေးတွေမှာ ကွာခြားချက်က မသိသာပါဘူး — ရွေးချယ်ရတဲ့ အဓိက အကြောင်းရင်းက အမြန်နှုန်း မဟုတ်ဘဲ "ပြင်မယ်/မပြင်ဘူး" ဆိုတဲ့ ရည်ရွယ်ချက်ပါ။

မေး: () အလွတ် tuple က ဘာအသုံးဝင်လဲ? ဖြေ: နေရာယူထားတဲ့ အလွတ် တန်ဖိုးအနေနဲ့ သုံးပါတယ်။ ဥပမာ function က "ဘာမှ မတွေ့ဘူး" လို့ ပြန်ပြောချင်တဲ့အခါ () ပြန်ပေးတာက "ရလဒ် အစုအဝေး အလွတ်" ဆိုတဲ့ အဓိပ္ပာယ်ကို ရှင်းရှင်းလင်းလင်း ဖော်ပြပါတယ်။

မေး: Tuple ထဲမှာ list ထည့်လို့ရလား? ဖြေ: ရပါတယ်! ("May", [85, 90], 20) လို ရေးလို့ရပါတယ်။ အဲဒီ list ရဲ့ အတွင်းတန်ဖိုးတွေကိုတော့ ပြင်လို့ရပါတယ် — ဒီအကြောင်းကို အခန်း ၁၁ (Nested Tuple) မှာ အသေးစိတ် လေ့လာပါမယ်။

---

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

• Tuple ဆိုတာ ordered + immutable collection ပါ — list နဲ့ အဓိက ကွာခြားချက်က ပြင်ဆင်လို့ မရတာပါ။
• ဖန်တီးနည်း သုံးမျိုး: ()၊ packing (x = 1, 2)၊ tuple() constructor။
• Indexing/slicing က list လိုပါပဲ (0-based၊ negative index ရပါတယ်)။
• Operator တွေ: + (ဆက်)၊ * (ထပ်)၊ in (ပါဝင်မှု စစ်) — အားလုံး အသစ်ဖန်တီးပေးတာပါ။
• Method နှစ်ခုပဲ: count() နဲ့ index()။
• သုံးသင့်တဲ့ အခြေအနေ: မပြောင်းသင့်တဲ့ အချက်အလက်၊ coordinates လို တွဲဖက်တန်ဖိုး၊ dictionary key။
• Unpacking (name, age, job = person) နဲ့ တန်ဖိုးတွေ ခွဲထုတ်နိုင်ပါတယ်။
• ရွေးချယ်မှု စည်းမျဉ်း: "ပြင်ဦးမလား?" — ပြင်မယ်ဆို list၊ မပြင်ဘူးဆို tuple။

နောက်အခန်းမှာ tuple ထဲမှာ tuple ထပ်ထည့်တဲ့ nested tuple ကို လေ့လာပါမယ်။

---

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

1. (လွယ်) weekdays = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun") tuple တစ်ခု ဖန်တီးပြီး index 3 မှာရှိတဲ့ ရက်ကို print ထုတ်ပါ။ ပြီးရင် negative index နဲ့ စနေနေ့ကို ထုတ်ကြည့်ပါ။

2. (အလတ်) a = (5, 10) နဲ့ b = (15, 20) ဆိုတဲ့ tuple နှစ်ခု ရှိတယ်။ နှစ်ခုကို ဆက်ပြီး (5, 10, 15, 20) ရအောင် လုပ်ပါ။ ပြီးရင် a ကို ၃ ခါ ထပ်ပြီး ရလဒ် print ထုတ်ပါ။

3. (အလတ်) rgb = (255, 128, 0) ကို unpacking သုံးပြီး red, green, blue variable သုံးခုထဲ ခွဲထည့်ပါ။ ပြီးရင် f"R={red} G={green} B={blue}" လို့ print ထုတ်ပါ။

4. (ခက်) scores = (88, 92, 88, 75, 92, 88) ထဲမှာ အကြိမ်ရေ အများဆုံး ပါတဲ့ အမှတ်ကို count() သုံးပြီး ရှာထုတ်ပါ။ (အကြံပြု: တစ်မူထူးခြားတဲ့ တန်ဖိုးတိုင်းကို count() နဲ့ စစ်ပြီး အများဆုံးကို မှတ်ထားပါ)

5. (စိန်ခေါ်မှု) players = [("Aung", 150), ("May", 200), ("Zaw", 175)] — (အမည်, ရမှတ်) tuple တွေရဲ့ list ပါ။ ရမှတ် အမြင့်ဆုံး ကစားသမားရဲ့ tuple အပြည့်အစုံကို print ထုတ်ပါ။ (အကြံပြု: unpacking နဲ့ loop တွဲသုံးပါ)