Вот почему нужно использовать оператор := в Python

Сегодня рассказываем о самом странном операторе Python — операторе моржа. Для чего он нужен, и как использовать его с учётом других особенностей языка? Подробности к старту курса по Fullstack-разработке на Python — под катом:

• Основы
• Накапливание (аккумулирование) данных на месте
• Именование значений внутри f-строки
• Any и All
• Подводные камни и ограничения
• Заключительные мысли

---

Оператор присваивания (или оператор моржа) появился ещё в Python 3.8, но он всё ещё вызывает споры, а многие необоснованно его ненавидят. Я же попытаюсь убедить вас, что этот оператор — хорошее дополнение к языку, а при правильном применении он может помочь сделать код короче и яснее.

Основы

Посмотрим на основные варианты применения оператора моржа, которые могут убедить вас попробовать, если вы ещё не знакомы с :=.

В первом примере, который я хочу показать, оператор моржа сокращает количество вызовов функций.

Представим функцию func(), которая выполняет очень ресурсоёмкие вычисления. Её работа занимает много времени, поэтому вызывать функцию много раз не хочется:

# "func" вызывается три раза
result = [func(x), func(x)**2, func(x)**3]

# Используем результат "func" в одну строку, без многострочного кода

result = [y := func(x), y**2, y**3]

В объявлении первого списка выше func(x) вызывается трижды. Каждый раз возвращается один и тот же результат — и это пустая трата времени ресурсов. При перезаписи с оператором моржа func() вызывается только один раз: её результат присваивается y и повторно используется для оставшихся значений списка. Вы можете возразить: «Морж не нужен, я могу просто добавить y = func(x) перед объявлением списка!» Да, но это лишняя строка кода, и на первый взгляд — не зная, что func(x) работает очень медленно, — может быть непонятно, для чего нужна переменная y.

Если это не убедило вас, есть ещё кое-что. Вот списковое включение с той же дорогостоящей func():

result = [func(x) for x in data if func(x)]

result = [y for x in data if (y := func(x))]

В первой строке функция func(x) в каждом цикле вызывается дважды. С оператором моржа функция вычисляется один раз, внутри if, а затем результат используется повторно. Длина кода одинаковая, обе строки одинаково читаемы, но вторая в два раза эффективнее. Производительность можно сохранить, заменив оператор моржа на полный цикл for, но для этого потребуется 5 строк кода.

Один из самых распространённых вариантов применения оператора моржа — сокращение вложенных условий, например в сопоставлении при работе с регулярными выражениями:

import re

test = "Something to match"

pattern1 = r"^.*(thing).*"
pattern2 = r"^.*(not present).*"

m = re.match(pattern1, test)
if m:
    print(f"Matched the 1st pattern: {m.group(1)}")
else:
    m = re.match(pattern2, test)
    if m:
        print(f"Matched the 2nd pattern: {m.group(1)}")

# ---------------------

# Чище

if m := (re.match(pattern1, test)):
    print(f"Matched 1st pattern: '{m.group(1)}'")
elif m := (re.match(pattern2, test)):
    print(f"Matched 2nd pattern: '{m.group(1)}'")

Код сократился с 7 до 4 строк, а за счёт удаления вложенного if стал более читаемым.

Следующая в списке — идиома «loop-and-half» («цикл пополам»):

while True:  # Цикл
    command = input("> ")
    if command == 'exit':  # и пополам
        break
    print("Your command was:", command)

# ---------------------

# Чище

while (command := input("> ")) != "exit":
    print("Your command was:", command)

Обычное решение — фиктивный бесконечный цикл while, в котором поток управления передаётся оператору break. Но также можно задействовать оператор моржа, чтобы переназначить значение command, а затем использовать его в условном цикле while в той же строке. Это сделает код намного чище и короче.

Аналогичное упрощение применимо и к другим циклам while, например при чтении файлов построчно или при получении данных из сокета.

Накапливание (аккумулирование) данных на месте

Перейдём к более сложным случаям применения оператора моржа:

data = [5, 4, 3, 2]
c = 0; print([(c := c + x) for x in data])  # c = 14
# [5, 9, 12, 14]

from itertools import accumulate
print(list(accumulate(data)))

# ---------------------

data = [5, 4, 3, 2]
print(list(accumulate(data, lambda a, b: a*b)))

# [5, 20, 60, 120]

a = 1; print([(a := a*b) for b in data])

# [5, 20, 60, 120]

Первые две строки показывают, как использовать := для вычисления промежуточного результата. В настолько простом случае лучше подойдёт функция itertools, например accumulate, как в двух следующих строках. Но в ситуациях сложнее itertools довольно быстро становится нечитаемым, и, на мой взгляд, версия с := намного лучше, чем с lambda.

Если вы всё ещё не уверены, ознакомьтесь с нечитабельными примерами в документации accumulate (с накоплением процентов или логистическим отображением). Попробуйте переписать их с оператором моржа, они станут выглядеть намного лучше.

---

Именно так, шаг за шагом, вы станете востребованным профессионалом в области IT:

• Профессия Fullstack-разработчик на Python (15 месяцев)
• Профессия Data Scientist (24 месяца)

Именование значений внутри f-строки

Этот пример показывает возможности и ограничения :=, но не лучшие практики.
Если очень хочется, := можно использовать внутри f-строк:

from datetime import datetime

print(f"Today is: {(today:=datetime.today()):%Y-%m-%d}, which is {today:%A}")

# Today is: 2022-07-01, which is Friday

from math import radians, sin, cos
angle = 60
print(f'{angle=}\N{degree sign} {(theta := radians(angle)) =: .2f}, {sin(theta) =: .2f}, {cos(theta) =: .2f}')

# angle=60° (theta := radians(angle)) = 1.05, sin(theta) = 0.87, cos(theta) = 0.50

В первом print оператор := определяет переменную today, которая затем используется в той же строке; today избавляет нас от повторного вызова datetime.today().

Точно так же во втором примере объявляется переменная theta, которая повторно используется для вычисления sin(theta) и cos(theta). В этом случае мы также используем его в сочетании с оператором «обратный морж» — на самом деле это просто =, с ним выражение выводится рядом с его значением, а : используется для форматирования выражения.

Обратите внимание: чтобы f-строка правильно интерпретировала выражения с оператором моржа, их нужно заключать в круглые скобки.

Any и All

Чтобы проверить, удовлетворяют ли какие-то значения в некотором итерируемом объекте определённому условию, можно восопользоваться функциями any() и all(). Но что делать, если нужно зафиксировать значение, из-за которого any() вернуло True (так называемое «свидетельство»), или значение, которое привело к сбою all() — «контрпример»?

numbers = [1, 4, 6, 2, 12, 4, 15]

# Возвращает только логические значения, а не обычные

print(any(number > 10 for number in numbers))  # True
print(all(number < 10 for number in numbers))  # False

# ---------------------

any((value := number) > 10 for number in numbers)  # True
print(value)  # 12

all((counter_example := number) < 10 for number in numbers)  # False
print(counter_example)  # 12

И any(), и all() для вычисления выражения используют замыкание, то есть прекращают вычисления, как только находят первое «свидетельство» или «контрпример» соответственно. А значит, при таком трюке созданная оператором моржа переменная всегда будет возвращать первого «свидетеля» или «контрпример».

Подводные камни и ограничения

Хотя выше я пытался убедить использовать оператор моржа, думаю, также важно предупредить о некоторых его недостатках и ограничениях. Ниже — подводные камни, с которыми вы можете столкнуться.

В предыдущем примере вы видели, что замыкание полезно для захвата значений в any()/all(), но иногда это может привести к неожиданным результатам:

for i in range(1, 100):
    if (two := i % 2 == 0) and (three := i % 3 == 0):
        print(f"{i} is divisible by 6.")
    elif two:
        print(f"{i} is divisible by 2.")
    elif three:
        print(f"{i} is divisible by 3.")

# NameError: name 'three' is not defined [имя 'three' не определено]

Мы создали условие с двумя соединёнными and присваиваниями. Эти and проверяют, делится ли число на 2, 3 или 6 в зависимости от того, выполняются ли первое, второе или оба условия. На первый взгляд это может показаться хорошим приёмом, но из-за замыкания, если выражение (two: = i % 2 == 0) не выполняется, вторая часть будет пропущена, а значит, имя three окажется неопределённым или будет иметь устаревшее значение из предыдущего цикла.

Замыкание может быть и преднамеренным. Использовать его можно с регулярными выражениями, чтобы найти в строке несколько паттернов:

import re

tests = ["Something to match", "Second one is present"]

pattern1 = r"^.*(thing).*"
pattern2 = r"^.*(present).*"

for test in tests:
    m = re.match(pattern1, test)
    if m:
        print(f"Matched the 1st pattern: {m.group(1)}")
    else:
        m = re.match(pattern2, test)
        if m:
            print(f"Matched the 2nd pattern: {m.group(1)}")

# Сопоставлено с первым паттерном: thing

# Сопоставлено со вторым паттерном: present

for test in tests:
    if m := (re.match(pattern1, test) or re.match(pattern2, test)):
        print(f"Matched: '{m.group(1)}'")
        # Сопоставлено: 'thing'
        # Сопоставлено: 'present'

Мы уже видели версию этого фрагмента в первом разделе статьи, где в сочетании с оператором моржа использовались if/elif. Здесь код упрощается ещё больше: условное выражение сокращается до единственного if.

Если вы только знакомитесь с оператором моржа, то заметите, что он заставляет переменные области видимости вести себя по-разному при списковом включении:

values = [3, 5, 2, 6, 12, 7, 15]

tmp = "unmodified"
dummy = [tmp for tmp in values]
print(tmp)  # Как и ожидалось, "tmp" не разбился на элементы. Он по-прежему "немодифицированный"

total = 0
partial_sums = [total := total + v for v in values]
print(total)  # Выводит: 50

При обычном списковом включении list, dict или set переменная цикла не просачивается в окружающую область, и поэтому любые существующие переменные с тем же именем не изменятся. Но с оператором моржа переменная из включения (total в приведённом выше коде) останется доступной после завершения включения, она примет значение из внутреннего включения.

Когда вы освоитесь с оператором моржа, то сможете попробовать его в других случаях. Но вот одно место, где вы никогда не должны его использовать, — это оператор with:

class ContextManager:
    def __enter__(self):
        print("Entering the context...")

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Leaving the context...")

with ContextManager() as context:
    print(context)  # None

with (context := ContextManager()):
    print(context)  # <__main__.ContextManager object at 0x7fb551cdb9d0>

С обычным синтаксисом with ContextManager() as context: ... context привязывается к возвращаемому значению context.__enter__(), а если вы используете версию с := — к результату ContextManager(). Часто это не имеет большого значения, ведь context.__enter__() обычно возвращает self, но если это не так, то при отладке возникнут большие проблемы.

Вот что происходит, когда вы используете оператор моржа с менеджером контекста closing:

from contextlib import closing
from urllib.request import urlopen

with closing(urlopen('https://www.python.org')) as page:
    for line in page:
        print(line)  # Вывод HTML-кода страницы

with (page := closing(urlopen('https://www.python.org'))):
    for line in page:
        print(line)  # TypeError: 'closing' object is not iterable [объект 'closing' не итерируемый]

Ещё одна проблема, с которой вы можете столкнуться, — приоритет оператора моржа, ведь он ниже приоритета логических операторов:

text = "Something to match."
flag = True

if match := re.match(r"^.*(thing).*", text) and flag:
    print(match.groups())  # AttributeError: 'bool' object has no attribute 'group' [у объекта 'bool' нет атрибута 'group']

if (match := re.match(r"^.*(thing).*", text)) and flag:
    print(match.groups())  # ('thing',)

Здесь мы видим, что присваивание нужно заключить в круглые скобки, чтобы гарантировать, что результат re.match(...) присваивается переменной. Если этого не сделать, выражение and будет вычисляться первым, то есть будет присвоен логический результат.

И, наконец, не ловушка, а скорее небольшое ограничение. Сейчас с оператором моржа нельзя использовать подсказки встроенного типа. Поэтому, если захочется указать тип переменной, нужно разбить её на 2 строки:

from typing import Optional

value: Optional[int] = None
while value := some_func():
    ...  # Что-то делаем

Заключительные мысли

Оператором моржа, как и любой другой особенностью синтаксиса, можно злоупотребить: снизить ясность и читабельность кода. Не нужно писать его везде, где только возможно. Относитесь к этому оператору как к инструменту — знайте его преимущества и недостатки, а используйте там, где это уместно.

Если хочется увидеть более практичное и эффективное использование оператора моржа, узнайте, как он появился в стандартной библиотеке CPython — все эти изменения можно найти в этом PR. И рекомендую прочитать PEP 572, в котором есть обоснование появления оператора и ещё больше примеров.

---

А мы поможем прокачать ваши навыки или с самого начала освоить профессию, востребованную в любое время:

• Профессия Data Scientist (24 месяца)
• Профессия Data Analyst (18 месяцев)
• Профессия Fullstack-разработчик на Python (15 месяцев)