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

בדוגמה הראשונה מתוך התיעוד יש לנו קטע קוד שמועתק מדג'נגו:

if (
    isinstance(value, (list, tuple)) and
    len(value) > 1 and
    isinstance(value[-1], (Promise, str))
):
    *value, label = value
    value = tuple(value)
else:
    label = key.replace('_', ' ').title()

ואחרי המעבר ל Structural Pattern Matching הוא יראה כך:

match value:
    case [*v, label := (Promise() | str())] if v:
        value = tuple(v)
    case _:
        label = key.replace('_', ' ').title()

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

[*v, _] = value

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

ה Promise וה str מופיעים שם בתור הפעלה של פונקציות, למרות שבתוכנית אמיתית לא היינו מפעילים פונקציות אלה בשביל לבדוק שייכות למחלקה אלא משתמשים ב isinstance מהדוגמה לפני השינוי.

פעולת match/case הופכת אפילו יותר מסובכת כשמדובר על התאמה למחלקות שלנו. ניקח את הספריה regex_spm בתור דוגמה ואת הקוד הבא מתוך התיעוד שלה:

match regex_spm.fullmatch_in("123,45"):
  case r"(\d+),(?P<second>\d+)" as m:
    print("Notice the `as m` at the end of the line above")
    print(f"The first group is {m[1]}")
    print(f"The second group is {m['second']}")
    print(f"The full `re.Match` object is available as {m.match}")

זה נראה כמו קסם עד שאנחנו נזכרים במימוש של הספריה:

@dataclass
class RegexSpmMatch:
  string: str
  _match_func: Callable[[re.Pattern, str], re.Match]
  match: re.Match | None = None

  def __eq__(self, pattern: str | re.Pattern | tuple[str, int | re.RegexFlag]):
    if isinstance(pattern, str):
      pattern = re.compile(pattern)
    elif isinstance(pattern, tuple):
      pattern = re.compile(*pattern)
    self.match = self._match_func(pattern, self.string)
    return self.match is not None

  def __getitem__(
      self,
      group: int | str | tuple[int, ...] | tuple[str, ...]
  ) -> str | tuple[str, ...] | None:
    return self.match[group]

בעצם יש לנו dataclass עם מימוש מקוסטם לפונקציה __eq__ מה שגורם להתאמה מול ה case. ה as המועתק למשתנה m הוא לא Match Object אלא אותו dataclass מהספריה, שכולל מימוש ל __getitem__ כדי לאפשר את כתיב הסוגריים המרובעים.

נשווה את זה לגירסת ה if/else:

if m := re.search("(\d+),(?P<second>\d+)", text):
    ...
elif m := re.search("(\d)-(\d)", text):
    ...
else:
    print("no match")

וקל לראות שדווקא גישת ה if/else יצאה יותר קריאה ויותר חסכונית. לראיה הקוד הזה שנראה מאוד הגיוני אבל לא עובד עם הספריה:

pattern1 = r"my-first-pattern"
pattern2 = re.compile(r"my-second-pattern")
match regex_spm.search_in(my_string):
  case pattern1: print("This does not work, it matches any string. Python interprets `pattern1` "
                       "as simply a new capture variable name, hiding its previous value.")
  case pattern2: print("This does not work either")

סך הכל Structural Pattern Matching זה כן מנגנון ממש אחלה. תשתמשו בו איפה שהגיוני אבל שימו לב להיזהר משימוש יתר.