Переменные в Python

Допустим, мы пишем программу-приветствие. Имя пользователя мы не знаем заранее: оно появится только когда программа запустится. Значит, в коде нам нужно как-то ссылаться на это будущее имя, не зная его. Именно для этого существуют переменные.

Python 3.13
12
name = "Иван"
print("Привет, " + name + "!")

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

Переменная как подпись, указывающая на объект в памяти

Что такое переменная?

Переменная в Python — это имя, привязанное к объекту в памяти. Тип объекта Python определяет сам, и эту привязку можно поменять в любой момент.

Из этой формулировки следуют три удобства:

не нужно объявлять переменную заранее: она появляется при первом присваивании
не нужно указывать тип: Python видит, что справа, и запоминает
можно перепривязать имя к другому значению в любой момент

Создание и использование переменных

Переменная создаётся через оператор =. Слева пишется имя, справа — значение, на которое это имя будет указывать:

Python 3.13
123456
# Создание переменных различных типов
name = "Иван"          # Строковая переменная
age = 25               # Целочисленная переменная
height = 1.85          # Переменная с плавающей точкой
is_student = True      # Логическая переменная
courses = ["Python", "SQL", "JavaScript"]  # Переменная-список

После создания имя можно подставлять везде, где нужно его значение:

Python 3.13
12
name = "Иван"
print("Привет, " + name + "!")
Привет, Иван!
345
age = 25
next_year_age = age + 1
print(f"В следующем году тебе будет {next_year_age} лет")
В следующем году тебе будет 26 лет

Множественное присваивание

Чаще всего такое присваивание применяют для распаковки: справа стоит коллекция, слева сразу несколько имён. Они получают значения по порядку:

Python 3.13
123
coordinates = (10, 20, 30)
x, y, z = coordinates
print(f"x={x}, y={y}, z={z}")
x=10, y=20, z=30

Из той же логики растёт элегантный способ обменять значения двух переменных без временной:

Python 3.13
1234
a = 5
b = 10
a, b = b, a
print(f"a = {a}, b = {b}")
a = 10, b = 5

Справа сначала собирается кортеж (10, 5), потом он распаковывается слева. Никакой третьей переменной не нужно.

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

Python 3.13
1
x = y = z = 0

В реальном коде такое встречается редко, обычно проще написать три строки. К тому же с изменяемыми объектами цепочка создаст одну и ту же ссылку: a = b = [] сделает a и b одним и тем же списком, что почти всегда не то, что хотелось.

Динамическая типизация

Python — язык с динамической типизацией. Тип переменной определяется во время выполнения и может меняться при присваивании нового значения:

Python 3.13
12
x = 10 # x имеет тип int (целое число)
print(f"x = {x}, тип: {type(x)}")
x = 10, тип: <class 'int'>
34
x = "десять" # теперь x имеет тип str (строка)
print(f"x = {x}, тип: {type(x)}")
x = десять, тип: <class 'str'>
56
x = [1, 2, 3] # теперь x имеет тип list (список)
print(f"x = {x}, тип: {type(x)}")
x = [1, 2, 3], тип: <class 'list'>

Для определения текущего типа данных переменной используется встроенная функция type():

Python 3.13
123456
name = "Иван"
age = 25
height = 1.85
is_student = True

print(f"{name}: {type(name)}")
Иван: <class 'str'>
7
print(f"{age}: {type(age)}")
25: <class 'int'>
8
print(f"{height}: {type(height)}")
1.85: <class 'float'>
9
print(f"{is_student}: {type(is_student)}")
True: <class 'bool'>

Именование переменных в Python

Хорошие имена переменных делают код понятным и удобным в поддержке.

Правила именования

Имена могут содержать буквы, цифры и символ подчёркивания (a-z, A-Z, 0-9, _).
Имя должно начинаться с буквы или символа подчёркивания.
Нельзя использовать зарезервированные слова Python (например, if, for, class).

Python 3.13
123456789
# Допустимые имена
name = "Иван"
age_in_years = 25
_private_variable = "Непубличная информация"

# Недопустимые имена
# 2name = "Нельзя начинать с цифры"
# my-name = "Нельзя использовать дефис"
# class = "Зарезервированное слово"

Лучшие практики для именования переменных

В сообществе Python есть официальное руководство по стилю, PEP 8. Это не закон, но почти весь Python-код, который вы встретите, ему следует. И читать ваш код будет проще, когда он выглядит так же.

Используйте описательные имена: пусть имя говорит о назначении

Python 3.13
12345
# Лучше так ✅
user_age = 25

# Чем так ❌
a = 25

Через месяц к коду вернётесь вы сами, и a уже ни о чём не скажет. user_age сразу подсказывает читателю, что это.

Используйте snake_case (слова в нижнем регистре через подчёркивание)

Python 3.13
12345
# Python-стиль ✅
first_name = "Иван"

# Не в стиле Python ❌
firstName = "Иван"

Технически оба варианта работают. Но весь Python-код вокруг написан в snake_case, и переключение между стилями в одном проекте утомляет глаз.

Префикс is_ или has_ для логических переменных

Python 3.13
12
is_adult = True
has_permission = False

Когда вы видите if is_adult:, сразу понятно, что справа булево значение, а не, скажем, число лет или объект пользователя. Имя adult без префикса такой подсказки не даёт.

ВЕРХНИЙ_РЕГИСТР для констант

Python 3.13
12
MAX_ATTEMPTS = 3
PI = 3.14159

В Python нет настоящих констант: MAX_ATTEMPTS можно переприсвоить, и язык не возразит. Но соглашение «всё в верхнем регистре трогать нельзя» общепринятое, и его все соблюдают.

Избегайте слишком коротких имён

Python 3.13
123456789
# Плохо ❌
n = "Иван"
flag = True
str1 = "Строка"

# Хорошо ✅
user_name = "Иван"
is_verified = True
welcome_message = "Добро пожаловать!"

Несколько лишних символов при написании экономят минуты при чтении. А читают код всегда чаще, чем пишут.

Чувствительность к регистру

Python — регистрозависимый язык, что означает различие между прописными и строчными буквами в именах переменных. Переменные name, Name и NAME интерпретируются как три разные переменные:

Python 3.13
12345
name = "Иван"
Name = "Пётр"
NAME = "Алексей"

print(name)
Иван
6
print(Name)
Пётр
7
print(NAME)
Алексей

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

Задания для самопроверки

Сразу под этой статьёй есть блок Задания для самопроверки. В нём можно сразу попробовать применить то, что прочитали.

Что уже написано в редакторе

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

Выглядит это так:

Структура задания: где вписывать значения, что не трогать, что делает кнопка «Проверить»

Левая часть — условие: что и какими значениями назвать. Плашки в условии (например, John, 25, True) означают ровно те значения, которые ждут в коде.

Справа в редакторе строки 1–3 (с = без значений) — это места, куда вписываются значения из условия. Строки 5–7 (с print(...)) трогать не надо, они нужны системе, чтобы увидеть результат и сверить с эталоном.

Кнопка «Проверить» запускает ваш код и сверяет вывод с ожидаемым. Нажимать её можно сколько угодно раз: ошибки ни на что не влияют, переменные внутри задания живут своей жизнью.

Как читать результат

Если код правильный, увидите зелёное «Решение верно» и два совпадающих блока: «Полученный результат» и «Ожидаемый результат».

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

Если что-то расходится, система покажет, в какой именно строке. У задания может быть не один тест, а несколько (Тест 1, Тест 2, и т. д.), например, чтобы проверить код на разных входных данных. Все они должны пройти, чтобы задание засчиталось.

В следующем уроке посмотрим, где живёт переменная: почему имя, объявленное внутри функции, не видно снаружи, и наоборот.

Telegram