Переменные и присваивание

В предыдущих уроках мы уже запускали код и выводили текст через print(). Каждый раз значение писалось прямо в вызове — строка или число фиксировались на месте. Но что делать, если одно и то же значение нужно использовать несколько раз или оно может меняться? Здесь и появляется переменная.

Что такое переменная и зачем она нужна

Переменная — это имя, под которым Python хранит какое-то значение. Удобнее всего думать об этом как о ящике с подписью: вы кладёте внутрь значение и клеите на ящик ярлык с именем. Потом, когда нужно это значение, вы просто называете ярлык.

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

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

Переменные делают код читаемым. Сравните два варианта:

# без переменной
print("Привет, Анна! Рады видеть тебя, Анна.")

# с переменной
name = "Анна"
print("Привет, " + name + "! Рады видеть тебя, " + name + ".")

Во втором случае имя хранится в одном месте. Если его нужно поменять, меняете только строку name = "Анна" — и всё остальное обновится автоматически.

Концептуально переменная — это связь между именем и значением. Python ищет значение по имени каждый раз, когда вы его упоминаете в коде.

Оператор присваивания =

Когда вы пишете name = "Анна", знак = делает ровно одну вещь: берёт значение справа и связывает его с именем слева. Сначала Python вычисляет правую часть — в данном случае это строка "Анна". Потом привязывает результат к имени name. Это и есть присваивание.

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

x = 2 + 3
greeting = "Привет, " + "мир"

В первом случае Python сначала посчитает 2 + 3, получит 5 и запишет это число под именем x. Во втором — склеит две строки и запишет результат под именем greeting. Само имя переменной в этот момент на правую часть не влияет никак.

Теперь важный момент, который сбивает с толку почти всех, кто раньше не программировал. В математике запись a = b означает, что a и b равны — это утверждение о равенстве. В Python = — это не утверждение, а команда: «запиши вот это значение под вот этим именем». Проверка равенства в Python выглядит иначе — это двойное ==. Но об этом будет отдельный разговор позже.

Ещё одно следствие из однонаправленности присваивания: можно написать

count = 0
count = count + 1

С точки зрения математики это выглядит бессмысленно — число не может равняться себе плюс единица. Но Python читает эту строку слева направо в два шага: сначала вычислить count + 1 (получится 1), потом записать 1 обратно под именем count. Старое значение при этом теряется. Именно так в программах обновляют счётчики и накапливают суммы.

Имена переменных: правила и ограничения

Имя переменной — это не просто строка символов, которую вы придумываете произвольно. У Python есть жёсткие правила, и если вы их нарушаете, интерпретатор отказывается выполнять код ещё до того, как дойдёт до вашей логики.

Имя может состоять из букв латинского алфавита (а также символов Unicode, но об этом позже), цифр и символа подчёркивания _. Всё остальное — пробелы, дефисы, точки, скобки — недопустимо.

Одно ограничение особенно важно запомнить: имя не может начинаться с цифры. Python видит цифру в начале и думает, что перед ним число, а не идентификатор. Поэтому 2name — синтаксическая ошибка, а name2 — вполне корректное имя.

Второе правило касается регистра. Python различает строчные и прописные буквы, так что age, Age и AGE — это три разные переменные. Случайная путаница регистра — частый источник ошибок у начинающих, особенно когда переменная объявляется в одном месте, а используется в другом с другим регистром.

Третье правило: нельзя использовать зарезервированные слова Python в качестве имён переменных. Зарезервированные слова — это ключевые слова языка, которые Python уже занял под свои нужды: if, for, while, and, or, not, True, False, None, return, def и другие. Если попробовать написать if = 5, получите SyntaxError немедленно. Таких слов в языке несколько десятков — запоминать их список целиком не нужно, достаточно знать, что они существуют, и не удивляться ошибке, если имя окажется занятым.

Наконец, несколько слов о стиле. Технически X, myVar, my_var и MYVAR — всё это допустимые имена. Но в Python-сообществе принято писать имена переменных строчными буквами, разделяя слова подчёркиванием: user_name, total_price, max_value. Такой стиль называется snake_case, и он сделает ваш код читаемым для любого другого Python-разработчика.

Вот примеры, которые иллюстрируют все правила сразу:

user_name = "Анна"   # корректно: строчные буквы, подчёркивание
age2 = 25            # корректно: цифра не в начале
_temp = 0            # корректно: начинается с подчёркивания

# Эти варианты вызовут ошибку:
# 2name = "Анна"     # SyntaxError: начинается с цифры
# my-name = "Анна"   # SyntaxError: дефис недопустим
# if = 3             # SyntaxError: зарезервированное слово

Примеры с ошибками закомментированы — они показывают запрещённые конструкции, не прерывая выполнение файла. Попробуйте раскомментировать любую из них и запустить — Python выдаст SyntaxError с указанием строки.

Переменные в print() и типичные ошибки

Теория готова — теперь посмотрим, как переменная работает в связке с print(), и разберём ошибку, которую предыдущие разделы не затрагивали.

Самый простой сценарий: сохранить значение в переменную и передать её в print().

name = "Анна"
print(name)

Вывод:

Анна

Когда Python доходит до print(name), он не выводит слово name — он ищет, какое значение сейчас хранится под этим именем, и выводит его. Здесь это строка "Анна".

print() принимает любое количество аргументов через запятую, и переменные можно смешивать как угодно:

first_name = "Анна"
last_name = "Смирнова"
print(first_name, last_name)

Вывод:

Анна Смирнова

Python автоматически вставляет пробел между аргументами — это поведение print() по умолчанию.

SyntaxError и NameError: в чём разница

Если имя переменной нарушает правила из предыдущего раздела — начинается с цифры или совпадает с ключевым словом — Python выдаст SyntaxError ещё до запуска программы. Это ошибки разбора кода — такие же, как SyntaxError из-за опечатки, с которой мы уже встречались. Здесь причина другая: недопустимое имя переменной, но Python также обнаруживает её до запуска программы.

Но есть ошибка другого рода, с которой вы столкнётесь в процессе выполнения:

print(greeting)       # NameError: name 'greeting' is not defined
greeting = "Привет"

Здесь имя greeting написано правильно — оно не нарушает никаких правил именования. Но Python выполняет код сверху вниз, и когда доходит до строки print(greeting), переменная ещё не существует: она объявлена строчкой ниже. Python не смотрит вперёд — он ищет greeting прямо сейчас и не находит.

Результат — NameError во время выполнения, а не при разборе. Это принципиальное отличие от SyntaxError: программа успела запуститься, но упала на конкретной строке.

Исправление одно — поставить присваивание перед использованием:

greeting = "Привет"
print(greeting)       # Привет

Правило простое: переменная должна быть создана раньше, чем вы к ней обращаетесь.