Цепочка присваиваний: как работает a = b = c = 5

Привет! Ты уже знаешь, как присваивать значение одной переменной. А что, если нужно присвоить одно и то же значение сразу нескольким переменным? Можно написать три строки, а можно — одну.

В Python есть элегантный способ сделать это — цепочка присваиваний.

В этой статье мы разберём:

• Что такое цепочка присваиваний
• Как она работает под капотом
• Разница для неизменяемых и изменяемых типов
• Подводные камни и как их избежать

Что нужно знать перед началом

Для этого урока тебе понадобится:

• Установленный Python
• Базовое понимание переменных, изменяемых и неизменяемых типов (статьи 2, 9)

Совет: Цепочка присваиваний — удобный синтаксический сахар, но с изменяемыми типами нужно быть осторожным.

Основная часть

Что такое цепочка присваиваний

Цепочка присваиваний — это способ присвоить одно и то же значение нескольким переменным в одной строке.

a = b = c = 5
print(a, b, c)   # 5 5 5

Все три переменные получают значение 5.

Как это работает под капотом

В Python цепочка присваиваний выполняется справа налево.

a = b = c = 5

# Эквивалентно:
c = 5
b = c
a = b

Все переменные ссылаются на один и тот же объект.

a = b = c = 5
print(id(a), id(b), id(c))   # Все адреса одинаковые

Совет: Для неизменяемых типов (int, str) это безопасно — они не меняются.

Цепочка с неизменяемыми типами (int, str)

Для чисел и строк цепочка безопасна.

x = y = z = 10
print(x, y, z)   # 10 10 10

y = 20
print(x, y, z)   # 10 20 10

Числа неизменяемы. Когда мы меняем y, создаётся новый объект. x и z остаются неизменными.

a = b = c = "Python"
print(a, b, c)   # Python Python Python

b = "Java"
print(a, b, c)   # Python Java Python

Цепочка с изменяемыми типами (list, dict)

С изменяемыми типами всё иначе. Все переменные ссылаются на один и тот же объект.

a = b = c = []
print(a, b, c)   # [] [] []
print(id(a), id(b), id(c))   # Все одинаковые

a.append(1)
print(a, b, c)   # [1] [1] [1] — все изменились!

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

Как избежать проблем с изменяемыми типами

Если тебе нужны отдельные списки, используй разные присваивания.

# Плохо — все ссылаются на один список
a = b = c = []

# Хорошо — каждый получает свой список
a = []
b = []
c = []

Или используй copy():

a = []
b = c = a.copy()   # b и c — копии a

Цепочка с другими типами

Цепочка работает с любыми типами данных.

# С числами
a = b = c = 42

# Со строками
x = y = z = "hello"

# С логическими значениями
is_active = is_logged_in = is_admin = True

# С None
data = result = value = None

Совет: Особенно полезна цепочка для инициализации нескольких переменных одинаковым значением (например, счётчиков).

Смешанные цепочки

Можно использовать цепочку для разных типов.

a = b = c = 10
d = e = "Hello"
f = g = h = []

Но так делать не рекомендуется — это ухудшает читаемость.

Задачи для закрепления

Попробуй решить задачи самостоятельно.

Задача 1. Что выведет код?

x = y = z = 5
y = 10
print(x, y, z)

Задача 2. Что выведет код?

a = b = c = [1, 2, 3]
b.append(4)
print(a, b, c)

Задача 3. Как исправить код, чтобы переменные x, y, z имели отдельные списки?

Задача 4. Что выведет код?

a = b = c = 5
a += 1
print(a, b, c)

Задача 5. Можно ли использовать цепочку присваиваний для разных типов в одной строке?

Ответы:

Задача 1

# 5 10 5
# y получил новое значение, x и z остались 5.

Задача 2

# [1, 2, 3, 4] [1, 2, 3, 4] [1, 2, 3, 4]
# Все переменные ссылаются на один список.

Задача 3

x = []
y = []
z = []
# или
x, y, z = [], [], []

Задача 4

# 6 5 5
# a += 1 создаёт новый int, b и c остались 5.

Задача 5

# Можно, но не рекомендуется.
x = y = 10
a = b = "hello"

Нюансы и подводные камни

Изменяемые типы в цепочке — частый источник багов

# Классическая ошибка
def add_item(item, items=[]):
    items.append(item)
    return items

print(add_item(1))   # [1]
print(add_item(2))   # [1, 2] — неожиданно!

В этом примере список items создаётся один раз при определении функции. Подробнее об этом — в статье про аргументы по умолчанию.

Вложенные изменяемые объекты

a = b = c = [1, 2, 3]
a[0] = 99
print(a, b, c)   # [99, 2, 3] [99, 2, 3] [99, 2, 3]

Инициализация счётчиков

count1 = count2 = count3 = 0   # Отлично
count1 += 1
print(count1, count2, count3)   # 1 0 0

Для чисел это безопасно.

Частые ошибки и как их избежать

Ошибка 1: Цепочка присваиваний для списков

Неправильно:

a = b = c = []   # Все ссылаются на один список
a.append(1)      # a, b, c — все [1]

Правильно:

a = []
b = []
c = []

Ошибка 2: Путаница между цепочкой и множественным присваиванием

# Цепочка — одинаковые значения
a = b = c = 5

# Множественное присваивание — разные значения
a, b, c = 1, 2, 3

Ошибка 3: Изменение одного элемента через индекс

a = b = c = [1, 2, 3]
a[0] = 99   # Меняет все три!

Шпаргалка

Заключение / Выводы

Сегодня мы узнали:

• Цепочка присваиваний — a = b = c = 5
• Для неизменяемых типов (int, str) безопасна
• Для изменяемых типов (list, dict) — все переменные ссылаются на один объект
• Используй copy() или раздельное присваивание для списков
• Цепочка — удобный синтаксис, но с изменяемыми типами — осторожно

КВИЗ

Что дальше?

• Следующая статья: «Топ-5 ошибок с переменными и типами данных»