แบบฝึกหัด Python สำหรับผู้เริ่มต้น

เครื่องคิดเลขอย่างง่ายใน Python

ในบทเรียนนี้ คุณจะสร้างเครื่องคิดเลขอย่างง่ายที่ทำการคำนวณที่เลือกด้วยดิกชันนารีและฟังก์ชัน lambda

  • ระดับเริ่มต้น
  • อ่าน 2 นาที
  • ตัวอย่างที่รันได้ 1 ตัวอย่าง

บทนำ

ปัญหาที่ต้องแก้

เครื่องคิดเลขต้องเลือกการคำนวณให้ตรงกับสัญลักษณ์แต่ละตัว จะเขียน if / elif ต่อกันยาว ๆ ให้ครบทุกตัวดำเนินการก็ได้ แต่โค้ดจะยาวขึ้นทุกครั้งที่เพิ่มการคำนวณใหม่ และต้องเขียนโครงเดิมซ้ำ ๆ

ลองนึกภาพแบบนี้

Dictionary ของการคำนวณเหมือนปุ่มบนเครื่องคิดเลขพกพา แต่ละปุ่ม (สัญลักษณ์ตัวดำเนินการ) ต่อสายไว้กับการคำนวณหนึ่งอย่าง (ฟังก์ชัน) กดปุ่ม * ก็คูณเลขสองตัวได้ทันที ไม่ต้องไล่ถามคำถามทีละข้อก่อน

จากปุ่มเครื่องคิดเลขสู่โค้ด
"*": lambda left, right: left * right🔘 ปุ่มแต่ละปุ่มต่อสายไว้กับการคำนวณหนึ่งอย่าง
operations[operator]👆 กดปุ่ม *
(left, right)⚙️ ใส่เลขสองตัวเข้าไป
12 * 4 = 48📟 ผลลัพธ์
ค้นหาฟังก์ชันจากสัญลักษณ์ แล้วเรียกใช้
สรุปในประโยคเดียว

dispatch table (ตารางเลือกฟังก์ชัน) คือ dictionary ที่จับคู่คีย์กับฟังก์ชัน ในที่นี้คีย์คือสัญลักษณ์ตัวดำเนินการ โปรแกรมจึงหาและเรียกฟังก์ชันที่ถูกต้องได้ทันที

ประเด็นสำคัญ

  1. operations จับคู่แต่ละสัญลักษณ์อย่าง "+" กับฟังก์ชัน lambda เล็ก ๆ
  2. operations[operator] ค้นหาฟังก์ชันสำหรับ "*"
  3. operations[operator](left, right) เรียกฟังก์ชันนั้นด้วย 12 และ 4
  4. ถ้าจะเพิ่มการคำนวณใหม่ ก็แค่เพิ่มหนึ่งบรรทัดใน dictionary

ใช้เมื่อไร?

  • เลือกสิ่งที่จะทำตามอินพุตของผู้ใช้: ตัวดำเนินการของเครื่องคิดเลข ตัวเลือกเมนู คำสั่งในเกม
  • ใช้แทน if / elif ยาว ๆ ที่ทุกกรณีทำงานแบบเดียวกัน
  • เรียนรู้ว่าฟังก์ชันก็เก็บไว้ในโครงสร้างข้อมูลได้

เมื่อไรยังไม่จำเป็น

  • มีแค่สองกรณี: if / else ธรรมดาอ่านง่ายกว่า
  • แต่ละกรณีต้องใช้ตรรกะหลายขั้นที่ต่างกันมาก: ฟังก์ชันที่ตั้งชื่อหรือคำสั่ง match อ่านง่ายกว่า lambda

โค้ดตัวอย่าง

รันโค้ด →
main.py
operations = {
    "+": lambda left, right: left + right,
    "-": lambda left, right: left - right,
    "*": lambda left, right: left * right,
    "/": lambda left, right: left / right,
}
left, operator, right = 12, "*", 4
# Select and call the function associated with the operator.
print(f"{left} {operator} {right} = {operations[operator](left, right)}")
สร้างปุ่ม Run สำหรับตัวอย่างนี้

ผลลัพธ์จากการรัน

12 * 4 = 48

อธิบายโค้ด

ดิกชันนารี operations เก็บแต่ละการคำนวณเป็นฟังก์ชัน lambda ที่มีพารามิเตอร์สองตัว นิพจน์ operations[operator] ดึงฟังก์ชันของสัญลักษณ์ "*" แล้ว (left, right) เรียกฟังก์ชันนั้นด้วยตัวเลข 12 และ 4 ถ้าจะเพิ่มการคำนวณใหม่ แค่เพิ่มคู่คีย์กับค่าในดิกชันนารี

เปลี่ยนค่าและรันโปรแกรมด้วย คอมไพเลอร์ Python ออนไลน์ของ CodeUtility โดยไม่ต้องติดตั้ง Python

แบบฝึกหัดเพิ่มเติม

ลองแก้โค้ดตามคำแนะนำด้านล่าง การเปลี่ยนโค้ดแล้วดูผลลัพธ์จะช่วยให้เข้าใจบทเรียนได้ดีกว่าการอ่านอย่างเดียวมาก

  1. เปลี่ยนข้อมูลอินพุตแล้วทายผลลัพธ์ก่อนรัน
  2. เพิ่มการตรวจสอบข้อมูลว่างหรือข้อมูลที่ไม่ถูกต้อง
  3. แยกขั้นตอนการประมวลผลเป็นฟังก์ชันและทดสอบกับข้อมูลหลายชุด
รันในคอมไพเลอร์ Python →

ข้อผิดพลาดที่พบบ่อย

ไม่จัดการตัวดำเนินการที่ไม่รู้จัก

operations["%"] ทำให้เกิด KeyError

ปัญหา
print(operations[operator](left, right))
วิธีแก้
if operator in operations:
    print(operations[operator](left, right))
else:
    print("Unknown operator")

หารด้วยศูนย์

เมื่อ right เป็น 0 คำสั่ง left / right จะเกิด ZeroDivisionError

ปัญหา
operations["/"](12, 0)
วิธีแก้
if operator == "/" and right == 0:
    print("Cannot divide by zero")

เรียนบทนี้จบแล้วใช่ไหม

ทำเครื่องหมายว่าเรียนแล้วเพื่อติดตามความคืบหน้า

ฝึกด้วยโจทย์

ใช้สิ่งที่เรียนในบทนี้แก้ปัญหาจริง ทุกโจทย์รันในเบราว์เซอร์ พร้อมการทดสอบทันทีและรีวิวจาก AI

โจทย์ทั้งหมด