Множественное присваивание: a, b = 1, 2

Привет! Ты уже знаешь, как присваивать значение одной переменной: x = 5. А что, если нужно присвоить значения сразу нескольким переменным? Или поменять их местами? В Python для этого есть элегантный механизм — множественное присваивание.

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

• Как присвоить значения нескольким переменным в одной строке
• Как менять значения переменных местами без третьей переменной
• Что такое распаковка (unpacking) списков и кортежей
• Расширенная распаковка с помощью *

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

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

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

Совет: Множественное присваивание делает код короче и читаемее. Это один из тех приёмов, который сразу заметен в Python-коде.

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

Присваивание нескольких переменных в одной строке

Вместо:

a = 1
b = 2
c = 3

Можно написать:

a, b, c = 1, 2, 3
print(a, b, c)   # 1 2 3

Количество переменных слева должно совпадать с количеством значений справа.

# Правильно
x, y = 10, 20

# Ошибка — не совпадает количество
# a, b = 1, 2, 3   # ValueError: too many values to unpack
# a, b, c = 1, 2   # ValueError: not enough values to unpack

Совет: Эта фишка особенно полезна, когда функция возвращает несколько значений.

Обмен значений переменных (swap)

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

# В других языках (например, Java, C++)
temp = a
a = b
b = temp

В Python это делается одной строкой:

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

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

Важно: Python сначала вычисляет все значения справа, а потом присваивает их переменным слева. Поэтому временная переменная не нужна.

Совет: Запомни этот трюк. Он очень часто используется в алгоритмах (сортировка, перестановки).

Присваивание одинакового значения

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

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

x = y = z = "Hello"
print(x, y, z)   # Hello Hello Hello

Распаковка (unpacking) списков и кортежей

Ты можешь «распаковать» список или кортеж в отдельные переменные.

# Распаковка кортежа
coordinates = (10, 20)
x, y = coordinates
print(x, y)   # 10 20

# Распаковка списка
colors = ["red", "green", "blue"]
r, g, b = colors
print(r, g, b)   # red green blue

Количество переменных должно совпадать с количеством элементов.

# Ошибка
items = [1, 2, 3]
# a, b = items   # ValueError: too many values to unpack

Совет: Распаковка часто используется, когда функция возвращает список или кортеж.

Игнорирование значений при распаковке

Если какие-то значения не нужны, их можно отбросить с помощью _ (подчёркивание).

person = ("Анна", 25, "Москва")
name, _, city = person
print(name, city)   # Анна Москва (возраст пропущен)

Совет: _ — это обычное допустимое имя переменной, но по соглашению оно означает «неиспользуемое значение».

Расширенная распаковка с помощью *

Если нужно собрать «оставшиеся» значения в список, используй *.

# Первое значение в a, остальные в rest
a, *rest = [1, 2, 3, 4, 5]
print(a)      # 1
print(rest)   # [2, 3, 4, 5]

# Первое и последнее в переменные, остальные в середину
first, *middle, last = [10, 20, 30, 40, 50]
print(first)   # 10
print(middle)  # [20, 30, 40]
print(last)    # 50

# Можно игнорировать часть значений
first, *_, last = [1, 2, 3, 4, 5]
print(first, last)   # 1 5

Важно: *rest создаёт список, даже если остался один элемент или ни одного.

a, *rest = [1]
print(a)      # 1
print(rest)   # [] (пустой список)

Распаковка с возвратом из функции

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

def get_user():
    return "Анна", 25, "Москва"

name, age, city = get_user()
print(name, age, city)   # Анна 25 Москва

Совет: Этот приём делает код чище и понятнее.

Пример из реальной жизни: обмен значений при сортировке

Алгоритм пузырьковой сортировки (часть):

def bubble_sort_step(arr, i):
    if arr[i] > arr[i + 1]:
        arr[i], arr[i + 1] = arr[i + 1], arr[i]   # Обмен значений

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

Задача 1. Присвой переменным x, y, z значения 5, 10, 15 одной строкой. Выведи их.

Задача 2. Поменяй местами значения переменных a = 100 и b = 200 без использования третьей переменной.

Задача 3. Распакуй список [1, 2, 3, 4] в переменные first, second, rest.

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

a = [1, 2, 3]
b = a
a, b = b, a
print(a, b)

Задача 5. Функция возвращает кортеж (100, 200, 300). Как присвоить значения переменным x, y, z?

Ответы:

Задача 1

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

Задача 2

a, b = 100, 200
a, b = b, a
print(a, b)   # 200 100

Задача 3

items = [1, 2, 3, 4]
first, second, *rest = items
print(first, second, rest)   # 1 2 [3, 4]

Задача 4

# [1, 2, 3] [1, 2, 3]
# Сначала вычисляются значения справа: b (это тот же список a) и a (это тот же список a)
# Потом присваивание: a = b, b = a — оба ссылаются на один список

Задача 5

result = (100, 200, 300)
x, y, z = result
# или сразу
x, y, z = (100, 200, 300)

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

Количество переменных должно совпадать

# Ошибка — лишнее значение
# a, b = 1, 2, 3   # ValueError

# Ошибка — не хватает значений
# a, b, c = 1, 2   # ValueError

Используй * для сбора лишних значений.

Обмен переменных работает благодаря параллельному вычислению

a, b = b, a
# Python сначала вычисляет (b, a), потом присваивает a и b

Это безопасно и не требует временной переменной.

Распаковка с * создаёт список

Даже если остался один элемент или ноль, *rest будет списком.

first, *rest = [42]
print(rest)   # [] (пустой список)

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

Ошибка 1: Несоответствие количества переменных и значений

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

a, b = 1, 2, 3

Правильно: Используй * для сбора лишних значений.

a, *b = 1, 2, 3
print(a, b)   # 1 [2, 3]

Ошибка 2: Забыл, что кортеж создаётся запятой, а не скобками

Скобки для кортежа необязательны.

a, b = 1, 2   # Обычный способ
(a, b) = (1, 2)   # Тоже работает, но длиннее

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

a, b = b, a   # обмен
a, b = a, b   # ничего не делает (бессмысленно)

Шпаргалка

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

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

• Присваивать несколько переменных одной строкой: a, b = 1, 2
• Менять местами значения без временной переменной: a, b = b, a
• Распаковывать списки и кортежи в переменные
• Использовать * для сбора «оставшихся» значений
• Игнорировать ненужные значения через

КВИЗ

Что дальше?

Следующая статья: «Динамическая типизация в Python: плюсы и минусы»