Design Pattern ใน Python

ดีไซน์แพตเทิร์น Strategy ใน Python

ในบทเรียนนี้ คุณจะใช้แพตเทิร์น Strategy เลือกและเปลี่ยนอัลกอริทึมระหว่างที่โปรแกรมทำงาน

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

บทนำ

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

ราคาอาจคิดต่างกันสำหรับลูกค้าทั่วไป สมาชิก หรือช่วงลดราคา ถ้ารวมทุกกฎไว้ในฟังก์ชันเดียวที่มี if / elif ต่อกันยาว ฟังก์ชันจะยาวขึ้นทุกครั้งที่มีกฎใหม่ Strategy ช่วยให้เราเสียบกฎที่ต้องการเข้าไปได้

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

แพตเทิร์น Strategy เหมือนการเลือกเส้นทางในแอปนำทาง: เร็วที่สุด สั้นที่สุด หรือเลี่ยงทางด่วน การเดินทางยังเหมือนเดิม เราแค่เสียบกลยุทธ์เส้นทางที่ต้องการ แล้วแอปก็นำทางตามนั้น โดยวิธีขับไม่ได้เปลี่ยน

จากการเลือกเส้นทางสู่โค้ด
regular_discount, member_discount🗺️ เส้นทางที่มีให้เลือก
Checkout(member_discount)📍 เลือกหนึ่งเส้นทางตอนเริ่ม
self.discount_strategy(amount)🚗 ทำตามเส้นทางที่เลือกไว้
12.00💳 ราคาสมาชิกเมื่อยอดเป็น 15
อัลกอริทึมเสียบเปลี่ยนได้ ไม่ได้เขียนตายตัวไว้ในโค้ด
สรุปในประโยคเดียว

แพตเทิร์น Strategy วางอัลกอริทึมแต่ละแบบไว้หลัง interface เดียวกัน ในที่นี้คือฟังก์ชันที่มีพารามิเตอร์เหมือนกัน และให้ผู้เรียกเลือกว่าจะใช้ตัวไหน

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

  1. regular_discount และ member_discount รับยอดรวมและส่งกลับจำนวนเงินที่ต้องจ่าย
  2. Checkout รับฟังก์ชันใดฟังก์ชันหนึ่งเข้ามาเป็น discount_strategy
  3. total(amount) เรียก strategy ที่เก็บไว้โดยไม่รู้ว่าเป็นตัวไหน
  4. member_discount ลด 20% ดังนั้น 15 จึงเป็น 12.00

ใช้เมื่อไร?

  • กฎที่สลับกันได้: การตั้งราคา การเรียง การตรวจสอบ รูปแบบไฟล์
  • ใช้แทน if / elif ยาว ๆ ที่คอยเลือกอัลกอริทึม
  • ทดสอบด้วย strategy ตัวแทนแบบง่าย

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

  • มีแค่หนึ่งหรือสองกฎง่าย ๆ ที่แทบไม่เปลี่ยน: if ชัดเจนกว่า
  • strategy ที่ต้องการอินพุตต่างกันมาก: การบังคับให้ใช้ interface เดียวจะดูฝืน

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

รันโค้ด →
main.py
def regular_discount(total): return total
def member_discount(total): return total * 0.8


class Checkout:
    # Strategy: inject the algorithm that is allowed to vary.
    def __init__(self, discount_strategy):
        self.discount_strategy = discount_strategy

    def total(self, amount):
        # Delegate the varying algorithm to the strategy.
        return self.discount_strategy(amount)


checkout = Checkout(member_discount)
print(f"{checkout.total(15):.2f}")
สร้างปุ่ม Run สำหรับตัวอย่างนี้

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

12.00

อธิบายโค้ด

คลาส Checkout รับฟังก์ชันส่วนลด discount_strategy ตอนสร้าง และมอบการคำนวณทั้งหมดให้ฟังก์ชันนี้ในเมธอด total() ด้วยกลยุทธ์ member_discount คำสั่งซื้อ 15 จะเหลือ 12.00 ถ้าจะเปลี่ยนวิธีคำนวณ แค่ส่งฟังก์ชันอื่นเข้าไป โดยไม่ต้องแก้คลาส Checkout

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

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

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

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

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

เรียก strategy ตอนส่งเข้าไป

Checkout(member_discount()) ส่งผลลัพธ์ของฟังก์ชันเข้าไป ไม่ใช่ตัวฟังก์ชัน

ปัญหา
checkout = Checkout(member_discount())  # TypeError
วิธีแก้
checkout = Checkout(member_discount)

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

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

ถัดไป: ดีไซน์แพตเทิร์น Command ใน Python →

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

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

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