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

Опубликовано: 06.04.2026
Категория: Python
Теги: #Python
Просмотров: 40

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


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

Простыми словами, переменная — это именованная ссылка на объект, хранящийся в памяти компьютера. Когда вы создаёте переменную, вы фактически даёте имя области памяти, в которой находятся ваши данные. Представьте переменную как бирку или ярлык, который вы прикрепляете к некоторому значению.

message = "Привет, мир!"

age = 25

Здесь message и age — это переменные, которые ссылаются на строку "Привет, мир!" и целое число 25 соответственно.


Объявление переменных и оператор присваивания

В Python не нужно специально объявлять переменную до её использования. Переменная создаётся автоматически в момент первого присваивания ей значения. Для этого используется оператор присваивания = (один знак равенства).

Важно: Не путайте оператор присваивания = с оператором сравнения ==. В Python = означает «присвоить значение», а == — «проверить на равенство».

# Создание переменной
username = "Анна"

# Переприсваивание нового значения
username = "Мария"
print(username)    # Выведет: Мария

Переменная может быть переиспользована, и ей можно присваивать значения совершенно разных типов — это одна из особенностей Python.


Имена переменных

Чтобы код был понятным и поддерживаемым, важно правильно называть переменные. В Python действуют следующие правила именования:

  1. Допустимые символы: латинские буквы (a-z, A-Z), цифры (0-9) и символ подчёркивания (_).

  2. Первый символ: имя не может начинаться с цифры.

  3. Регистр имеет значение: myvar, MyVar и MYVAR — это три разные переменные.

  4. Запрещённые имена: нельзя использовать ключевые слова языка (if, for, while, True, False, None, and, or, not, def, class, return, import и другие).

Стили именования

В сообществе Python принято использовать стиль snake_case (все слова строчными буквами, разделённые подчёркиваниями):

user_name = "Иван"    # Хороший стиль
total_price = 1500    # Хороший стиль
MAX_RETRIES = 5       # Константы обычно пишутся капсом

Рекомендации по именованию

  • Имя должно быть осмысленным и отражать суть хранимых данных. a, b, x — допустимы, но предпочтительнее count, total, user_age.

  • Для логических переменных (булевых) часто используют префиксы is_, has_, can_: is_ready = True, has_error = False.

  • Не используйте имена встроенных функций (например, print, input, len) в качестве имён переменных — это переопределит их и может привести к трудноуловимым ошибкам.


Каскадное присваивание

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

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

В этом случае все три переменные будут ссылаться на один и тот же объект в памяти (число 0). Для неизменяемых типов (числа, строки) это безопасно.


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

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

a, b = 10, 20
print(a, b)    # 10 20

# Элегантный обмен значениями
x, y = 5, 7
x, y = y, x
print(x, y)    # 7 5

Множественное присваивание работает и с другими итерируемыми объектами:

name, age, city = "Елена", 30, "Москва"
print(name, age, city)

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

Одна из ключевых особенностей Python — динамическая типизация. Это означает, что переменная не привязана к конкретному типу данных навсегда. Тип переменной определяется автоматически в момент присваивания значения и может меняться в процессе выполнения программы.

data = 42            # Сейчас это int (целое число)
print(type(data))    # <class 'int'>

data = "Пивет"       # Теперь это str (строка)
print(type(data))    # <class 'str'>

data = 3.14          # Теперь это float (дробное число)
print(type(data))    # <class 'float'>

Это очень гибко, но требует внимательности: вы можете случайно переприсвоить переменной значение неожиданного типа, что приведёт к ошибке при последующем использовании.


Изменяемые и неизменяемые типы

Все типы данных в Python делятся на изменяемые (mutable) и неизменяемые (immutable). Понимание этого различия критически важно.

Неизменяемые типы (immutable)

После создания объекта его значение нельзя изменить. Любая операция, которая кажется изменяющей объект, на самом деле создаёт новый объект. К ним относятся:

  • int (целые числа)

  • float (дробные числа)

  • complex (комплексные числа)

  • bool (логические значения)

  • str (строки)

  • tuple (кортежи)

  • frozenset (неизменяемое множество)

a = 10
b = a
a = a + 5      # Создаётся новый объект 15, переменная a теперь ссылается на него
print(a, b)    # 15 10 (b продолжает указывать на старый объект 10)

Изменяемые типы (mutable)

Объекты таких типов можно изменять на месте, без создания нового объекта. К ним относятся:

  • list (списки)

  • dict (словари)

  • set (множества)

  • пользовательские классы

list_a = [1, 2, 3]
list_b = list_a
list_a.append(4)         # Изменяем объект по месту
print(list_a, list_b)    # [1, 2, 3, 4] [1, 2, 3, 4] (обе переменные указывают на один и тот же изменённый объект)

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


Типы данных переменных

Рассмотрим основные встроенные типы данных в Python.

Логические значения (bool)

Тип bool имеет всего два возможных значения: True (истина) и False (ложь). Часто используется в условиях и циклах.

is_valid = True
is_finished = False
is_greater = 10 > 5    # Результат: True

Любое значение в Python может быть неявно преобразовано к логическому типу. False эквивалентны: None, 0, 0.0, пустые строки "", пустые коллекции [], {}, ().

Целые числа (int)

Тип int представляет целые числа. В Python нет ограничений на размер целого числа (кроме доступной памяти).

age = 30
count = -15
big_number = 12345678901234567890

# Поддержка разных систем счисления
binary = 0b1010      # 10 в двоичной
octal = 0o12         # 10 в восьмеричной
hexadecimal = 0xA    # 10 в шестнадцатеричной

Дробные числа (float)

Тип float представляет числа с плавающей точкой (приблизительно как double в других языках).

pi = 3.14159
temperature = -12.5
scientific = 1.5e-3    # 0.0015

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

print(0.1 + 0.2)  # 0.30000000000000004, а не 0.3

Для точных финансовых расчётов лучше использовать модуль decimal.

Комплексные числа (complex)

Python поддерживает комплексные числа "из коробки". Мнимая часть обозначается суффиксом j или J.

z1 = 2 + 3j
z2 = complex(1, -4)        # 1 - 4j
print(z1.real, z1.imag)    # 2.0 3.0
print(z1 + z2)             # (3-1j)

Строки (str)

Строки в Python — это неизменяемые последовательности символов в кодировке Unicode. Их можно создавать с помощью одинарных, двойных, тройных кавычек.

single_quoted = 'Привет'
double_quoted = "Мир"
multiline = """Это многострочная
строка, которая может занимать
несколько строк кода"""

# f-строки для вставки значений (Python 3.6+)

name = "Алексей"
greeting = f"Привет, {name}!"    # Привет, Алексей!


# Методы строк
text = " Python "
print(text.strip())              # "Python"
print(text.upper())              # " PYTHON "
print("hello".capitalize())      # "Hello"

Определение типа переменной: функция type()

Чтобы узнать текущий тип значения, на которое ссылается переменная, используйте встроенную функцию type():

var = 100
print(type(var))    # <class 'int'>

var = "Текст"
print(type(var))    # <class 'str'>

var = [1, 2, 3]
print(type(var))    # <class 'list'>

Функция id() и работа со ссылками

Функция id() возвращает уникальный идентификатор объекта в памяти. Это полезно для понимания того, ссылаются ли переменные на один и тот же объект.

a = [1, 2, 3]
b = a
c = [1, 2, 3]

print(id(a), id(b))      # Одинаковые идентификаторы
print(id(a) == id(b))    # True
print(id(a) == id(c))    # False (хотя содержимое одинаковое, это разные объекты)

Заключение

Мы рассмотрели все основные аспекты работы с переменными в Python:

  • Переменные — это ссылки на объекты в памяти.

  • Для создания переменной достаточно присвоить ей значение через =.

  • Имена должны быть осмысленными и следовать правилам snake_case.

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

  • Важно различать изменяемые и неизменяемые типы, особенно при присваивании.

  • Основные типы данных: bool, int, float, complex, str.

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