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

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

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

В этом коде name — это ярлык, который Python повесил на строку "Иван" в памяти. Когда дальше встречается name, 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 лет

Во втором примере перед кавычками стоит буква f. Она означает: внутри строки можно писать имена переменных в фигурных скобках, и Python подставит туда их значения. Такие строки называют f-строками, и дальше в курсе они встретятся часто — подробно разберём их в главе про строки.

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

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

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 — язык с динамической типизацией. Тип переменной определяется во время выполнения и может меняться при присваивании нового значения. Посмотреть текущий тип можно функцией type() — она показывает, какого типа значение:

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'>

Сами типы — что такое str, int, float и bool и чем они отличаются друг от друга — разберём позже, в уроке про базовые типы данных. Пока достаточно того, что тип у значения есть и он может меняться.

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

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

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

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

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

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

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

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

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

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

# Чем так ❌
a = 25

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

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

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

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

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

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

Python 3.13
12
is_adult = True
has_permission = False

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

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

Python 3.13
12
MAX_ATTEMPTS = 3
PI = 3.14159

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

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

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», «Тест #2» и так далее. Задание засчитывается, только когда проходят все тесты.

Каждая вкладка с тестом показывает, что именно будет проверено: строку кода и значение, которое должно получиться. Например, «Тест #2» читает user_age и ждёт, что там окажется 25. Открыть тесты можно в любой момент, в том числе до первой проверки.

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

На вкладке «Результат» лежит общий итог (сколько тестов прошло) и всё, что вы напечатали через print(). Это удобно, когда хочется посмотреть промежуточные значения по ходу решения.

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