30105-2006

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:
Python
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
Python
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): เป็นการกำหนดค่าสมาชิกแต่ละตัวในทูเพิล (หรือลิสต์) ให้กับตัวแปรหลายตัวพร้อมกัน จำนวนตัวแปรทางซ้ายต้องเท่ากับจำนวนสมาชิกในทูเพิล/ลิสต์
Python
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)ทูเพิล (Tuple)
การสร้าง[] หรือ list()() หรือ tuple() (สมาชิกตัวเดียวต้องมี ,)
การเปลี่ยนแปลงMutable (เปลี่ยนแปลงได้หลังการสร้าง)Immutable (เปลี่ยนแปลงไม่ได้หลังการสร้าง)
เมธอดมีเมธอดสำหรับเพิ่ม, ลบ, แก้ไข, จัดเรียง มากมายมีเมธอดน้อยกว่า (หลักๆ คือ count(), index())
ความเร็วอาจช้ากว่าเล็กน้อยสำหรับการวนซ้ำหรือเข้าถึงข้อมูลอาจเร็วกว่าเล็กน้อย (เนื่องจากโครงสร้างคงที่)
การใช้หน่วยความจำอาจใช้มากกว่าเล็กน้อยอาจใช้น้อยกว่าเล็กน้อย
กรณีใช้งานหลัก– ชุดข้อมูลที่ต้องการเปลี่ยนแปลงบ่อยๆ
– ใช้เก็บข้อมูลที่เป็นกลุ่มเดียวกันและอาจมีการเพิ่มลด
– เช่น รายการสิ่งที่ต้องทำ, ตะกร้าสินค้า		– ชุดข้อมูลที่ต้องการให้คงที่ ไม่เปลี่ยนแปลง
– ใช้เก็บข้อมูลที่เป็น “ระเบียน” (record) ที่มีความหมายตายตัว เช่น พิกัด (x,y), ค่าสี RGB
– ใช้เป็น key ของ dictionary (เพราะ key ต้องเป็น immutable)
– เมื่อต้องการป้องกันการแก้ไขข้อมูลโดยไม่ตั้งใจ
  • เมื่อไหร่ควรใช้ 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 คน
      • (เสริม) แสดงชื่อนักเรียนที่ได้คะแนนสูงสุด

Related Posts