(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: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 เข้าไปต่อท้ายลิสต์
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
การลบสมาชิก:
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()) ความเร็ว อาจช้ากว่าเล็กน้อยสำหรับการวนซ้ำหรือเข้าถึงข้อมูล อาจเร็วกว่าเล็กน้อย (เนื่องจากโครงสร้างคงที่) การใช้หน่วยความจำ อาจใช้มากกว่าเล็กน้อย อาจใช้น้อยกว่าเล็กน้อย กรณีใช้งานหลัก – ชุดข้อมูลที่ต้องการเปลี่ยนแปลงบ่อยๆ – ชุดข้อมูลที่ต้องการให้คงที่ ไม่เปลี่ยนแปลง
เมื่อไหร่ควรใช้ List?
เมื่อข้อมูลในกลุ่มมีการเปลี่ยนแปลง (เพิ่ม, ลบ, แก้ไข) บ่อยครั้ง
เมื่อต้องการใช้เมธอดที่หลากหลายในการจัดการข้อมูล เช่น sort(), append(), remove()
เมื่อไหร่ควรใช้ Tuple?
เมื่อข้อมูลในกลุ่มเป็นค่าคงที่ ไม่ควรมีการเปลี่ยนแปลงหลังสร้างเสร็จ เพื่อความปลอดภัยของข้อมูล
เมื่อต้องการใช้เป็น Key ใน Dictionary
เมื่อต้องการส่งคืนค่าหลายค่าจากฟังก์ชัน (Python มักจะทำเป็น Tuple โดยอัตโนมัติ)
เมื่อต้องการประสิทธิภาพที่สูงขึ้นเล็กน้อย (ในบางกรณี) สำหรับข้อมูลที่ไม่เปลี่ยนแปลง
ปฏิบัติการที่ 1: สร้างและเข้าถึงลิสต์ 🛍️
โจทย์ 1.1: ลิสต์เพื่อนของฉัน:
สร้างลิสต์ชื่อ friends เก็บชื่อเพื่อนของคุณอย่างน้อย 4 คน
แสดงผลลิสต์ friends ทั้งหมด
แสดงผลชื่อเพื่อนคนที่สองในลิสต์
แสดงผลชื่อเพื่อนคนสุดท้ายในลิสต์โดยใช้ดัชนีแบบลบ
แสดงผลจำนวนเพื่อนทั้งหมดในลิสต์
โจทย์ 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: จัดการสมาชิกในลิสต์ ✏️🗑️➕
โจทย์ 2.1: รายการซื้อของ:
สร้างลิสต์ว่างชื่อ shopping_list
ใช้เมธอด append() เพิ่ม “ไข่ไก่”, “นมสด”, “ขนมปัง” เข้าไปใน shopping_list ทีละรายการ แล้วแสดงผลลิสต์ทุกครั้งที่เพิ่ม
ใช้เมธอด insert() แทรก “น้ำส้ม” เข้าไปเป็นรายการที่สอง (ดัชนี 1) ของลิสต์ แล้วแสดงผล
แก้ไขรายการ “ขนมปัง” เป็น “ขนมปังโฮลวีต” แล้วแสดงผล
โจทย์ 2.2: จัดการคลังสินค้า (สมมติ):
สร้างลิสต์ inventory = ["ปากกา", "ดินสอ", "ยางลบ", "ไม้บรรทัด", "สมุด"]
ลูกค้าซื้อ “ยางลบ” ไป: ใช้เมธอด remove() เพื่อลบ “ยางลบ” ออกจากลิสต์ แล้วแสดงผล
สินค้าชิ้นสุดท้ายถูกขายไป: ใช้เมธอด pop() เพื่อลบสินค้าชิ้นสุดท้ายออกจากลิสต์ แล้วแสดงผลทั้งลิสต์ที่เหลือและสินค้าที่ถูก pop ออกไป
สมมติว่าสินค้า “ดินสอ” (อยู่ที่ดัชนี 0 หรือ 1 แล้วแต่ว่าทำข้อก่อนหน้าอย่างไร) หมดสต็อกถาวร: ใช้ del เพื่อลบสินค้า ณ ดัชนีนั้น แล้วแสดงผล
ปฏิบัติการที่ 3: เมธอดลิสต์สารพัดประโยชน์ ⚙️
โจทย์ 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 อันดับแรก แล้วแสดงผล
โจทย์ 3.2: รวมทีม:
สร้างลิสต์ team_a = ["Alice", "Bob"] และ team_b = ["Charlie", "David"]
สร้างลิสต์ all_players โดยการต่อ team_a และ team_b เข้าด้วยกัน แล้วแสดงผล
เพิ่ม “Eve” เข้าไปใน all_players โดยใช้ append()
แสดงผลจำนวนผู้เล่นทั้งหมดใน all_players
ปฏิบัติการที่ 4: ทูเพิลเพื่อนซี้ที่เปลี่ยนใจไม่ได้ 🔒
โจทย์ 4.1: ข้อมูลส่วนตัว (ที่ไม่ควรเปลี่ยน):
สร้างทูเพิลชื่อ person_info เก็บข้อมูล: ชื่อ, นามสกุล, วันเกิด (เช่น “15/03/1990”), และกรุ๊ปเลือด
แสดงผลทูเพิลทั้งหมด
แสดงผลเฉพาะชื่อและนามสกุลโดยใช้ indexing
ลองพยายามแก้ไขวันเกิดในทูเพิล (เช่น person_info[2] = "16/03/1990") สังเกตผลลัพธ์ (ควรจะเกิด TypeError)
โจทย์ 4.2: Unpack ข้อมูล:
สร้างทูเพิล point_3d = (10, 20, 5)
ทำการ Unpacking ทูเพิลนี้ให้กับตัวแปร x, y, และ z
แสดงผลค่าของ x, y, และ z
โจทย์ 4.3: ทูเพิลใน for loop:
สร้างทูเพิล days = ("Monday", "Tuesday", "Wednesday", "Thursday", "Friday")
เขียน for loop เพื่อแสดงชื่อวันแต่ละวันในทูเพิล days
แบบฝึกหัดประยุกต์ (เลือกทำ 1-2 ข้อ หรือเป็นการบ้าน)
โจทย์ประยุกต์ 1: จัดการรายการสิ่งที่ต้องทำ (To-Do List) อย่างง่าย:
สร้างลิสต์ว่างสำหรับเก็บรายการสิ่งที่ต้องทำ
เขียนโปรแกรมให้ผู้ใช้สามารถ:
เพิ่มงานใหม่เข้าไปในลิสต์
ดูรายการงานทั้งหมด (พร้อมลำดับที่ เช่น 1. ซักผ้า, 2. อ่านหนังสือ)
ลบงานออกจากลิสต์ (โดยระบุลำดับที่ของงานที่ต้องการลบ)
พิมพ์ “exit” เพื่อจบโปรแกรม
(ใช้ while loop เพื่อให้โปรแกรมทำงานวนรับคำสั่งจากผู้ใช้ และใช้ if-elif-else เพื่อแยกการทำงานตามคำสั่ง)
โจทย์ประยุกต์ 2: เก็บข้อมูลคะแนนนักเรียน:
เขียนโปรแกรมรับชื่อและคะแนนสอบของนักเรียน 3 คน โดยเก็บข้อมูลของแต่ละคนเป็นทูเพิล (ชื่อ, คะแนน) แล้วนำทูเพิลเหล่านี้ไปเก็บในลิสต์รวมชื่อ student_data
หลังจากรับข้อมูลครบแล้ว ให้แสดงผลข้อมูลนักเรียนทุกคน
คำนวณและแสดงคะแนนเฉลี่ยของนักเรียนทั้ง 3 คน
(เสริม) แสดงชื่อนักเรียนที่ได้คะแนนสูงสุด
