วิธีใช้สวิตช์ใน Python: คำแนะนำโดยละเอียดพร้อมตัวอย่างและทางเลือกอื่นๆ

อินฟอร์เมเทค ดิจิตอล » การเขียนโปรแกรม » วิธีใช้สวิตช์ใน Python: คำแนะนำโดยละเอียดพร้อมตัวอย่างและทางเลือกอื่นๆ

คุณเคยสงสัยไหมว่าจะจัดการเงื่อนไขหลายๆ อย่างใน Python ได้อย่างง่ายดายและมีประสิทธิภาพได้อย่างไร?เมื่อทำงานกับภาษาอย่าง C, Java หรือ JavaScript คุณอาจเคยใช้คำสั่ง switch-case ที่คุ้นเคย เพื่อเลือกตัวเลือกต่างๆ โดยอิงจากค่าของตัวแปร แต่ใน Python กลไกแบบคลาสสิกนี้ไม่มี... จนกระทั่งเมื่อไม่นานมานี้ ในขณะที่นักพัฒนาต้องหาวิธีการอื่นมาหลายปี ตอนนี้ภาษา Python ก็ได้นำเสนอโซลูชันที่ทันสมัยและทรงพลังแล้ว

บทความนี้คือคู่มือฉบับสมบูรณ์ที่จะช่วยให้คุณเข้าใจวิธีการใช้คำสั่ง `switch` ใน Pythonรวมถึงค้นพบทางเลือกที่ดีกว่าในเวอร์ชันเก่าๆ อธิบายว่าทำไมถึงไม่ได้ใส่มาในเวอร์ชันแรกๆ และเรียนรู้วิธีเขียนโค้ดให้สะอาดตาและอ่านง่ายขึ้น ไม่ว่าคุณจะใช้เวอร์ชันใดก็ตาม เตรียมพร้อมที่จะเรียนรู้เทคนิค ตัวอย่าง และความแตกต่างที่สำคัญในการใช้งานเงื่อนไขหลายๆ ตัวในระบบนิเวศของ Python

สวิตช์นี้มีอยู่ใน Python หรือไม่ ประวัติและเหตุผลที่ไม่มีสวิตช์นี้

ไวยากรณ์ switch-case ซึ่งมีอยู่ในหลายภาษา ไม่ได้ถูกนำมาใช้ใน Python อย่างเป็นทางการจนกระทั่งเวอร์ชัน 3.10เหตุผลหลักเป็นเรื่องปรัชญา: ผู้สร้าง Python ให้ความสำคัญกับความเรียบง่ายและอ่านง่ายมาโดยตลอด พวกเขาเชื่อว่าการแนะนำไวยากรณ์ใหม่สำหรับคำสั่ง switch อาจทำให้สิ่งต่างๆ ซับซ้อนขึ้น ดังนั้นif-elif-elseจึงเพียงพอที่จะเติมเต็มช่องว่างนั้นได้ นอกจากนี้ ยังไม่มีข้อตกลงร่วมกันเกี่ยวกับไวยากรณ์ที่เหมาะสมที่สุด อันที่จริง ข้อเสนออย่างเป็นทางการหลายฉบับ (PEP 275, PEP 3103) ถูกปฏิเสธเนื่องจากขาดข้อตกลงและเพราะหลายคนรู้สึกว่าทางเลือกที่มีอยู่แล้วนั้นชัดเจนและทรงพลังเพียงพอ

เป็นเวลาหลายปีแล้วที่ชุมชนได้ชดเชยการขาดคำสั่ง `switch` โดยใช้เงื่อนไขต่อเนื่องและพจนานุกรมแน่นอนว่าสิ่งนี้ก่อให้เกิดการถกเถียง แต่แทนที่จะเป็นข้อเสียที่แก้ไขไม่ได้ วิธีการเหล่านี้กลับพิสูจน์แล้วว่ามีความยืดหยุ่นและปรับตัวได้สูง อย่างไรก็ตาม เมื่อโครงการมีความซับซ้อนมากขึ้น ความต้องการวิธีการแก้ปัญหาที่สง่างามกว่าก็ปรากฏชัดเจนมากขึ้นเรื่อยๆ

เคสสวิตช์คืออะไรและใช้ทำอะไร?

คำสั่ง switch -caseเป็นโครงสร้างควบคุมที่ใช้ในหลายภาษาเพื่อเรียกใช้บล็อกโค้ดที่แตกต่างกันโดยขึ้นอยู่กับค่าของตัวแปรหรือนิพจน์ กล่าวอีกนัยหนึ่งคือ ช่วยให้คุณเลือกตัวเลือกหนึ่งจากหลายความเป็นไปได้ในวิธีที่สะอาดและตรงไปตรงมา หลีกเลี่ยงการเขียนคำสั่งเงื่อนไขที่ซับซ้อนไม่รู้จบ

ตัวอย่างการใช้งานทั่วไป ได้แก่ การแสดงชื่อวันในสัปดาห์ตามตัวเลข การกำหนดเกรด การเลือกการดำเนินการตามอินพุตของผู้ใช้ เป็นต้น ในภาษาเช่น C หรือ Java ไวยากรณ์จะเรียบง่ายดังนี้:

switch(valor) {
    case 1:
        // acción
        break;
    case 2:
        // otra acción
        break;
    default:
        // acción por defecto
}

ใน Python โครงสร้างคลาสสิกนี้ไม่มีอยู่จนกระทั่งเมื่อไม่นานนี้ ดังนั้น นักพัฒนาจึงต้องสร้างสรรค์สิ่งใหม่ๆ เพื่อให้ได้ผลลัพธ์เดียวกัน

การมาถึงของสวิตช์ใน Python: คำสั่ง match-case (ตั้งแต่ Python 3.10)

ในเวอร์ชัน 3.10 Python ได้เพิ่มฟีเจอร์ที่รอคอยมานาน นั่นคือคำสั่ง match-caseแม้ว่าไวยากรณ์จะคล้ายกับคำสั่ง switch-case แบบดั้งเดิม แต่จริงๆ แล้วมันมีประสิทธิภาพมากกว่ามาก เพราะมันใช้การจับคู่รูปแบบ (pattern matching ) ทำให้สามารถเปรียบเทียบได้ไม่เพียงแค่ค่าธรรมดาเท่านั้น แต่ยังรวมถึงโครงสร้างที่ซับซ้อน เช่น ทูเปิล คลาส ลิสต์ พจนานุกรม และอื่นๆ อีกด้วย

กรณีจับคู่ของ Python เขียนได้ดังนี้:

def ejemplo_switch(x):
    match x:
        case 1:
            return "uno"
        case 2:
            return "dos"
        case _:
            return "desconocido"

เครื่องหมายขีดล่าง ( _ ) ทำหน้าที่เป็นตัวอักษรแทน (wildcard) และเทียบเท่ากับค่าเริ่มต้นในภาษาอื่นๆ โดยจะทำงานเมื่อไม่มีรูปแบบใดตรงกันมาก่อน

ทำไมมันถึงทรงพลังขนาดนั้น?เพราะคุณสามารถรับรูปแบบที่ซับซ้อน จับตัวแปร เปิดทูเปิลหรืออ็อบเจ็กต์ และแม้กระทั่งใช้การ์ดเพื่อเพิ่มเงื่อนไขเพิ่มเติมหลังจากคำสั่ง case ได้:

match dato:
    case (a, b) if a > b:
        print("El primer elemento es mayor que el segundo")
    case (a, b):
        print(f"Valores: {a}, {b}")

นอกจากนี้ ใน Python 3.10 และสูงกว่า โครงสร้างนี้ยังช่วยปรับปรุงการอ่านง่าย การบำรุงรักษา และความสามารถในการปรับขนาดของโค้ดของคุณ โดยเฉพาะเมื่อต้องจัดการกับหลายๆ กรณี

ทางเลือกในการสลับใน Python สำหรับเวอร์ชันเก่า

ก่อนที่คำสั่ง`match-case` จะเข้ามา นักพัฒนาได้คิดค้นทางเลือกอื่นที่ใช้ได้ผลไม่แพ้กันสองวิธีที่พบมากที่สุดคือ การใช้สตริง `if-elif-else` และการแมปพจนานุกรมเรามาดูรายละเอียดกัน:

1. การใช้ if-elif-else

วิธีที่ตรงไปตรงมาและง่ายที่สุดคือการใช้เงื่อนไขต่อเนื่องกันโดยใช้ if, elif และ elseวิธีนี้ช่วยให้คุณครอบคลุมค่าที่เป็นไปได้ทั้งหมดของตัวแปรและเรียกใช้บล็อกโค้ดที่เกี่ยวข้องได้ ตัวอย่างเช่น การแสดงวันในสัปดาห์โดยอิงจากตัวเลข:

dia = 4
if dia == 1:
    print('lunes')
elif dia == 2:
    print('martes')
elif dia == 3:
    print('miércoles')
elif dia == 4:
    print('jueves')
elif dia == 5:
    print('viernes')
elif dia == 6:
    print('sábado')
elif dia == 7:
    print('domingo')
else:
    print('error')

ข้อดีของแนวทางนี้:

• โค้ดเรียบง่ายและอ่านได้ง่าย
• คุณไม่จำเป็นต้องมีโครงสร้างพิเศษอื่นใด มันเป็น Python ล้วนๆ
• การเปรียบเทียบสามารถใช้ได้ทุกรูปแบบ ไม่ใช่เพียงความเท่าเทียมกันเท่านั้น

ข้อเสียของบันได if-elif-else:

• แนวโน้มที่จะเขียนโค้ดซ้ำๆ คุณจะต้องทำซ้ำตัวแปรในการเปรียบเทียบแต่ละครั้ง ซึ่งจะสร้างข้อความที่ไม่จำเป็นจำนวนมากหากคุณมีหลายกรณี
• ประสิทธิภาพจะลดลงเมื่อมีเงื่อนไขจำนวนมาก หากคดีถึงที่สุดแล้ว คดีก่อนหน้าทั้งหมดจะถูกประเมินก่อนมาถึง
• ความยากลำบากในการเพิ่มหรือลบเคสแบบไดนามิก

2. การใช้พจนานุกรมเพื่อจำลองสวิตช์เคส

วิธีแบบ Pythonic มากๆ ในการจำลองคำสั่ง switch คือการใช้พจนานุกรมแนวคิดนั้นง่ายมาก: คุณเชื่อมโยงค่าที่เป็นไปได้แต่ละค่า (คีย์) กับฟังก์ชันหรือการกระทำที่สอดคล้องกัน (ค่า) จากนั้น คุณสอบถามพจนานุกรมเพื่อรับฟังก์ชันและเรียกใช้ฟังก์ชันนั้น

def lunes():
    print('lunes')
def martes():
    print('martes')
def error():
    print('error')

switch_semana = {
    1: lunes,
    2: martes,
    # ... otros días ...
}
dia = 8
switch_semana.get(dia, error)()

ข้อดีของวิธีนี้:

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

ข้อเสีย:

• จำเป็นต้องกำหนดฟังก์ชันที่เกี่ยวข้องทั้งหมดไว้ล่วงหน้า ซึ่งอาจยุ่งยากสำหรับการดำเนินการง่ายๆ
• มันอนุญาตเฉพาะการเปรียบเทียบเพื่อความเท่าเทียมกันเท่านั้น (ใช้ไม่ได้กับช่วง, ระยะ, ฯลฯ)
• ไม่ได้มีไว้สำหรับกรณีที่มีตรรกะเงื่อนไขที่ซับซ้อนมากขึ้นภายในแต่ละการเลือก

ความแตกต่างระหว่าง if-elif-else และ switch (หรือ match-case)

การทำงานภายในของคำสั่ง if-elif-else แตกต่างจากคำสั่ง switchในคำสั่ง if-elif-else เงื่อนไขจะถูกประเมินทีละข้อจากบนลงล่าง จนกว่าจะพบเงื่อนไขที่เป็นจริงข้อแรก ดังนั้น หากค่าที่ต้องการอยู่ตอนต้น การทำงานจะรวดเร็ว แต่ถ้าอยู่ตอนท้าย การทำงานจะใช้เวลานานขึ้น

ในทางตรงกันข้าม คำสั่ง switch แบบดั้งเดิม (และพจนานุกรมซึ่งเป็นทางเลือกใน Python) โดยทั่วไปจะใช้ตารางค้นหา ทำให้การเข้าถึงมีความสม่ำเสมอมากขึ้น โดยไม่คำนึงถึงจำนวนกรณีหรือตำแหน่งของกรณีเหล่านั้น ด้วยคำสั่ง match-caseและพจนานุกรม เวลาในการเข้าถึงจึงมีความสม่ำเสมอกว่ามาก

เมื่อใดจึงจะเลือกทางเลือกแต่ละทาง?

ไม่มีวิธีแก้ปัญหาแบบสากลที่แน่นอน เครื่องมือที่ดีที่สุดจะขึ้นอยู่กับปัญหาเฉพาะนั้นๆ

• สำหรับเงื่อนไขจำนวนน้อยหรือตรรกะที่ซับซ้อนในแต่ละสาขา if-elif-else ถือเป็นตัวเลือกที่ตรงไปตรงมาที่สุด มันช่วยให้สามารถเปรียบเทียบได้และมีความยืดหยุ่นมาก
• เมื่อคุณมีหลายกรณีและแต่ละกรณีเพียงแค่ดำเนินการเฉพาะอย่างหนึ่ง ให้ใช้พจนานุกรม โค้ดมีความสะอาดมากขึ้น ปรับขนาดได้ และง่ายต่อการดูแลรักษามากขึ้น
• หากคุณใช้ Python 3.10 หรือสูงกว่า กรณีไม้ขีดไฟ เป็นตัวเลือกที่ดีที่สุดสำหรับความชัดเจนและพลัง ช่วยให้คุณสามารถผสมผสานความสง่างามของสวิตช์กับพลังของการจับคู่รูปแบบบนโครงสร้างที่ซับซ้อนได้

ควรคำนึงถึงความสามารถในการอ่าน ประสิทธิภาพ และความสามารถในการบำรุงรักษาของโค้ดของคุณอยู่เสมอ

ตัวอย่างการใช้งานสวิตช์ใน Python และทางเลือกอื่นๆ

มาดูตัวอย่างหลายๆ ตัวอย่างที่นำทางเลือกแต่ละทางเลือกไปใช้ตั้งแต่ความซับซ้อนน้อยที่สุดไปจนถึงความซับซ้อนมากที่สุด:

ตัวอย่างที่ 1 : คำนวณเกรดจากคะแนน

# Usando if-elif-else
puntuacion = 85
if puntuacion >= 90:
    print('Sobresaliente')
elif puntuacion >= 80:
    print('Notable')
elif puntuacion >= 70:
    print('Bien')
else:
    print('Insuficiente')

กรณีนี้เหมาะอย่างยิ่งสำหรับการใช้เงื่อนไข เนื่องจากคุณกำลังทำงานกับช่วงเวลา ไม่ใช่ค่าคงที่

ตัวอย่างที่ 2 : แสดงวันในสัปดาห์ตามตัวเลข (พร้อมพจนานุกรม)

# Definición de funciones para cada día
def lunes():
    print('lunes')
def martes():
    print('martes')
def miercoles():
    print('miércoles')
def jueves():
    print('jueves')
def viernes():
    print('viernes')
def sabado():
    print('sábado')
def domingo():
    print('domingo')
def error():
    print('error')
switch_semana = {
    1: lunes,
    2: martes,
    3: miercoles,
    4: jueves,
    5: viernes,
    6: sabado,
    7: domingo
}
dia = 8
switch_semana.get(dia, error)()

ตัวอย่างที่ 3: การใช้ match-case เพื่อเลือกการดำเนินการทางคณิตศาสตร์

operacion = 'suma'
a = 10
b = 5
match operacion:
    case 'suma':
        print(a + b)
    case 'resta':
        print(a - b)
    case 'multiplicacion':
        print(a * b)
    case 'division':
        print(a / b)
    case _:
        print('Operación no válida')

อย่างที่คุณเห็น รูปแบบประโยคนั้นเรียบง่ายและชัดเจนมาก เครื่องหมายขีดล่างแสดงถึงกรณีเริ่มต้น

ตัวอย่างขั้นสูง: การจับคู่รูปแบบด้วยตัวจับคู่

จุดแข็งที่สำคัญของการวิเคราะห์แบบจับคู่กรณี (match-case analysis) อยู่ที่ความสามารถในการทำงานกับรูปแบบที่ซับซ้อนตัวอย่างเช่น คุณสามารถวิเคราะห์ทูเปิล รายการ พจนานุกรม ออบเจ็กต์ และอื่นๆ ได้

punto = (3, 5)
match punto:
    case (0, 0):
        print('Origen')
    case (0, y):
        print(f'Eje Y en {y}')
    case (x, 0):
        print(f'Eje X en {x}')
    case (x, y):
        print(f'Coordenadas X={x}, Y={y}')

คุณสามารถใช้ คำสั่ง if (guard) เพื่อเพิ่มเงื่อนไขเพิ่มเติมให้กับแต่ละกรณี ได้ด้วย

ความแตกต่างด้านประสิทธิภาพระหว่าง if-elif-else, diniaries และ match-cases

ในกรณีส่วนใหญ่ ความแตกต่างด้านประสิทธิภาพนั้นแทบจะไม่มีนัยสำคัญสำหรับสคริปต์ทั่วไปอย่างไรก็ตาม เมื่อมีทางเลือกจำนวนมาก พจนานุกรมและอาร์กิวเมนต์แบบ match-case อาจมีประสิทธิภาพมากกว่า เนื่องจากช่วยลดจำนวนการเปรียบเทียบลง ในทุกกรณี ปัจจัยที่สำคัญที่สุดมักจะเป็นความสามารถในการอ่านและบำรุงรักษาโค้ดมากกว่าการปรับแต่งเล็กๆ น้อยๆ ที่แทบจะไม่สร้างความแตกต่างในโครงการจริงเลย

ใช้เทคนิคที่ทำให้โค้ดชัดเจนขึ้นและหลีกเลี่ยงข้อผิดพลาด

โซลูชันสร้างสรรค์: คลาสและตัวจัดการบริบทเพื่อจำลองสวิตช์

นักพัฒนาบางรายได้สร้างคลาสเฉพาะที่ช่วยให้สามารถจำลองพฤติกรรมแบบคลาสสิกของคำสั่ง switch ได้ รวมถึงตัวเลือกขั้นสูง เช่น การเพิ่มbreakเพื่อควบคุมการทำงานของกรณีถัดไป การจัดกลุ่มกรณี การปรับแต่งการเปรียบเทียบ หรือการเปิดใช้งานโหมดเข้มงวดที่รับประกันว่าจะมีเพียงสาขาเดียวเท่านั้นที่จะถูกเรียกใช้งาน

ตัวอย่างเช่น ตัวจัดการบริบทแบบกำหนดเองสามารถนำไปใช้เพื่อใช้รูปแบบไวยากรณ์ที่คล้ายกับภาษาอื่นๆ ได้มาก:

class switch:
    def __init__(self, variable, comparator=None, strict=False):
        self.variable = variable
        self.matched = False
        self.matching = False
        if comparator:
            self.comparator = comparator
        else:
            self.comparator = lambda x, y: x == y
        self.strict = strict
    def __enter__(self):
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        pass
    def case(self, expr, break_=False):
        if self.strict:
            if self.matched:
                return False
            if self.matching or self.comparator(self.variable, expr):
                if not break_:
                    self.matching = True
                else:
                    self.matched = True
                    self.matching = False
                return True
            else:
                return False
        else:
            if self.matching or self.comparator(self.variable, expr):
                if not break_:
                    self.matching = True
                else:
                    self.matched = True
                    self.matching = False
                return True
            else:
                return False
    def default(self):
        return not self.matched and not self.matching

การใช้คลาสนี้ช่วยให้มีรูปแบบไวยากรณ์เช่นนี้:

dia = 4
with switch(dia) as s:
    if s.case(1, True): print('lunes')
    if s.case(2, True): print('martes')
    if s.case(3, True): print('miércoles')
    if s.case(4, True): print('jueves')
    if s.case(5, True): print('viernes')
    if s.case(6, True): print('sábado')
    if s.case(7, True): print('domingo')
    if s.default(): print('error')

ข้อดีของวิธีนี้คืออะไร?มันมีไวยากรณ์ที่คุ้นเคยมากสำหรับผู้ที่มาจากภาษาโปรแกรมอื่น และอนุญาตให้ปรับแต่งขั้นสูงได้ เช่น การใช้ฟังก์ชันเปรียบเทียบใดๆ การจัดกลุ่มกรณี การเรียกใช้หลายสาขาหรือเพียงสาขาเดียว เป็นต้น ข้อเสียคือมันมักจะช้ากว่าและต้องนำเข้าหรือกำหนดคลาสพิเศษ

การใช้ฟังก์ชั่นแลมบ์ดาเพื่อลดความซับซ้อนของการกระทำในพจนานุกรม

บ่อยครั้งที่คุณไม่จำเป็นต้องกำหนดฟังก์ชันแยกต่างหากสำหรับแต่ละการกระทำ คุณสามารถใช้ฟังก์ชันนิรนาม (แลมบ์ดา) ได้ซึ่งเป็นประโยชน์อย่างยิ่งเมื่อการกระทำที่จะทำนั้นง่าย:

switch_operaciones = {
    'sumar': lambda a, b: a + b,
    'restar': lambda a, b: a - b,
    'multiplicar': lambda a, b: a * b
}
operacion = 'sumar'
resultado = switch_operaciones.get(operacion, lambda a, b: None)(5, 3)
print(resultado)

ซึ่งช่วยให้โค้ดมีขนาดกะทัดรัดและขยายได้ง่ายโดยไม่สูญเสียความชัดเจน

กรณีการใช้งานขั้นสูง: การจับคู่รูปแบบใน Match-Case

คำสั่ง`match-case` ใน Python 3.10 นั้นเหนือกว่าการคัดลอกคำสั่ง `switch-case` แบบคลาสสิกอย่างมาก พลังที่แท้จริงของมันอยู่ที่การจับคู่รูปแบบโครงสร้างตัวอย่างเช่น มันช่วยให้คุณแยกแยะความแตกต่างระหว่างโครงสร้างข้อมูลต่างๆ คลาสที่กำหนดเอง แยกส่วนอ็อบเจ็กต์ และจับส่วนประกอบย่อยได้อย่างง่ายดาย

ตัวอย่างที่มีรายการและทูเพิล:

datos = 
match datos:
    case :
        print('Lista con 1, 2, 3')
    case :
        print('Lista que empieza con 1')
    case _:
        print('Otra lista')

ตัวอย่างที่มีวัตถุ (โดยถือว่าเป็นคลาส Point):

class Punto:
    def __init__(self, x, y):
        self.x = x
        self.y = y
p = Punto(2, 3)
match p:
    case Punto(x=0, y=0):
        print('Origen')
    case Punto(x, y):
        print(f'Coordenadas: {x} {y}')

กลไกนี้ช่วยให้คุณเขียนโค้ดที่แสดงออกได้อย่างมีประสิทธิภาพซึ่งปรับให้เข้ากับโครงสร้างที่ซับซ้อนได้โดยไม่สูญเสียความสามารถในการอ่าน

ประเด็นที่ต้องพิจารณาเมื่อย้ายรหัส: ความเข้ากันได้และแนวทางปฏิบัติที่ดีที่สุด

ไม่ใช่ทุกโปรเจ็กต์ที่จะสามารถใช้ `match-case` ได้ทันทีหากคุณทำงานในสภาพแวดล้อมที่มี Python เวอร์ชันเก่า (เช่น 3.8 หรือ 3.9) คุณจะต้องเลือกใช้พจนานุกรมแทน เมื่อสามารถอัปเกรดเป็นเวอร์ชัน 3.10 ขึ้นไปได้แล้ว ให้ใช้ประโยชน์จากประสิทธิภาพและความชัดเจนของการจับคู่รูปแบบ โดยเฉพาะในโปรเจ็กต์ที่ตรรกะการเลือกหลายรายการมีความสำคัญ

จำไว้ว่า:

• เลือกตัวเลือกที่ให้ความสามารถในการอ่าน ความยืดหยุ่น และความสะดวกในการบำรุงรักษาที่ดีที่สุด
• ในปัญหาที่เรียบง่ายมาก (บางกรณี) คำสั่ง if-elif-else มักจะเพียงพอและตรงไปตรงมามากกว่า
• สำหรับตารางการเลือกขนาดใหญ่ ให้ใช้พจนานุกรมและฟังก์ชัน
• หากต้องการโครงสร้างที่ซับซ้อนหรือต้องการใช้ประโยชน์จาก Python ในปัจจุบันอย่างเต็มที่ ให้เลือกแบบ match-case

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

เคล็ดลับการเพิ่มประสิทธิภาพและการออกแบบสำหรับโค้ด Python ที่สะอาดยิ่งขึ้น

อย่าตกหลุมพรางของการออกแบบเงื่อนไขที่ซับซ้อนมากมายเพียงเพื่อเลียนแบบคำสั่ง switch แบบคลาสสิกจงคิดถึงแต่ละกรณีอย่างละเอียดและประเมินว่าโครงสร้างควบคุมแบบใดที่เพิ่มคุณค่าให้กับบริบทของโปรแกรมของคุณมากที่สุด จำไว้ว่า Python ให้ความสำคัญกับความชัดเจน ดังนั้นจงหลีกเลี่ยงการทำให้โค้ดของคุณซับซ้อนเกินไปหากคุณสามารถบรรลุผลลัพธ์เดียวกันได้ด้วยวิธีง่ายๆ

เคล็ดลับสำคัญ: เมื่อใช้พจนานุกรม ให้ใช้ฟังก์ชัน get() เพื่อหลีกเลี่ยงข้อผิดพลาดหากคีย์ไม่มีอยู่และสามารถกำหนดค่าเริ่มต้นได้อย่างสวยงาม

การเปรียบเทียบกับภาษาอื่นและความคิดเห็นสุดท้าย

ในบางภาษา เช่น C, C++ หรือ Java สวิตช์จะอนุญาตเฉพาะการเปรียบเทียบค่าธรรมดา (จำนวนเต็ม สตริง) และให้ค่าเพียงเล็กน้อยสำหรับโครงสร้างที่ซับซ้อน Python ก้าวไปอีกขั้น: ประการแรก มันเสนอทางเลือกที่หลากหลาย (if-elif-else, พจนานุกรม) และตอนนี้มันเปิดประตูสู่ตรรกะขั้นสูงโดยไม่ต้องใช้ความพยายามพิเศษ สิ่งสำคัญคือการใช้ประโยชน์จากข้อดีของแต่ละเวอร์ชันและอย่าบังคับตัวเองให้เลียนแบบไวยากรณ์อื่น ๆ หากปัญหาต้องการโซลูชันอื่น

หากคุณเพิ่งเริ่มใช้ Python หรือเคยใช้ภาษาอื่นมาก่อน อย่าเพิ่งหงุดหงิดหากไม่พบคีย์เวิร์ดสวิตช์ในคู่มือ ลองพิจารณาความเป็นไปได้ทั้งหมดที่มีอยู่ และเลือกสิ่งที่เหมาะสมกับบริบทและความต้องการของคุณมากที่สุด

การจัดการทางเลือกต่างๆ ใน ​​Python ไม่เคยง่ายหรือทรงพลังเท่านี้มาก่อน ตอนนี้คุณเข้าใจเหตุผลเบื้องหลังการไม่มีสวิตช์ (และการมาถึงในเวลาต่อมา) วิธีจำลองสวิตช์อย่างมีประสิทธิภาพในทุกเวอร์ชัน และวิธีใช้ประโยชน์สูงสุดจากคำสั่ง match-case ใหม่ ไม่ว่าคุณจะต้องเลือกระหว่างตัวเลือกครึ่งโหล จัดการโครงสร้างที่ซับซ้อน ปฏิบัติตามแนวทางปฏิบัติที่ดีที่สุด หรือเป็นกังวลเกี่ยวกับประสิทธิภาพ คุณก็มีทางเลือกที่มั่นคง สง่างาม และยืดหยุ่น ไม่ว่าโค้ดของคุณจะใช้สำหรับสคริปต์ด่วนหรือแอปพลิเคชันที่ซับซ้อน Python ก็มีเครื่องมือที่ช่วยให้คุณเขียนได้อย่างชัดเจน รวดเร็ว และง่ายดาย