Что такое моржовый оператор?

Моржовый оператор (Walrus Operator) :=

Моржовый оператор (:=) — это оператор присваивания выражения (assignment expression), введённый в Python 3.8. Он позволяет присваивать значение переменной и использовать это значение в одном выражении. Его форма напоминает глаза и бивни моржа, отсюда название.

Синтаксис

# Традиционный способ (два шага)
value = some_function()
if value > 10:
    print(value)

# С моржовым оператором (один шаг)
if (value := some_function()) > 10:
    print(value)

# Переменная value доступна и после блока if!
print(value)  # ✓ Работает

Почему "моржовый"?

:= выглядит как глаза и бивни моржа

   / ^__^
  ( ( o o)  <-- Глаза и бивни
   \\ (=) /   <-- Форма :=
    (/|_|\\)

Основные применения

1. В условиях (if/while)

# Проблема: вычисляем и затем проверяем
data = get_api_response()
if data and len(data) > 0:
    process(data)

# Решение: моржовый оператор
if (data := get_api_response()) and len(data) > 0:
    process(data)

# Пример с while
import re
pattern = re.compile(r'\d+')
text = "abc123def456ghi"

while (match := pattern.search(text)):
    print(f"Найдено: {match.group()}")
    text = text[match.end():]  # Ищем дальше

2. В list comprehensions

# Без оператора (вычисляем дважды)
data = [
    x for x in (expensive_function(i) for i in range(5))
    if x > 10
]

# С оператором (вычисляем один раз)
data = [
    y for x in range(5)
    if (y := expensive_function(x)) > 10
]

# Пример: обработка данных из API
responses = [
    result for url in urls
    if (result := fetch_api(url)) is not None
]

3. В while циклах (очень полезно)

# Чтение файла (классический пример)
with open('large_file.txt') as f:
    while (line := f.readline()):
        process(line)

# Без оператора пришлось бы:
with open('large_file.txt') as f:
    while True:
        line = f.readline()
        if not line:
            break
        process(line)

# Пример: чтение сокетов
import socket
socket_fd = socket.socket()
while (data := socket_fd.recv(1024)):
    process_network_packet(data)

# Пример: работа с очередью
from queue import Queue
q = Queue()
while (item := q.get()) is not None:
    process_item(item)

4. Вложенные условия

# Проверка нескольких условий
if (user := get_user(user_id)):
    if (profile := user.get_profile()):
        if (settings := profile.get_settings()):
            apply_settings(settings)

# Можно красиво через and
if (user := get_user(user_id)) and \
   (profile := user.get_profile()) and \
   (settings := profile.get_settings()):
    apply_settings(settings)

Практические примеры

1. Парсинг текста

import re

text = "Email: john@example.com, Age: 30"
email_pattern = r'Email: ([\w\.-]+@[\w\.-]+)'
age_pattern = r'Age: (\d+)'

# С моржовым оператором
if (email_match := re.search(email_pattern, text)):
    email = email_match.group(1)
    print(f"Email: {email}")

if (age_match := re.search(age_pattern, text)):
    age = int(age_match.group(1))
    print(f"Age: {age}")

2. Кэширование с проверкой

class Cache:
    def __init__(self):
        self._cache = {}
    
    def get(self, key, factory):
        """Получить значение, если его нет — создать."""
        if (value := self._cache.get(key)) is not None:
            return value
        
        value = factory()
        self._cache[key] = value
        return value

# Использование
cache = Cache()
result = cache.get('expensive_key', lambda: expensive_computation())

3. Фильтрация списков с трансформацией

# Получить квадраты чисел, которые больше 50
numbers = [3, 5, 10, 15, 20]
squares_over_50 = [
    squared for num in numbers
    if (squared := num ** 2) > 50
]
print(squares_over_50)  # [100, 225, 400]

# Пример: фильтрация и трансформация JSON
import json
data = [
    {"name": "Alice", "age": 30},
    {"name": "Bob", "age": 25},
    {"name": "Charlie", "age": 35},
]

adults = [
    name for item in data
    if (name := item.get('name')) and item['age'] >= 30
]
print(adults)  # ['Alice', 'Charlie']

4. Обработка результатов функций

def validate_email(email: str) -> bool:
    return '@' in email

def get_user_by_email(email: str):
    if validate_email(email):
        return {"id": 1, "email": email}
    return None

# Без оператора
user_email = "user@example.com"
user = get_user_by_email(user_email)
if user:
    print(f"Пользователь найден: {user['id']}")

# С оператором
if (user := get_user_by_email("user@example.com")):
    print(f"Пользователь найден: {user['id']}")

Типичные ошибки

# ❌ Ошибка 1: забыли скобки
if x := 5 > 3:  # SyntaxError!
    print(x)

# ✓ Правильно: нужны скобки
if (x := 5) > 3:
    print(x)

# ❌ Ошибка 2: в верхнем уровне (вне выражения)
x := 5  # SyntaxError!

# ✓ Правильно: в выражении
(x := 5)
print(x)

# ❌ Ошибка 3: не видим переменную за пределами
if (x := 5):
    pass
print(x)  # ✓ На самом деле работает! Переменная видна

# ❌ Ошибка 4: используем то же имя переменной
x = 10
if (x := expensive_function()) > 5:  # Переписали x
    print(x)  # Это new x, не старая переменная!

Когда использовать и когда НЕ использовать

# ✓ ИСПОЛЬЗУЙ когда:
# 1. Избегаешь повторного вычисления
if (result := expensive_api_call()) is not None:
    process(result)

# 2. Делаешь код более читаемым
while (line := f.readline()):
    process(line)

# 3. Работаешь с regex
if (match := pattern.search(text)):
    do_something(match.group(1))

# ✓ НЕ ИСПОЛЬЗУЙ когда:
# 1. Делает код менее читаемым (слишком сложно)
data = [y for x in complex_generator() if (y := transform(x)) and (z := y.process()) and z.is_valid()]
# Лучше развернуть в обычный цикл:
data = []
for x in complex_generator():
    y = transform(x)
    if y:
        z = y.process()
        if z.is_valid():
            data.append(z)

# 2. В верхнем уровне скрипта (просто присваивай)
# ❌ (x := 5)
# ✓ x = 5

История появления (PEP 572)

# Python 3.7 и раньше:
# Нельзя было присваивать в выражениях

# Python 3.8+ :
# Добавлен моржовый оператор по PEP 572
# Это вызвало много дискуссий в сообществе

# Гвидо ван Россум (создатель Python) поддержал
# но ограничил использование скобками для ясности

Сравнение с другими языками

# Python (3.8+)
if (x := some_func()) > 10:
    print(x)

# Go (похоже)
if x, err := someFunc(); err == nil {
    fmt.Println(x)
}

# C++17
if (auto x = someFunc(); x > 10) {
    std::cout << x;
}

# JavaScript (нет встроенного, но можно через функции)
const x = someFunc();
if (x > 10) {
    console.log(x);
}

Реальные примеры из стандартной библиотеки

# Python 3.10+ использует моржовый оператор в своём коде
# Пример из pathlib:
class Path:
    def read_text(self):
        with open(self) as f:
            # Раньше нужно было открыть, прочитать, потом проверить
            # Теперь можно проще
            if (data := f.read()):
                return data

# Пример из re
def findall_with_limit(pattern, string, limit=10):
    found = []
    for match in re.finditer(pattern, string):
        if (text := match.group(0)) and len(found) < limit:
            found.append(text)
    return found

Ключевые моменты

• := это оператор присваивания выражения (assignment expression)
• Вводит переменную в текущий scope
• Должны быть скобки вокруг выражения (кроме специальных случаев)
• Очень полезен в while циклах и list comprehensions
• Избегает повторного вычисления дорогих функций
• Можно переиспользовать переменную но это может быть запутанным
• Не всегда улучшает читаемость — используй осторожно
• Доступен только в Python 3.8+