Переменные в Python: как объявить, присвоить и назвать

Переменная - это имя

Переменная в Python - это имя, которое ты прикрепляешь к значению. Пишешь имя, знак равенства и значение:

age = 30
name = "Rosa"
is_admin = True

print(age, name, is_admin)

Три переменные, три значения, три типа. Python спокойно держит их бок о бок, а тебе не пришлось ничего сообщать ему о том, какого типа эти значения. Значение идёт после =; имя - перед.

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

price = 19.99
quantity = 3
total = price * quantity

print("You owe", total)

Имена делают предпоследнюю строку самоописательной. В этом и главный выигрыш от хороших имён переменных - код, который читается как объяснение.

Присваивание - это не математика

Вот что ловит людей, пришедших из уроков математики: = в Python - это не «равно». Это «присвоить». Означает: «возьми значение после = и прикрепи его к имени слева». Python сначала вычисляет значение, потом делает присваивание.

Поэтому вот это совершенно законно:

count = 0
count = count + 1
count = count + 1
print(count)

Строка count = count + 1 не утверждает, что count равен count плюс один (математически невозможно). Она говорит: вычисли count + 1 и присвой результат обратно в count. Python сперва вычисляет выражение - 0 + 1 даёт 1 - и только потом обновляет переменную.

Писать count = count + 1 ты будешь достаточно часто, чтобы у Python был сокращённый вариант: count += 1 делает то же самое.

Переприсваивание меняет ярлык, а не значение

Переменная может начать указывать на другое значение в любой момент. Старое значение не модифицируется - переменная просто начинает ссылаться на что-то другое:

mood = "hopeful"
print(mood)

mood = "determined"
print(mood)

mood = 42
print(mood)

Обрати внимание на последнюю строку. mood две строки держит строку, а потом вдруг - целое число. Python не возразил. Это динамическая типизация - фиксированного типа у переменных нет, он есть только у значений. Эта гибкость помогает при прототипировании и кусается, когда переменная незаметно меняет смысл внутри функции. Безопасная привычка - подобрать имя, подходящее к тому, что представляет значение, и держать переменную в этой одной роли всю её жизнь.

Правила для имён переменных

Python принимает имена, которые:

• Начинаются с буквы или подчёркивания (_).
• Содержат буквы, цифры и подчёркивания.
• Не являются зарезервированным ключевым словом (if, for, class, return и ещё пара десятков).

Значит, вот эти валидны:

user_name = "Ada"
_internal = 42
score2 = 99

print(user_name, _internal, score2)

А эти - нет:

• 2nd_user - не может начинаться с цифры.
• user-name - дефисы запрещены (Python читает их как вычитание).
• class - зарезервированное ключевое слово.
• user name - пробелов в именах не бывает.

Имена чувствительны к регистру, как ты уже знаешь: total, Total и TOTAL - три разные переменные. Опечатку за тебя Python не заметит.

Соглашения об именовании

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

• lower_snake_case для обычных переменных и функций: retry_count, fetch_profile.
• UPPER_SNAKE_CASE для констант: MAX_RETRIES = 5.
• PascalCase для имён классов (к ним ещё вернёмся).
• Ведущее подчёркивание (_something) - намёк, что имя задумывалось приватным. Не форсируется - только соглашение.
• Замыкающее подчёркивание (class_) позволяет использовать имя, которое иначе столкнулось бы с ключевым словом.

Придерживайся этого - и твой код будет выглядеть как тот Python, что писали другие.

Имена должны описывать смысл

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

Сравни:

# Hard to follow:
x = 1200
y = 0.08
z = x * y
print(z)

# Easy to follow:
price = 1200
tax_rate = 0.08
tax_due = price * tax_rate
print(tax_due)

Один и тот же код, один и тот же ответ - но только вторая версия сообщает, что происходит. Короткие имена (i, n, x) уместны в очень маленьких областях видимости вроде счётчиков цикла, но за их пределами - разворачивай слова.

Множественное присваивание (используй умеренно)

Python позволяет одной строкой присвоить одно значение нескольким переменным:

x = y = z = 0
print(x, y, z)

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

name, age, city = "Rosa", 30, "Lisbon"
print(name, age, city)

Оба подходят, когда делают код яснее (например, распаковка возвращаемого значения функции). С первой формой - цепочкой = = = - стоит быть внимательным: все три переменные в итоге ссылаются на один и тот же объект, что важно для изменяемых типов вроде списков (к этому ещё вернёмся).

Что унести с собой

• name = value создаёт переменную.
• У переменных типа нет; он есть у значений.
• Имена подчиняются нескольким жёстким правилам и множеству мягких соглашений - уважай и те, и другие.
• Описательное имя - самая дешёвая форма документации.

Дальше - какие именно типы значений Python поддерживает на самом деле: целые, дробные, строки, булевы, и почему полезно понимать, что есть что.