Переменные и типы данных в Python

Переменная в Python — это имя, которое ссылается на объект в памяти. Тип данных хранится в самом объекте, к имени он не привязан. Короткий ответ: переменная создаётся присваиванием age = 30, объявлять тип заранее не нужно, а узнать тип значения можно функцией type(age), которая вернёт <class 'int'>.

Ниже — как создавать переменные и называть их, какие встроенные типы данных есть в Python, чем изменяемые типы отличаются от неизменяемых и как преобразовывать значения из одного типа в другой. Примеры проверены на Python 3.12, вывод показан комментарием # →.

Как создать переменную

В Python нет отдельного объявления переменной: она появляется в момент первого присваивания.

age = 30
name = "Анна"
price = 199.9
is_admin = False

print(type(age), type(name), type(price), type(is_admin))
# → <class 'int'> <class 'str'> <class 'float'> <class 'bool'>

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

x, y, z = 1, 2, 3        # множественное присваивание
a = b = 0                # одно значение двум именам
x, y = y, x              # обмен значениями
print(x, y, a, b)        # → 2 1 0 0

first, *rest = [10, 20, 30, 40]   # распаковка с «хвостом»
print(first, rest)       # → 10 [20, 30, 40]

counter = 10
counter += 1             # то же, что counter = counter + 1
print(counter)           # → 11

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

• Имя состоит из букв, цифр и подчёркивания и не может начинаться с цифры: user_1 — можно, 1user — нельзя.
• Регистр важен: name и Name — две разные переменные.
• Нельзя использовать ключевые слова языка: class, for, if, None, True, lambda и другие. Полный список (35 слов в Python 3.12–3.15) выводит import keyword; print(keyword.kwlist). Мягкие ключевые слова (match, case, type, _, а с Python 3.15 ещё lazy) использовать как имена можно.
• По соглашению PEP 8 переменные пишут в snake_case: user_name, total_price. Константы — заглавными: MAX_SIZE = 100.
• Кириллица в именах технически разрешена, но в реальных проектах принято писать имена латиницей.

Не называйте переменные именами встроенных функций — list, dict, str, sum, id. Код запустится, но встроенная функция станет недоступна (см. «Частые ошибки»).

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

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

value = 42
print(type(value))  # → <class 'int'>
value = "сорок два"
print(type(value))  # → <class 'str'>

При этом типизация строгая: Python не смешивает типы молча. Сложить строку с числом нельзя — нужно явное преобразование (об этом ниже).

Для проверки типа в условиях используйте isinstance() — он учитывает наследование и принимает кортеж типов:

print(isinstance(3.14, float))       # → True
print(isinstance(True, int))         # → True (bool — подкласс int)
print(isinstance(5, (int, float)))   # → True

Встроенные типы данных в Python

Встроенные типы данных Python делятся на числа, строки, логический тип, «пустое значение» и коллекции:

Тип	Пример значения	Что хранит	Изменяемый
int	10, -3, 2**100	целые числа произвольной длины	нет
float	2.5, 1e-3	числа с плавающей точкой	нет
complex	3+4j	комплексные числа	нет
bool	True, False	логические значения	нет
str	"текст"	строки Unicode	нет
NoneType	None	«нет значения»	нет
list	[1, 2]	упорядоченная коллекция	да
tuple	(1, 2)	неизменяемая упорядоченная коллекция	нет
dict	{"a": 1}	пары «ключ — значение»	да
set	{1, 2}	множество уникальных элементов	да
frozenset	frozenset({1, 2})	неизменяемое множество	нет
bytes	b"abc"	последовательность байтов	нет
range	range(3)	диапазон целых чисел	нет

Основным типам на сайте посвящены отдельные статьи: числа int и float, строки, списки, кортежи, словари и множества. Здесь разберём то, что объединяет их все.

None — отсутствие значения

None — единственный объект типа NoneType. Его возвращают функции без return, им обозначают «значение ещё не задано». Проверять None принято через is:

result = None
print(result is None)  # → True

Изменяемые и неизменяемые типы данных

Это главное свойство типа, которое влияет на поведение программы. Неизменяемый (immutable) объект нельзя поменять после создания: любая «модификация» создаёт новый объект. Изменяемый (mutable) объект меняется на месте, и это видно через все переменные, которые на него ссылаются.

Изменяемые типы данных в Python: list, dict, set, bytearray, а также объекты большинства пользовательских классов. Неизменяемые: int, float, complex, bool, str, tuple, frozenset, bytes, None.

Присваивание b = a не копирует объект — оно даёт ему второе имя:

a = [1, 2, 3]
b = a            # b и a — один и тот же список
b.append(4)
print(a)         # → [1, 2, 3, 4]
print(a is b)    # → True

c = a.copy()     # новый список
c.append(5)
print(a, c)      # → [1, 2, 3, 4] [1, 2, 3, 4, 5]

Со строкой то же действие ведёт себя иначе, потому что строка неизменяема:

s = "кот"
t = s
t += "ы"         # создаётся новая строка, s не меняется
print(s, t)      # → кот коты

s[0] = "К"       # → TypeError: 'str' object does not support item assignment

Неизменяемость нужна, чтобы объект можно было использовать как ключ словаря или элемент множества: ключ обязан быть хешируемым. Кортеж хешируем, только если хешируемы все его элементы:

pair = (1, [2, 3])
pair[1].append(4)    # сам кортеж не изменился, изменился список внутри
print(pair)          # → (1, [2, 3, 4])
{pair: 1}            # → TypeError: unhashable type: 'list'

Преобразование типов

Для явного преобразования вызывают тип как функцию: int(), float(), str(), bool(), list() и т. д.

print(int("42") + 1)        # → 43
print(float("3.14"))        # → 3.14
print(str(100) + " руб.")   # → 100 руб.
print(int(7.9))             # → 7 (дробная часть отбрасывается)
print(list("abc"), tuple([1, 2]), set([1, 1, 2]))
# → ['a', 'b', 'c'] (1, 2) {1, 2}

Правило для bool(): ложны 0, 0.0, пустая строка, пустые коллекции и None. Всё остальное истинно, включая строку "0":

print(bool(0), bool(""), bool([]), bool(None), bool("0"), bool(-1))
# → False False False False True True

int() не принимает строку с дробной частью: int("3.14") выбросит ValueError: invalid literal for int() with base 10: '3.14'. Сначала преобразуйте в float. Подробнее о переводе чисел в текст и форматировании — в статье как преобразовать число в строку, а о выводе значений внутри строк — в статье про f-строки.

Аннотации типов

С Python 3.6 тип переменной можно подсказать аннотацией. Это подсказка для читателя, IDE и анализаторов вроде mypy; при выполнении Python аннотации не проверяет:

title: str = "Python"
count: int = "не число"   # Python не возразит
print(count)              # → не число

Аннотации активно используют FastAPI и Pydantic — там они превращаются в настоящую валидацию данных. Подробнее — в статье о Pydantic.

Частые ошибки

NameError: name is not defined

Переменную прочитали до присваивания или опечатались в имени. С Python 3.10 интерпретатор подсказывает похожее имя:

username = "anna"
print(usernmae)
# → NameError: name 'usernmae' is not defined. Did you mean: 'username'?

Помните про регистр: Name и name — разные переменные.

TypeError при сложении строки и числа

print("Возраст: " + 30)
# → TypeError: can only concatenate str (not "int") to str

Преобразуйте число явно — "Возраст: " + str(30) — или используйте f-строку: f"Возраст: {age}".

Затёрли встроенную функцию

list = [1, 2]
list("abc")  # → TypeError: 'list' object is not callable

Переименуйте переменную (items, numbers), а в интерактивной сессии верните встроенное имя командой del list.

Неожиданное изменение «копии»

Если после b = a изменение b портит a, значит, обе переменные ссылаются на один изменяемый объект. Создайте копию: a.copy(), list(a) или copy.deepcopy(a) для вложенных структур.

Сравнение через is вместо ==

is проверяет, что это один и тот же объект, а == — что значения равны. Для чисел и строк используйте ==, а is оставьте для проверки на None: if value is None. Логические значения PEP 8 советует проверять просто if flag:, без сравнения с True.

Частые вопросы

Как изменить глобальную переменную внутри функции?

Прочитать глобальную переменную функция может и так, а для присваивания нужно объявить её через global. Без объявления counter += 1 внутри функции вызовет UnboundLocalError:

counter = 0


def increment():
    global counter
    counter += 1


increment()
print(counter)  # → 1

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

Есть ли в Python константы?

Отдельного синтаксиса для констант нет. Имя заглавными буквами (MAX_SIZE = 100) — соглашение PEP 8, и переприсвоить такую переменную можно. Аннотация typing.Final запрещает это только для анализаторов вроде mypy:

from typing import Final

MAX_SIZE: Final = 100
MAX_SIZE = 200   # mypy сообщит об ошибке, Python — нет
print(MAX_SIZE)  # → 200

Как удалить переменную?

Инструкция del x удаляет имя. После этого обращение к x вызовет NameError: name 'x' is not defined. Сам объект Python освободит, когда на него не останется ни одной ссылки.

Как создать переменные с именами item_1, item_2 в цикле?

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

values = {}
for i in range(3):
    values[f"item_{i}"] = i * 10
print(values)            # → {'item_0': 0, 'item_1': 10, 'item_2': 20}
print(values["item_2"])  # → 20

Сколько памяти занимает переменная?

Сама переменная — только ссылка, память занимает объект. Его размер в байтах показывает sys.getsizeof(). Для коллекций учитывается только сам контейнер без элементов. Вывод ниже получен на 64-битном CPython 3.12:

import sys

print(sys.getsizeof(1), sys.getsizeof(2**100), sys.getsizeof([1, 2, 3]))  # → 28 40 88

Итог

Переменная в Python — имя для объекта, тип хранится в самом объекте и проверяется функциями type() и isinstance(). Главное различие между типами данных — изменяемость: list, dict и set меняются на месте, а числа, строки и кортежи — нет. Дальше изучите конкретные типы: числа, строки и словари, а краткий справочник по всему языку собран в шпаргалке по синтаксису Python.