Немного примеров match/case в Python 3.10

Не так давно (а именно 4 октября 2021 года) официально увидела свет юбилейная версия языка python, а именно версия 3.10. В ней было добавлено несколько изменений, а самым интересным (на мой взгляд) было введение pattern matching statement (оператор сопоставления с шаблонами). Как гласит официальное описание этого оператора в PEP622, разработчики в большей мере вдохновлялись наработками таких языков как: Scala, Erlang, Rust.

Для тех, кто еще не знаком с данным оператором и всей его красотой, предлагаю познакомиться с pattern matching в данной статье. 

Немного о pattern matching

Как говорится в официальной документации (PEP622) в Python очень часто требуется проверять данные на соответствие типов, обращаться к данным по индексу и к этим же данным применять проверку на тип. Также зачастую приходится проверять не только тип данных, но и количество, что приводит к появлению огромного числа веток if/else с вызовом функций isinstance, len и обращению к элементам по индексу, ключу или атрибуту. Именно для упрощения работы и уменьшения is/else был введен новый оператор match/case.

Очень важно не путать pattern matching и switch/case, их главное отличие состоит в том, что pattern matching - это не просто оператор для сравнения некоторой переменной со значениями, это целый механизм для проверки данных, их распаковки и управления потоком выполнения.

Давай же рассмотрим несколько примеров, как данный оператор поможет упростить написание кода и сделать код более читаемым.

Примеры

Самый простой пример - это сравнение некоторой переменной со значениями (сначала рассмотрим как это было бы с if/else):

def load():
   print("Загружаем")
def save():
   print("Сохраняем")
def default():
   print("Неизвестно как обработать")

def main(value):
   if isinstance(value, str) and value == "load":
       load()
   elif isinstance(value, str) and value == "save":
       save()
   else:
       default()
      
main("load")
>>> Загружаем
main("save")
>>> Сохраняем
main("hello")
>>> Неизвестно как обработать

Теперь с match/case:

def main(value):
   match value:
       case "load":
           load()
       case "save":
           save()
       case _:
           default()
main("load")
>>> Загружаем
main("save")
>>> Сохраняем
main(5645)
>>> Неизвестно как обработать

Стало заметно меньше "and" и "==", получилось избавиться от лишних проверок на тип данных и код стал более понятным, однако это лишь самый простой пример, углубимся дальше. Допустим, откуда-то приходят данные в виде строки, которые записаны с разделителем “~”, и заранее известно, что если в данных было ровно 2 значения, то выполнить одно действие, если 3 значения, то иное действие:

def load(link):
   print("Загружаем", link)
   return "hello"
def save(link, filename):
   data = load(link)
   print("Сохраняем в", filename)
def default(values):
   print("Неизвестно как эти данные обработать")
    
def main(data_string):
   values = data_string.split("~")
   if isinstance(values, (list, tuple)) and len(values) == 2 and values[0] == "load":
       load(values[1])
   elif isinstance(values, (list, tuple)) and len(values) == 3 and values[0] == "save":
       save(values[1], values[2])
   else:
       default(values)
      
main("load~http://example.com/files/test.txt")
>>> Загружаем http://example.com/files/test.txt
main("save~http://example.com/files/test.txt~file.txt")
>>> Загружаем http://example.com/files/test.txt
>>> Сохраняем в file.txt
main("use~http://example.com/files/test.txt~file.txt")
>>> Неизвестно как эти данные обработать
main("save~http://example.com/files/test.txt~file.txt~file2.txt")
>>> Неизвестно как эти данные обработать

И с match/case:

def main(data_string):
   values = data_string.split("~")
   match values:
       case "load", link:
           load(link)
       case "save", link, filename:
           save(link, filename)
       case _:
           default(values)
main("load~http://example.com/files/test.txt")
>>> Загружаем http://example.com/files/test.txt
main("save~http://example.com/files/test.txt~file.txt")
>>> Загружаем http://example.com/files/test.txt
>>> Сохраняем в file.txt
main("use~http://example.com/files/test.txt~file.txt")
>>> Неизвестно как эти данные обработать
main("save~http://example.com/files/test.txt~file.txt~file2.txt")
>>> Неизвестно как эти данные обработать

Также, если есть необходимо скачать несколько файлов:

def load(links):
   print("Загружаем", links)
   return "hello"
def main(data_string):
   values = data_string.split("~")
   match values:
       case "load", *links:
           load(links)
       case _:
           default(values)
main("load~http://example.com/files/test.txt~http://example.com/files/test1.txt")
>>> Загружаем ['http://example.com/files/test.txt', 'http://example.com/files/test1.txt']

Match/case сам решает проблему с проверкой типов данных, с проверкой значений и их количеством, что позволяет упростить логику и увеличить читаемость кода. И очень удобно, что можно объявлять переменные и помещать в них значения прямо в ветке case без использования моржового оператора. 

Рассмотрим пример, когда необходимо использовать оператор “или” в примере. Допустим, приходит запрос от пользователя с правами, и необходимо проверить, может ли данный пользователь выполнять текущее действие:

def main(data_string):
   values = data_string.split("~")
   match values:
       case name, "1"|"2" as access, request:
           print(f"Пользователь {name} получил доступ к функции {request} с правами {access}")
       case _:
           print("Неудача")
main("Daniil~2~load")
>>> Пользователь Daniil получил доступ к функции load с правами 2
main("Kris~0~save")
>>> Неудача

В таком случае символ “|” выступает в роли логического “или”, а значение прав доступа в переменную access было записано при помощи оператора "as". Разберем аналогичный пример, но в качестве аргумента будем рассматривать словарь:

def main(data_dict):
   match data_dict:
       case {"name": str(name), "access": 1|2 as access, "request": request}:
           print(f"Пользователь {name} получил доступ к функции {request} с правами {access}")
       case _:
           print("Неудача")
main({"name": "Daniil", "access": 1, "request": "save"})
>>> Пользователь Daniil получил доступ к функции save с правами 1
main({"name": ["Daniil"], "access": 1, "request": "save"})
>>> Неудача
main({"name": "Kris", "access": 0, "request": "load"})
>>> Неудача

Как видим, довольно просто делать сравнение шаблонов для словарей. Пойдем еще дальше и создадим класс для хранения всех этих данных, затем попробуем организовать блок match/case для классов:

class UserRequest:
   def __init__(self, name, access, request):
       self.name = name
       self.access = access
       self.request = request
def main(data_class):
   match data_class:
       case UserRequest(name=str(name), access=1|2 as access, request=request):
           print(f"Пользователь {name} получил доступ к функции {request} с правами {access}")
       case _:
           print("Неудача")
main(UserRequest("Daniil", 1, "delete"))
>>> Пользователь Daniil получил доступ к функции delete с правами 1
main(UserRequest(1234, 1, "delete"))
>>> Неудача
main(UserRequest("Kris", 0, "save"))
>>> Неудача

Чтобы еще упростить код и не писать названия атрибутов класса, которые сравниваются, можно прописать в классе атрибут match_args, благодаря которому case будет рассматривать значения, передаваемые при сравнивании в том порядке, в котором они записаны в  match_args:

class UserRequest:
   __match_args__= ('name', 'access', 'request')
   def __init__(self, name, access, request):
       self.name = name
       self.access = access
       self.request = request
def main(data_class):
   match data_class:
       case UserRequest(str(name), 1|2 as access, request):
           print(f"Пользователь {name} получил доступ к функции {request} с правами {access}")
       case _:
           print("Неудача")
main(UserRequest("Daniil", 1, "delete"))
>>> Пользователь Daniil получил доступ к функции delete с правами 1
main(UserRequest(1234, 1, "delete"))
>>> Неудача
main(UserRequest("Kris", 0, "save"))
>>> Неудача

Так же стоить помнить, что при работе case UserRequest(str(name), access=2, request) оператор похож на создание нового экземпляра, однако это так не работает. Рассмотрим пример, подтверждающий это:

class UserRequest:
   __match_args__= ('name', 'access', 'request')
   def __init__(self, name, access, request):
       print("Создан новый UserRequest")
       self.name = name
       self.access = access
       self.request = request
def main(data_class):
   match data_class:
       case UserRequest(str(name), 1|2 as access, request):
           print(f"Пользователь {name} получил доступ к функции {request} с правами {access}")
       case _:
           print("Неудача")
main(UserRequest("Daniil", 1, "delete"))
>>> Создан новый UserRequest
>>> Пользователь Daniil получил доступ к функции delete с правами 1

Как видно, вызов init произошел всего один раз, поэтому при работе case с классами не создаются новые новые экземпляры классов!

Более сложный и не такой тривиальный пример со сравнением некоторых данных, пришедших в оператор match/case:

class UserRequest:
  __match_args__= ('name', 'access', 'request')
  def __init__(self, name, access, request):
      self.name = name
      self.access = access
      self.request = request
def main(data_class):
  match data_class:
       case UserRequest(_, _, request) if request["func"] == "delete" and request["directory"] == "main_folder":
           print(f"Нельзя удалять файлы из {request['directory']}")
       case UserRequest(str(name), 1|2 as access, request) if request["func"] != "delete":
           print(f"Пользователь {name} получил доступ к файлу {request['file']} с правами {access} на {request['func']}")
       case _:
           print("Неудача")
main(UserRequest("Daniil", 1, {"func": "delete", "file": "test.txt", "directory": "main_folder"}))
>>> Нельзя удалять файлы из main_folder
main(UserRequest("Daniil", 1, {"func": "save", "file": "test.txt", "directory": "main_folder"}))
>>> Пользователь Daniil получил доступ к файлу test.txt с правами 1 на save

“_” позволяет не объявлять переменную под данные, а просто указывает, что на этом месте должны быть какие-то данные, но их можно не задействовать дальше. Также можно использовать оператор if для того, чтобы добавлять новые условия на проверку шаблона.

Заключение

Новый оператор pattern matching сильно упрощает жизнь во многих моментах и делает код еще более читаемым и лаконичным, что позволяет писать код быстрее и эффективнее не боясь за то, что вдруг где-то в коде не стоит проверка на тип элемента или на количество элементов в списке.

В данной статье были рассмотрены лишь несколько примеров для знакомства с оператором match/case, также существует возможность создавать более детальные и глубокие проверки в шаблонах, поэтому каждому стоит поэкспериментировать с данным оператором, так как, возможно, он позволит вам сделать код еще чище и проще.