Привет!

В юбилейный минор третьего питона наконец-то завезли pattern matching. Саму концепцию сложно назвать новой, она уже реализована во многих языках, причём как нового поколения (Rust, Golang), так и у тех, кому уже за 0x18 (Java).


Анонсировал pattern matching Гвидо ван Россум, автор языка программирования Python и «великодушный пожизненный диктатор»

Меня зовут Денис Кайшев, я код-ревьюер на курсе «Мидл Python-разработчик». В этом посте хочу рассказать, зачем в Python pattern matching и как с ним работать.

Синтаксически конструкция pattern matching по сути аналогична тому, как это представлено в ряде других языков:

match_expr:
    | star_named_expression ',' star_named_expressions?
    | named_expression
match_stmt: "match" match_expr ':' NEWLINE INDENT case_block+ DEDENT
case_block: "case" patterns [guard] ':' block
guard: 'if' named_expression
patterns: value_pattern ',' [values_pattern] | pattern
pattern: walrus_pattern | or_pattern
walrus_pattern: NAME ':=' or_pattern
or_pattern: '|'.closed_pattern+
closed_pattern:
    | capture_pattern
    | literal_pattern
    | constant_pattern
    | group_pattern
    | sequence_pattern
    | mapping_pattern
    | class_pattern
capture_pattern: NAME !('.' | '(' | '=')
literal_pattern:
    | signed_number !('+' | '-')
    | signed_number '+' NUMBER
    | signed_number '-' NUMBER
    | strings
    | 'None'
    | 'True'
    | 'False'
constant_pattern: attr !('.' | '(' | '=')
group_pattern: '(' patterns ')'
sequence_pattern: '[' [values_pattern] ']' | '(' ')'
mapping_pattern: '{' items_pattern? '}'
class_pattern:
    | name_or_attr '(' ')'
    | name_or_attr '(' ','.pattern+ ','? ')'
    | name_or_attr '(' ','.keyword_pattern+ ','? ')'
    | name_or_attr '(' ','.pattern+ ',' ','.keyword_pattern+ ','? ')'
signed_number: NUMBER | '-' NUMBER
attr: name_or_attr '.' NAME
name_or_attr: attr | NAME
values_pattern: ','.value_pattern+ ','?
items_pattern: ','.key_value_pattern+ ','?
keyword_pattern: NAME '=' or_pattern
value_pattern: '*' capture_pattern | pattern
key_value_pattern:
    | (literal_pattern | constant_pattern) ':' or_pattern
    | '**' capture_pattern

Может показаться сложным и запутанным, но на самом деле всё сводится примерно к такому виду:

match some_expression:
    case pattern_1:
        ...
    case pattern_2:
        ...

Это выглядит куда понятнее и приятнее глазу.

Сами шаблоны разбиты на несколько групп:

• Literal Patterns;
• Capture Patterns;
• Wildcard Pattern;
• Constant Value Patterns;
• Sequence Patterns;
• Mapping Patterns;
• Class Patterns.

Расскажу немного о каждой из них.

Literal Patterns

Паттерн Literal, как намекает нам название, предполагает сопоставление между собой ряда значений, а именно строк, чисел, булевых значений и NULLNone.

Это выглядит как string == 'string', используется метод __eq__.

match number:
    case 42:
        print('answer')
    case 43:
        print('not answer')

Capture Patterns

Шаблон захвата позволяет связать переменную с заданным в шаблоне именем и использовать это имя внутри локальной области видимости.

match greeting:
    case "":
        print('Hello my friend')
    case name:
        print(f'Hello  {name}')

Wildcard Pattern

Если вариантов сопоставления слишком много, то можно использовать _ , что является неким значением по умолчанию и будет совпадать со всеми элементами в конструкции match

match number:
    case 42:
        print("Its’s forty two")
    case _:
        print("I don’t know, what it is")

Constant Value Patterns

При использовании констант нужно использовать dotted names, к примеру перечисления, иначе сработает паттерн захвата.

OK = 200
CONFLICT = 409

response = {'status': 409, 'msg': 'database error'}
match response['status'], response['msg']:
    case OK, ok_msg:
        print('handler 200')
    case CONFLICT, err_msg:
        print('handler 409')
    case _:
        print('idk this status')

И ожидаемый результат будет не самым очевидным.

Sequence Patterns

Позволяет сопоставлять списки, кортежи и любые другие объекты от collections.abc.Sequence, кроме str, bytes, bytearray.

answer = [42]
match answer:
    case []:   
        print('i do not find answer')
    case [x]:
        print('asnwer is 42')
    case [x, *_]:
        print('i find more than one answers')

Теперь нет необходимости каждый раз вызывать len() для проверки количества элементов в списке, так как будет вызван метод __len__.

Mapping Patterns

Эта группа немного похожа на предыдущую, только здесь мы сопоставляем словари, или, если быть точным, объекты типа collections.abc.Mapping. Их можно достаточно неплохо сочетать друг с другом.

args = (1, 2)
kwargs = {'kwarg': 'kwarg', 'one_more_kwarg': 'one_more_kwarg'}

def match_something(*args, **kwargs):
    match (args, kwargs):
        case (arg1, arg2), {'kwarg': kwarg}:
            print('i find positional args and one keyword args')
        case (arg1, arg2), {'kwarg': kwarg, 'one_more_kwarg': one_more_kwarg}:
            print('i find a few keyword args')
        case _:
            print('i cannot match anything')

match_something(*args, **kwargs)

И всё бы ничего, но есть особенность. Этот паттерн гарантирует вхождение этого ключа (ключей) в словарь, но длина словаря не имеет значения. Поэтому на экране появится i find positional args and one keyword args.

Class patterns

Что касается пользовательских типов данных, то здесь используется синтаксис, схожий с инициализацией объекта.

Вот как это будет выглядеть на примере дата-классов:

from dataclasses import dataclass

@dataclass
class Coordinate:
    x: int
    y: int
    z: int

coordinate = Coordinate(1, 2, 3)
match coordinate:
    case Coordinate(0, 0, 0):
        print('Zero point')
    case _:
        print('Another point')

Также можно использовать if, или так называемый guard. Если условие ложно, то сопоставление с шаблоном продолжится. Стоит отметить, что сначала происходит сопоставление с шаблоном, и только после этого проверяется условие:

case Coordinate(x, y, z) if z == 0:
    print('Point in the plane XY')

Если использовать непосредственно классы, то нужен атрибут __match_args__, в котором необходимы позиционные аргументы (для namedtuple и dataclasses __match_args__ генерируется автоматически).

class Coordinate:
    __match_args__ = ['x', 'y', 'z']

    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

сoordinate = Сoordinate(1, 2, 3)
match Сoordinate:
    case Сoordinate(0, 0, 0):
        print('Zero Сoordinate')
    case Сoordinate(x, y, z) if z == 0:
        print('Сoordinate in the plane Z')
    case _:
        print('Another Сoordinate')

Иначе вызовется исключение TypeError: Coordinate() accepts 0 positional sub-patterns (3 given)

Что в итоге?

Фактически это выглядит как очередной синтаксический сахар наряду с недавним walrus operator. Реализация в текущем её виде преобразует блоки оператора match в эквивалентные конструкции if/else, а именно в байт-код, который имеет такой же эффект.


Армин Ронахер, создатель веб-фреймворка Flask для Python, очень ёмко описал текущее состояние Pattern matching

Да, сложно спорить: код станет несколько чище, нежели это была бы башня из if/else на треть экрана. Но и назвать это тем, что производит вау-эффект, тоже нельзя. Неплохо, что оно вводится: местами это будет удобно использовать, но не везде. Так или иначе, главное с этой новизной не переусердствовать, не бежать быстрее обновлять все проекты на 3.10 и всё переписывать, ведь:

Now is better than never. Although never is often better than right now.

Будете использовать? Если да, то где?