כיצד להשתמש ב-Switch בפייתון: מדריך סופי עם דוגמאות וחלופות

Informatec Digital » תכנות » כיצד להשתמש ב-Switch בפייתון: מדריך מקיף עם דוגמאות וחלופות

האם תהיתם פעם כיצד לנהל מספר תנאים בפייתון בצורה פשוטה ויעילה? כשאתם עובדים עם שפות כמו C, Java או JavaScript, סביר להניח שהשתמשתם במשפט ה-switch-case המוכר כדי לבחור בין מספר אפשרויות בהתבסס על ערך המשתנה. עם זאת, בפייתון, מנגנון קלאסי זה לא היה קיים... עד לאחרונה. בעוד שמפתחים נאלצו למצוא חלופות במשך שנים, השפה מציעה כעת פתרון מודרני וחזק.

מאמר זה הוא המדריך האולטימטיבי שלכם להבנת אופן השימוש במקבילה של `switch` בפייתון , גילוי חלופות חזקות יותר בגרסאות ישנות יותר, הבהרת מדוע הוא לא נכלל בשלביו המוקדמים, ולמידה כיצד לכתוב קוד נקי וקריא יותר, ללא קשר לגרסה בה אתם משתמשים. התכוננו ללמוד את כל הטריקים, הדוגמאות וההבדלים המרכזיים ביישום מספר תנאי שימוש במערכת האקולוגית של פייתון.

האם המתג קיים בפייתון? היסטוריה וסיבות להיעדרו

תחביר ה-switch-case, הקיים בשפות רבות, לא הגיע רשמית לפייתון עד גרסה 3.10. הסיבה העיקרית היא פילוסופית: יוצרי פייתון תמיד העדיפו פשטות וקריאות. הם האמינו שהכנסת תחביר חדש עבור פקודות switch עלולה לסבך את העניינים, ולכן if-elif-else מספיקה כדי למלא את הפער הזה. יתר על כן, מעולם לא הייתה הסכמה לגבי התחביר האידיאלי. למעשה, מספר הצעות רשמיות (PEP 275, PEP 3103) נדחו עקב חוסר הסכמה ומכיוון שרבים חשו שהחלופות הקיימות ברורות וחזקות מספיק.

במשך שנים, הקהילה פיצתה על היעדר משפט "החלפה" באמצעות שרשראות תנאי ומילונים. מיותר לציין שזה עורר ויכוח, אך רחוק מלהיות חיסרון בלתי עביר, גישות אלו הוכיחו את עצמן כגמישות ובעלות יכולת הסתגלות גבוהה. עם זאת, ככל שהפרויקטים גדלו במורכבותם, הצורך בפתרון אלגנטי יותר הפך לברור יותר ויותר.

מהו מארז מתג ולמה הוא משמש?

משפט ה- switch-case הוא מבנה בקרה המשמש בשפות רבות לביצוע בלוקי קוד שונים בהתאם לערך של משתנה או ביטוי. במילים אחרות, הוא מאפשר לך לבחור אפשרות אחת מתוך אפשרויות רבות בצורה נקייה וישירה, תוך הימנעות משרשראות אינסופיות של משפטי תנאי.

דוגמאות אופייניות לשימוש יהיו: הצגת שם של יום בשבוע על סמך מספר, מתן ציונים, בחירת פעולות על סמך קלט משתמש וכו'. בשפות כמו C או Java, התחביר שלה פשוט:

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

בפייתון, מבנה קלאסי זה לא היה קיים עד לאחרונה, ולכן המפתחים נאלצו להיות יצירתיים כדי להשיג את אותה התוצאה.

הגעת המתג בפייתון: משפט ההתאמה (מאז פיתון 3.10)

עם יציאת גרסה 3.10, שילבה פייתון תכונה המיוחלת: משפט ה-match-case. למרות שתחביר ה-switch-case המסורתי דומה למשפט ה-switch-case המסורתי, הוא למעשה הרבה יותר חזק, שכן הוא מציג התאמת תבניות , המאפשרת השוואה לא רק של ערכים פשוטים, אלא גם של מבנים מורכבים, טאפלים, מחלקות, רשימות, מילונים וכן הלאה.

מקרה ההתאמה של פייתון כתוב כך:

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

הקו התחתון ( _ ) משמש כתו כללי והוא המקביל לברירת המחדל בשפות אחרות, והוא מבוצע כאשר אין תבנית קודמת תואמת.

למה זה כל כך חזק? כי אפשר לקבל תבניות מורכבות, ללכוד משתנים, לפתוח טאפלים או אובייקטים, ואפילו להשתמש ב-guards כדי להוסיף תנאים נוספים אחרי משפט המקרה:

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}")

בנוסף, בפייתון 3.10 ומעלה, מבנה זה משפר את הקריאות, התחזוקה והמדרגיות של הקוד שלך, במיוחד בעת טיפול במספר רב של מקרים.

חלופות למעבר בפייתון עבור גרסאות ישנות יותר

לפני הגעתו של 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')

יתרונות גישה זו:

• קוד פשוט וקל לקריאה.
• אתה לא צריך שום מבנים מיוחדים אחרים; זה פייתון טהור.
• ניתן להשתמש בכל סוג של השוואה, לא רק בשוויון.

חסרונות של סולם if-elif-else:

• נטייה לקוד חוזר על עצמו. עליך לחזור על המשתנה בכל השוואה, מה שיוצר הרבה טקסט מיותר אם יש לך הרבה מקרים.
• פחות יעיל כאשר יש מספר רב של תנאים. אם התיק הגיע לסיומו, כל התיקים הקודמים מוערכים לפני הגעתם.
• קושי בהוספה או הסרה של מקרים באופן דינמי.

2. שימוש במילונים כדי לדמות מקרה-מתג

דרך מאוד פייתונית לדמות פקודה מסוג switch היא באמצעות מילונים. הרעיון פשוט: מקשרים כל ערך אפשרי (key) לפונקציה או לפעולה (value) המתאימה. לאחר מכן, מבצעים שאילתה במילון כדי להשיג את הפונקציה ולהפעיל אותה.

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)()

היתרונות של שיטה זו:

• קוד קומפקטי וניתן להרחבה בקלות.
• גישה מהירה מאוד לפונקציה הנכונה. המילון משתמש בגיבוב (hashing), כך שהחיפוש הוא כמעט מיידי.
• מאפשר לך להקצות את אותה פונקציה למספר מקשים (לדוגמה, לקבוצות של מקרים).
• ניתן לשנות את המתג בזמן ריצה.

חסרונות:

• זה דורש הגדרה מראש של כל הפונקציות הקשורות, דבר שיכול להיות מסורבל עבור פעולות פשוטות.
• זה מאפשר השוואות רק לשוויון (זה לא עובד עבור מרווחים, טווחים וכו').
• זה לא מיועד למקרים עם לוגיקה מותנית מורכבת יותר בתוך כל בחירה.

ההבדל בין if-elif-else לבין switch (או match-case)

הפעולות הפנימיות של שרשרת if-elif-else שונות מאלה של פקודה switch. בפקודה if-elif-else, התנאים מוערכים אחד אחד, מלמעלה למטה, עד שמתקיים התנאי האמיתי הראשון. לכן, אם הערך הרצוי נמצא בתחילת התהליך, התהליך מהיר; אם הוא בסוף, הוא לוקח יותר זמן.

לעומת זאת, פקודות switch מסורתיות (ומילונים כחלופה בפייתון) בדרך כלל משתמשות בטבלאות חיפוש, וכתוצאה מכך גישה אחידה יותר, ללא קשר למספר המקרים או למיקומם. עם פקודות match-case ומילונים, זמני הגישה עקביים הרבה יותר.

מתי לבחור כל חלופה?

אין פתרון אוניברסלי אחד; הכלי הטוב ביותר תלוי בבעיה הספציפית.

• עבור מספר קטן של תנאים או לוגיקה מורכבת בכל ענף, if-elif-else היא הבחירה הפשוטה ביותר. זה מאפשר כל השוואה והוא גמיש מאוד.
• כאשר יש לכם מקרים רבים וכל אחד מהם פשוט מבצע פעולה ספציפית, הסתמכו על מילונים. הקוד נקי יותר, ניתן להרחבה וקל יותר לתחזוקה.
• אם אתם משתמשים ב-Python 3.10 ומעלה, מקרה גפרורים זוהי האפשרות הטובה ביותר לבהירות ועוצמה. זה מאפשר לך לשלב את האלגנטיות של המתג עם העוצמה של התאמת תבניות על מבנים מורכבים.

תמיד חשוב על הקריאות, הביצועים והתחזוקה של הקוד שלך.

דוגמאות מעשיות לשימוש ב-Switch בפייתון ובחלופות שלו

בואו נבחן מספר דוגמאות בהן כל אחת מהחלופות הללו מיושמת, מהמורכבות הנמוכה ביותר לגדולה ביותר:

דוגמה 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: שימוש בהתאמה-קטן/קטן ערך לבחירת פעולה אריתמטית

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')

כפי שניתן לראות, התחביר פשוט וברור מאוד. הקו התחתון מציין את ברירת המחדל של אותיות גדולות ורבות.

דוגמה מתקדמת: התאמת תבניות עם התאמה בין קטגוריית ...

הכוח הגדול של ניתוח התאמה-מקרה טמון ביכולתו לעבוד עם דפוסים מורכבים. לדוגמה, ניתן לנתח טפלים, רשימות, מילונים, אובייקטים וכן הלאה.

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, מילונים ו-match-case

ברוב המקרים, ההבדל בביצועים זניח עבור סקריפטים אופייניים. עם זאת, כאשר יש מספר רב של חלופות, מילונים וארגומנטים של התאמה בין אותיות ותיקיות יכולים להיות יעילים יותר, מכיוון שהם מפחיתים את מספר ההשוואות. בכל מקרה, הגורם החשוב ביותר הוא בדרך כלל קריאות ותחזוקה של הקוד , ולא מיקרו-אופטימיזציות שכמעט ולא עושות הבדל בפרויקטים בעולם האמיתי.

השתמש בטכניקה שהופכת את הקוד לברור יותר ומונעת שגיאות.

פתרונות יצירתיים: מחלקות ומנהלי הקשר לחיקוי מתג

חלק מהמפתחים יצרו מחלקות ייעודיות המאפשרות לדמות את ההתנהגות הקלאסית של ה-switch, כולל אפשרויות מתקדמות כגון הוספת break כדי לשלוט בביצוע של מקרים עוקבים, קיבוץ מקרים, התאמה אישית של השוואות או הפעלת Strict Mode המבטיח שרק ענף אחד יבוצע.

לדוגמה, ניתן ליישם מנהל הקשר מותאם אישית כך שישתמש בתחביר הדומה מאוד לשפות אחרות:

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` של 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.

טריק קטן: ניתן להמיר פונקציות קיימות לקבלת מילוני פעולות, מה שהופך את המעבר בין גישות לקל עוד יותר.

טיפים לאופטימיזציה ועיצוב לקוד פייתון נקי יותר

אל תיפול למלכודת של עיצוב שרשראות אינסופיות של תנאי גישה רק כדי לחקות את משפט ה-switch הקלאסי. חשבו על כל מקרה ספציפי והעריכו איזה מבנה בקרה מוסיף את הערך הרב ביותר להקשר של התוכנית שלכם. זכרו שפייתון מעריכה בהירות, לכן הימנעו מסיבוך יתר של הקוד שלכם אם אתם יכולים להשיג את אותה התוצאה בפשטות.

טיפ חשוב: בעת שימוש במילונים, השתמשו בפונקציה get() כדי למנוע שגיאות אם המפתח אינו קיים וכך להיות מסוגל להגדיר רישיות ברירת מחדל בצורה אלגנטית.

השוואה עם שפות אחרות ומחשבות אחרונות

בשפות מסוימות, כמו C, C++ או Java, מתגים מאפשרים רק השוואת ערכים פשוטים (מספרים שלמים, מחרוזות) ומספקים ערך מועט עבור מבנים מורכבים. פייתון הולכת צעד קדימה: ראשית, היא מציעה חלופות רב-תכליתיות (if-elif-else, מילונים), וכעת היא פותחת את הדלת ללוגיקה מתקדמת ללא מאמץ נוסף. המפתח הוא לנצל את היתרונות של כל גרסה ולא לאלץ את עצמך לחקות תחביר אחר אם הבעיה דורשת פתרון שונה.

אם אתם רק מתחילים לעבוד עם פייתון או מתחילים ללמוד שפות אחרות, אל תתסכלו אם אינכם מוצאים את מילת המפתח switch במדריך. חשבו על כל האפשרויות הזמינות ובחרו את זו שהכי מתאימה להקשר ולצרכים שלכם.

ניהול חלופות מרובות בפייתון מעולם לא היה קל או עוצמתי יותר. כעת אתם מבינים את הסיבות להיעדרותו (והגעתו לאחר מכן) של המתג, כיצד לדמות אותו ביעילות בכל גרסה, וכיצד להפיק את המרב מההצהרה החדשה של match-case. בין אם אתם צריכים לבחור בין חצי תריסר אפשרויות, לתפעל מבנים מורכבים, לפעול לפי שיטות עבודה מומלצות או לדאוג לביצועים, יש לכם חלופות חזקות, אלגנטיות וגמישות. בין אם הקוד שלכם מיועד לסקריפטים מהירים או ליישומים מורכבים, פייתון נותנת לכם את הכלים לכתוב אותו בצורה ברורה, מהירה וקלה.