EP06: โครงสร้างข้อมูลพื้นฐาน: ลิสต์และทูเพิล

(1) ทบทวนความรู้เดิม

• ชนิดข้อมูลพื้นฐาน (Basic Data Types): int, float, str, bool
• ตัวแปร (Variables): การประกาศ, การกำหนดค่า
• โครงสร้างควบคุมแบบวนซ้ำ (for loop): การใช้ for กับ range() และการวนซ้ำกับสตริง เนื่องจากลิสต์และทูเพิลเป็นลำดับข้อมูล (sequences) ที่ for loop สามารถวนซ้ำได้ดี

(2) แนวคิดเรื่องโครงสร้างข้อมูลแบบกลุ่ม (Collection Data Structures)

• ทำไมเราถึงต้องการโครงสร้างข้อมูลแบบกลุ่ม?
  • เมื่อต้องการจัดเก็บข้อมูลหลายๆ ชิ้นที่เกี่ยวข้องกันไว้ภายใต้ชื่อตัวแปรเดียว เช่น รายชื่อนักเรียนในห้อง, รายการสินค้าที่สั่งซื้อ, ชุดของคะแนนสอบของนักเรียนคนหนึ่ง, พิกัดบนแผนที่ (x, y)
  • ช่วยให้การจัดการข้อมูลเป็นระบบและเข้าถึงได้ง่ายขึ้น
• ประเภทของโครงสร้างข้อมูลแบบกลุ่มใน Python: แนะนำภาพรวมว่า Python มีหลายแบบ (Lists, Tuples, Dictionaries, Sets) และหน่วยนี้จะเน้นที่ Lists และ Tuples

(3) ลิสต์ (Lists) ใน Python: ลำดับข้อมูลที่เปลี่ยนแปลงได้ (Mutable Ordered Sequences)

• คุณสมบัติของลิสต์:
  • เป็นลำดับ (Ordered): สมาชิกในลิสต์จะมีการจัดเรียงตามลำดับที่เราใส่เข้าไป และลำดับนั้นจะไม่เปลี่ยนแปลงเอง ( trừ khiเราสั่งให้เปลี่ยน) สมาชิกแต่ละตัวจะมี ดัชนี (index) ประจำตำแหน่ง
  • เปลี่ยนแปลงได้ (Mutable): เราสามารถเพิ่ม, ลบ, หรือแก้ไขค่าของสมาชิกในลิสต์ได้ หลังจาก ที่ลิสต์ถูกสร้างขึ้นแล้ว
  • เก็บข้อมูลต่างชนิดได้ (Heterogeneous): สมาชิกในลิสต์เดียวกันสามารถเป็นข้อมูลต่างชนิดกันได้ เช่น my_info = ["John Doe", 30, 175.5, True]
• การสร้างลิสต์ (Creating Lists):
  • ใช้เครื่องหมายวงเล็บเหลี่ยม []:
    • ลิสต์ว่าง (Empty list): empty_list = []
    • ลิสต์ที่มีสมาชิก: numbers = [10, 20, 30, 40], fruits = ["apple", "banana", "cherry"]
  • ใช้ฟังก์ชัน list():
    • สร้างลิสต์ว่าง: another_empty_list = list()
    • แปลงข้อมูลประเภทอื่นให้เป็นลิสต์ (เช่น สตริง, range, ทูเพิล):
      • chars = list("hello") จะได้ ['h', 'e', 'l', 'l', 'o']
      • num_range = list(range(5)) จะได้ [0, 1, 2, 3, 4]
• การเข้าถึงสมาชิกในลิสต์ (Accessing Elements):
  • ดัชนี (Indexing):
    • ดัชนีแบบบวก (Positive Indexing): เริ่มจาก 0 สำหรับสมาชิกตัวแรก, 1 สำหรับตัวที่สอง, ไปเรื่อยๆ
      • ตัวอย่าง: fruits = ["apple", "banana", "cherry"]
        • fruits[0] คือ "apple"
        • fruits[1] คือ "banana"
    • ดัชนีแบบลบ (Negative Indexing): เริ่มจาก -1 สำหรับสมาชิกตัวสุดท้าย, -2 สำหรับตัวรองสุดท้าย, ไปเรื่อยๆ
      • ตัวอย่าง: fruits = ["apple", "banana", "cherry"]
        • fruits[-1] คือ "cherry"
        • fruits[-2] คือ "banana"
    • IndexError: จะเกิดขึ้นถ้าเราระบุดัชนีที่อยู่นอกขอบเขตของลิสต์ (เช่น ลิสต์มี 3 สมาชิก แต่เรียก fruits[3])
  • การตัดส่วนของลิสต์ (Slicing):list_name[start:stop:step]
    • start: ดัชนีเริ่มต้น (รวมสมาชิก ณ ตำแหน่งนี้ด้วย) หากไม่ระบุ จะเริ่มจากตัวแรก (ดัชนี 0)
    • stop: ดัชนีสิ้นสุด (ไม่รวมสมาชิก ณ ตำแหน่งนี้) หากไม่ระบุ จะไปจนถึงตัวสุดท้ายของลิสต์
    • step: ระยะก้าวในการเลือกสมาชิก (ค่า default คือ 1) ถ้าเป็นค่าลบจะเป็นการตัดจากท้ายมาหน้า
    • ผลลัพธ์ของ Slicing จะเป็นลิสต์ใหม่เสมอ
    • ตัวอย่าง:numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      • numbers[2:5] จะได้ [2, 3, 4] (ดัชนี 2, 3, 4)
      • numbers[:3] จะได้ [0, 1, 2] (3 ตัวแรก)
      • numbers[5:] จะได้ [5, 6, 7, 8, 9] (ตั้งแต่ดัชนี 5 จนจบ)
      • numbers[1:7:2] จะได้ [1, 3, 5] (เริ่มที่ 1, ถึงก่อน 7, ก้าวทีละ 2)
      • numbers[::-1] จะได้ [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (ลิสต์กลับหัว)
• การวนซ้ำกับลิสต์ (Iterating through Lists) โดยใช้ for loop:

colors = ["red", "green", "blue"]
for color in colors:
    print(color)
# Output:
# red
# green
# blue

# วนซ้ำพร้อมดัชนีด้วย enumerate()
for index, color in enumerate(colors):
    print(f"Index {index}: {color}")
# Output:
# Index 0: red
# Index 1: green
# Index 2: blue

• การดำเนินการพื้นฐานกับลิสต์ (Basic List Operations):
  • การต่อลิสต์ (Concatenation): ใช้เครื่องหมาย +
    • list1 = [1, 2], list2 = [3, 4]
    • combined_list = list1 + list2 จะได้ [1, 2, 3, 4]
  • การทำซ้ำสมาชิก (Repetition): ใช้เครื่องหมาย *
    • my_list = ["hi"] * 3 จะได้ ['hi', 'hi', 'hi']
  • การตรวจสอบการเป็นสมาชิก (Membership Test): ใช้ in หรือ not in
    • fruits = ["apple", "banana"]
    • "apple" in fruits จะได้ True
    • "orange" not in fruits จะได้ True
• ฟังก์ชันที่ใช้กับลิสต์ (Built-in Functions for Lists):
  • len(list_name): คืนจำนวนสมาชิกในลิสต์
  • min(list_name), max(list_name): คืนค่าสมาชิกที่น้อยที่สุดหรือมากที่สุด (ใช้ได้กับลิสต์ที่สมาชิกเปรียบเทียบกันได้ เช่น ตัวเลขทั้งหมด หรือ สตริงทั้งหมด)
  • sum(list_name): คืนผลรวมของสมาชิกทั้งหมดในลิสต์ (ใช้ได้กับลิสต์ของตัวเลขเท่านั้น)
  • sorted(list_name): คืนค่าเป็น ลิสต์ใหม่ ที่สมาชิกถูกเรียงลำดับจากน้อยไปมาก (ลิสต์เดิมไม่เปลี่ยนแปลง)
    • sorted(list_name, reverse=True): เรียงจากมากไปน้อย
• เมธอดที่สำคัญของลิสต์ (Common List Methods) – เหล่านี้จะเปลี่ยนแปลงลิสต์ต้นฉบับ (in-place modification):
  • การเพิ่มสมาชิก:
    • list_name.append(item): เพิ่ม item เข้าไปต่อท้ายลิสต์
      • fruits.append("orange")
    • list_name.insert(index, item): แทรก item เข้าไป ณ ตำแหน่ง index ที่ระบุ สมาชิกเดิมจะถูกเลื่อนไปทางขวา
      • fruits.insert(1, "grape") # แทรก “grape” ที่ตำแหน่ง 1
    • list_name.extend(another_iterable): เพิ่มสมาชิกทุกตัวจาก another_iterable (เช่น ลิสต์อื่น, ทูเพิล, สตริง) เข้าไปต่อท้ายลิสต์ปัจจุบัน
      • more_fruits = ["mango", "papaya"], fruits.extend(more_fruits)
  • การแก้ไขสมาชิก:
    • list_name[index] = new_value: เปลี่ยนค่าสมาชิก ณ ตำแหน่ง index เป็น new_value
      • fruits[0] = "pineapple"
  • การลบสมาชิก:
    • list_name.pop(): ลบและคืนค่าสมาชิก ตัวสุดท้าย ของลิสต์ (ถ้าลิสต์ว่างจะเกิด IndexError)
    • list_name.pop(index): ลบและคืนค่าสมาชิก ณ ตำแหน่ง index ที่ระบุ
    • list_name.remove(value): ลบสมาชิกตัวแรกที่พบว่ามีค่าเท่ากับ value (ถ้าไม่เจอ value นั้นในลิสต์ จะเกิด ValueError)
    • del list_name[index]: ลบสมาชิก ณ ตำแหน่ง index (เป็นคำสั่ง ไม่ใช่เมธอด)
    • del list_name[start:stop]: ลบสมาชิกในช่วงที่กำหนด (slice)
    • list_name.clear(): ลบสมาชิกทั้งหมดออกจากลิสต์ ทำให้กลายเป็นลิสต์ว่าง
  • การค้นหาและนับ:
    • list_name.index(value): คืนค่าดัชนีของสมาชิกตัวแรกที่พบว่ามีค่าเท่ากับ value (ถ้าไม่เจอจะเกิด ValueError)
    • list_name.index(value, start_index): ค้นหาตั้งแต่ start_index เป็นต้นไป
    • list_name.count(value): คืนจำนวนครั้งที่ value ปรากฏในลิสต์
  • การจัดเรียงและกลับลำดับ (แก้ไขลิสต์โดยตรง):
    • list_name.sort(): เรียงลำดับสมาชิกในลิสต์จากน้อยไปมาก (สำหรับตัวเลข) หรือตามลำดับพจนานุกรม (สำหรับสตริง) ลิสต์เดิมจะถูกแก้ไข
    • list_name.sort(reverse=True): เรียงลำดับจากมากไปน้อย ลิสต์เดิมจะถูกแก้ไข
    • list_name.reverse(): กลับลำดับของสมาชิกในลิสต์ ลิสต์เดิมจะถูกแก้ไข
  • การคัดลอกลิสต์ (Copying Lists):
    • การกำหนดค่าแบบปกติ (new_list = old_list): new_list และ old_list จะชี้ไปที่อ็อบเจกต์ลิสต์เดียวกันในหน่วยความจำ การแก้ไขผ่านชื่อใดชื่อหนึ่งจะมีผลกับอีกชื่อหนึ่งด้วย (เรียกว่า Aliasing)
    • การคัดลอกแบบตื้น (Shallow Copy): สร้างอ็อบเจกต์ลิสต์ใหม่ แต่ถ้าสมาชิกในลิสต์เป็นอ็อบเจกต์ที่เปลี่ยนแปลงได้ (เช่น ลิสต์ซ้อนลิสต์) สมาชิกเหล่านั้นจะยังคงเป็นการอ้างอิงถึงอ็อบเจกต์เดิม
      • new_list = old_list.copy() (ใช้เมธอด copy())
      • new_list = old_list[:] (ใช้ Slicing ทั้งหมด)
      • new_list = list(old_list) (ใช้ฟังก์ชัน list())

(4) ทูเพิล (Tuples) ใน Python: ลำดับข้อมูลที่เปลี่ยนแปลงไม่ได้ (Immutable Ordered Sequences)

• คุณสมบัติของทูเพิล:
  • เป็นลำดับ (Ordered): เหมือนลิสต์ สมาชิกมีการเรียงลำดับและมีดัชนี
  • เปลี่ยนแปลงไม่ได้ (Immutable): ข้อแตกต่างสำคัญจากลิสต์ เมื่อสร้างทูเพิลขึ้นมาแล้ว จะไม่สามารถเพิ่ม, ลบ, หรือแก้ไขค่าของสมาชิกภายในทูเพิลนั้นได้
  • เก็บข้อมูลต่างชนิดได้ (Heterogeneous): เหมือนลิสต์
• การสร้างทูเพิล (Creating Tuples):
  • ใช้เครื่องหมายวงเล็บ ():
    • ทูเพิลว่าง (Empty tuple): empty_tuple = ()
    • ทูเพิลที่มีสมาชิก: numbers = (10, 20, 30), point = (5, 8)
  • ใช้ฟังก์ชัน tuple():
    • สร้างทูเพิลว่าง: another_empty_tuple = tuple()
    • แปลงข้อมูลประเภทอื่นให้เป็นทูเพิล: chars_tuple = tuple("hello") จะได้ ('h', 'e', 'l', 'l', 'o')
  • กรณีสมาชิกตัวเดียว (Single-element tuple):ต้องมีเครื่องหมายจุลภาค (comma) ต่อท้ายสมาชิกตัวนั้น มิฉะนั้น Python จะมองว่าเป็นเพียงค่าที่อยู่ในวงเล็บ ไม่ใช่ทูเพิล
    • single_val_tuple = (10,) # นี่คือทูเพิลที่มีสมาชิกตัวเดียว
    • not_a_tuple = (10) # นี่คือตัวแปรชนิด int ที่มีค่า 10
  • สร้างทูเพิลโดยไม่ใช้วงเล็บ (Tuple Packing): สามารถทำได้ถ้าไวยากรณ์ไม่กำกวม Python จะรวมค่าที่คั่นด้วยจุลภาคเป็นทูเพิลโดยอัตโนมัติ
    • my_data = 10, "Alice", 3.14 # my_data จะเป็น (10, "Alice", 3.14)
• การเข้าถึงสมาชิกในทูเพิล (Accessing Elements):
  • ดัชนี (Indexing) และ การตัดส่วน (Slicing): ทำได้เหมือนกับลิสต์ทุกประการ เพราะทั้งคู่เป็นลำดับ
• การวนซ้ำกับทูเพิล (Iterating through Tuples): ใช้ for loop เหมือนกับลิสต์ P

coordinates = (10, 20, 30)
for coord in coordinates:
    print(coord)

• การดำเนินการพื้นฐานกับทูเพิล (Basic Tuple Operations):
  • การต่อทูเพิล (Concatenation): + (จะสร้างทูเพิลใหม่ขึ้นมา)
    • tuple1 = (1, 2), tuple2 = (3, 4)
    • combined_tuple = tuple1 + tuple2 จะได้ (1, 2, 3, 4)
  • การทำซ้ำสมาชิก (Repetition): * (จะสร้างทูเพิลใหม่ขึ้นมา)
    • signal = ("ON",) * 3 จะได้ ('ON', 'ON', 'ON')
  • การตรวจสอบการเป็นสมาชิก (Membership Test): in, not in (เหมือนลิสต์)
• ฟังก์ชันที่ใช้กับทูเพิล: len(), min(), max(), sum(), sorted() (ซึ่งจะคืนค่าเป็นลิสต์ที่เรียงลำดับแล้วเสมอ)
• เมธอดของทูเพิล (Tuple Methods): เนื่องจากทูเพิลเปลี่ยนแปลงไม่ได้ จึงมีเมธอดน้อยกว่าลิสต์มาก
  • my_tuple.count(value): คืนจำนวนครั้งที่ value ปรากฏในทูเพิล
  • my_tuple.index(value): คืนค่าดัชนีของสมาชิกตัวแรกที่พบว่ามีค่าเท่ากับ value (ถ้าไม่เจอจะเกิด ValueError)
• การ Unpacking ทูเพิล (Tuple Unpacking): เป็นการกำหนดค่าสมาชิกแต่ละตัวในทูเพิล (หรือลิสต์) ให้กับตัวแปรหลายตัวพร้อมกัน จำนวนตัวแปรทางซ้ายต้องเท่ากับจำนวนสมาชิกในทูเพิล/ลิสต์

student_info = ("Anucha", 21, "Engineering")
name, age, faculty = student_info
print(f"Name: {name}, Age: {age}, Faculty: {faculty}")
# Output: Name: Anucha, Age: 21, Faculty: Engineering

(5) ความแตกต่างระหว่างลิสต์ (Lists) และ ทูเพิล (Tuples) และสถานการณ์การใช้งาน

• เมื่อไหร่ควรใช้ List?
  • เมื่อข้อมูลในกลุ่มมีการเปลี่ยนแปลง (เพิ่ม, ลบ, แก้ไข) บ่อยครั้ง
  • เมื่อต้องการใช้เมธอดที่หลากหลายในการจัดการข้อมูล เช่น sort(), append(), remove()
• เมื่อไหร่ควรใช้ Tuple?
  • เมื่อข้อมูลในกลุ่มเป็นค่าคงที่ ไม่ควรมีการเปลี่ยนแปลงหลังสร้างเสร็จ เพื่อความปลอดภัยของข้อมูล
  • เมื่อต้องการใช้เป็น Key ใน Dictionary
  • เมื่อต้องการส่งคืนค่าหลายค่าจากฟังก์ชัน (Python มักจะทำเป็น Tuple โดยอัตโนมัติ)
  • เมื่อต้องการประสิทธิภาพที่สูงขึ้นเล็กน้อย (ในบางกรณี) สำหรับข้อมูลที่ไม่เปลี่ยนแปลง

• ปฏิบัติการที่ 1: สร้างและเข้าถึงลิสต์ 🛍️
  1. โจทย์ 1.1: ลิสต์เพื่อนของฉัน:
     • สร้างลิสต์ชื่อ friends เก็บชื่อเพื่อนของคุณอย่างน้อย 4 คน
     • แสดงผลลิสต์ friends ทั้งหมด
     • แสดงผลชื่อเพื่อนคนที่สองในลิสต์
     • แสดงผลชื่อเพื่อนคนสุดท้ายในลิสต์โดยใช้ดัชนีแบบลบ
     • แสดงผลจำนวนเพื่อนทั้งหมดในลิสต์
  2. โจทย์ 1.2: ตัดมาดูหน่อยซิ:
     • สร้างลิสต์ weekdays = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
     • ใช้ Slicing เพื่อสร้างลิสต์ใหม่ workdays ที่มีเฉพาะ “Mon” ถึง “Fri” แล้วแสดงผล
     • ใช้ Slicing เพื่อสร้างลิสต์ใหม่ weekend ที่มีเฉพาะ “Sat” และ “Sun” แล้วแสดงผล
     • ใช้ Slicing เพื่อแสดงผลวันในสัปดาห์แบบวันเว้นวัน เริ่มจาก “Mon” (["Mon", "Wed", "Fri", "Sun"])
     • ใช้ Slicing เพื่อแสดงผลลิสต์ weekdays แบบกลับหัว
• ปฏิบัติการที่ 2: จัดการสมาชิกในลิสต์ ✏️🗑️➕
  1. โจทย์ 2.1: รายการซื้อของ:
     • สร้างลิสต์ว่างชื่อ shopping_list
     • ใช้เมธอด append() เพิ่ม “ไข่ไก่”, “นมสด”, “ขนมปัง” เข้าไปใน shopping_list ทีละรายการ แล้วแสดงผลลิสต์ทุกครั้งที่เพิ่ม
     • ใช้เมธอด insert() แทรก “น้ำส้ม” เข้าไปเป็นรายการที่สอง (ดัชนี 1) ของลิสต์ แล้วแสดงผล
     • แก้ไขรายการ “ขนมปัง” เป็น “ขนมปังโฮลวีต” แล้วแสดงผล
  2. โจทย์ 2.2: จัดการคลังสินค้า (สมมติ):
     • สร้างลิสต์ inventory = ["ปากกา", "ดินสอ", "ยางลบ", "ไม้บรรทัด", "สมุด"]
     • ลูกค้าซื้อ “ยางลบ” ไป: ใช้เมธอด remove() เพื่อลบ “ยางลบ” ออกจากลิสต์ แล้วแสดงผล
     • สินค้าชิ้นสุดท้ายถูกขายไป: ใช้เมธอด pop() เพื่อลบสินค้าชิ้นสุดท้ายออกจากลิสต์ แล้วแสดงผลทั้งลิสต์ที่เหลือและสินค้าที่ถูก pop ออกไป
     • สมมติว่าสินค้า “ดินสอ” (อยู่ที่ดัชนี 0 หรือ 1 แล้วแต่ว่าทำข้อก่อนหน้าอย่างไร) หมดสต็อกถาวร: ใช้ del เพื่อลบสินค้า ณ ดัชนีนั้น แล้วแสดงผล
• ปฏิบัติการที่ 3: เมธอดลิสต์สารพัดประโยชน์ ⚙️
  1. โจทย์ 3.1: จัดอันดับคะแนน:
     • สร้างลิสต์ student_scores = [85, 72, 90, 68, 72, 88, 72]
     • ใช้เมธอด count() เพื่อนับว่ามีนักเรียนกี่คนที่ได้คะแนน 72 แล้วแสดงผล
     • ใช้เมธอด index() เพื่อหาตำแหน่งแรกของคะแนน 90 แล้วแสดงผล (ถ้ามีคะแนน 90)
     • ใช้เมธอด sort(reverse=True) เพื่อเรียงคะแนนจากมากไปน้อยในลิสต์ student_scores เอง แล้วแสดงผล
     • สร้างลิสต์ใหม่ top_3_scores โดยใช้ slicing จาก student_scores ที่เรียงแล้ว เพื่อเก็บ 3 อันดับแรก แล้วแสดงผล
  2. โจทย์ 3.2: รวมทีม:
     • สร้างลิสต์ team_a = ["Alice", "Bob"] และ team_b = ["Charlie", "David"]
     • สร้างลิสต์ all_players โดยการต่อ team_a และ team_b เข้าด้วยกัน แล้วแสดงผล
     • เพิ่ม “Eve” เข้าไปใน all_players โดยใช้ append()
     • แสดงผลจำนวนผู้เล่นทั้งหมดใน all_players
• ปฏิบัติการที่ 4: ทูเพิลเพื่อนซี้ที่เปลี่ยนใจไม่ได้ 🔒
  1. โจทย์ 4.1: ข้อมูลส่วนตัว (ที่ไม่ควรเปลี่ยน):
     • สร้างทูเพิลชื่อ person_info เก็บข้อมูล: ชื่อ, นามสกุล, วันเกิด (เช่น “15/03/1990”), และกรุ๊ปเลือด
     • แสดงผลทูเพิลทั้งหมด
     • แสดงผลเฉพาะชื่อและนามสกุลโดยใช้ indexing
     • ลองพยายามแก้ไขวันเกิดในทูเพิล (เช่น person_info[2] = "16/03/1990") สังเกตผลลัพธ์ (ควรจะเกิด TypeError)
  2. โจทย์ 4.2: Unpack ข้อมูล:
     • สร้างทูเพิล point_3d = (10, 20, 5)
     • ทำการ Unpacking ทูเพิลนี้ให้กับตัวแปร x, y, และ z
     • แสดงผลค่าของ x, y, และ z
  3. โจทย์ 4.3: ทูเพิลใน for loop:
     • สร้างทูเพิล days = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday")
     • เขียน for loop เพื่อแสดงชื่อวันแต่ละวันในทูเพิล days
• แบบฝึกหัดประยุกต์ (เลือกทำ 1-2 ข้อ หรือเป็นการบ้าน)
  1. โจทย์ประยุกต์ 1: จัดการรายการสิ่งที่ต้องทำ (To-Do List) อย่างง่าย:
     • สร้างลิสต์ว่างสำหรับเก็บรายการสิ่งที่ต้องทำ
     • เขียนโปรแกรมให้ผู้ใช้สามารถ:
       • เพิ่มงานใหม่เข้าไปในลิสต์
       • ดูรายการงานทั้งหมด (พร้อมลำดับที่ เช่น 1. ซักผ้า, 2. อ่านหนังสือ)
       • ลบงานออกจากลิสต์ (โดยระบุลำดับที่ของงานที่ต้องการลบ)
       • พิมพ์ “exit” เพื่อจบโปรแกรม
     • (ใช้ while loop เพื่อให้โปรแกรมทำงานวนรับคำสั่งจากผู้ใช้ และใช้ if-elif-else เพื่อแยกการทำงานตามคำสั่ง)
  2. โจทย์ประยุกต์ 2: เก็บข้อมูลคะแนนนักเรียน:
     • เขียนโปรแกรมรับชื่อและคะแนนสอบของนักเรียน 3 คน โดยเก็บข้อมูลของแต่ละคนเป็นทูเพิล (ชื่อ, คะแนน) แล้วนำทูเพิลเหล่านี้ไปเก็บในลิสต์รวมชื่อ student_data
     • หลังจากรับข้อมูลครบแล้ว ให้แสดงผลข้อมูลนักเรียนทุกคน
     • คำนวณและแสดงคะแนนเฉลี่ยของนักเรียนทั้ง 3 คน
     • (เสริม) แสดงชื่อนักเรียนที่ได้คะแนนสูงสุด