Переменные в Python: подробное руководство

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

На этой странице рассматривается:

• Как создавать переменные и присваивать им значения
• Динамическая типизация — что это значит на практике
• Множественное присваивание и распаковка кортежей
• Составные операторы присваивания
• Проверка типа переменной с помощью type()
• Специальное значение None
• Удаление переменных с помощью del
• Основы области видимости переменных

Связанные главы: Имена переменных · Вывод переменных · Присвоение нескольких значений · Типы данных Python · Глобальные переменные · Область видимости Python

Создание переменной

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

Присвоить строку и вывести её

John Doe

Здесь name — имя переменной, а "John Doe" — значение. Знак = является оператором присваивания — это не проверка на равенство (для этого используется ==).

Имена переменных подчиняются нескольким правилам:

• Должны начинаться с буквы или символа подчёркивания (_), но не с цифры.
• Могут содержать буквы, цифры и символы подчёркивания.
• Чувствительны к регистру — score, Score и SCORE — это три разные переменные.
• Не могут совпадать с ключевыми словами Python, такими как if, for, while или class.

Стиль Python (PEP 8) рекомендует использовать snake_case для имён переменных: слова в нижнем регистре, разделённые символами подчёркивания, например first_name или total_price. Лучшие практики именования описаны в разделе Имена переменных.

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

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

x = 10
print(type(x))   # <class 'int'>

x = "hello"
print(type(x))   # <class 'str'>

x = 3.14
print(type(x))   # <class 'float'>

<class 'int'>
<class 'str'>
<class 'float'>

Такая гибкость удобна, но является распространённым источником ошибок: если случайно перезаписать переменную значением неправильного типа, Python не предупредит вас — только TypeError (или неверный результат) во время выполнения. Аннотации типов (например, x: int = 10) позволяют документировать намерения и выявлять такие ошибки заранее с помощью средства проверки типов. Подробности см. в разделе Python Type Hints.

Проверка типа переменной

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

name = "Alice"
age = 30
price = 9.99
active = True

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

<class 'str'>
<class 'int'>
<class 'float'>
<class 'bool'>

type() особенно полезна при отладке — когда переменная содержит неожиданный тип, print(type(x)) — самый быстрый способ проверить, что в ней на самом деле.

Переменные для каждого типа данных

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

Присвоить переменные разных типов

integer_val  = 10                          # int
float_val    = 10.5                        # float
complex_val  = 10 + 5j                     # complex
string_val   = "Hello, World!"             # str
bool_val     = True                        # bool
list_val     = [1, 2, 3, 4, 5]            # list  (mutable, ordered)
tuple_val    = (1, 2, 3, 4, 5)            # tuple (immutable, ordered)
dict_val     = {"key1": "value1"}          # dict  (key-value pairs)
set_val      = {1, 2, 3, 4, 5}            # set   (unique, unordered)
none_val     = None                        # NoneType

Подробное руководство о том, когда выбирать тот или иной тип, см. в разделе Типы данных Python.

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

Присвоение одного значения нескольким переменным

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

a = b = c = 0
print(a, b, c)

0 0 0

Это удобно для инициализации счётчиков или флагов, но будьте осторожны с изменяемыми объектами — a = b = c = [] заставляет все три имени указывать на один и тот же список, поэтому изменение одного затронет все три.

Распаковка кортежа

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

x, y, z = 1, 2, 3
print(x, y, z)

1 2 3

Python сопоставляет значения с правой стороны именам с левой стороны по порядку. Количество имён должно совпадать с количеством значений, иначе возникнет ValueError. Для распаковки со звёздочкой (*) и вложенной распаковки см. раздел Присвоение нескольких значений.

Составные операторы присваивания

Составное присваивание объединяет операцию и присваивание в один шаг. Вместо того чтобы писать count = count + 1, пишите count += 1:

count = 0
count += 1    # same as count = count + 1
print(count)  # 1

total = 100
total -= 25   # same as total = total - 25
print(total)  # 75

price = 10.0
price *= 1.2  # same as price = price * 1.2
print(price)  # 12.0

1
75
12.0

Полный набор составных операторов присваивания: +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, >>= и <<=. Они работают с любым типом, поддерживающим соответствующий оператор — например, += для строки выполняет конкатенацию:

message = "Hello"
message += ", World!"
print(message)

Hello, World!

Арифметика с переменными

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

Математические операции с переменными

a = 10
b = 20

print(a + b)   # addition       → 30
print(b - a)   # subtraction    → 10
print(a * b)   # multiplication → 200
print(b / a)   # division       → 2.0  (always float in Python 3)
print(b // a)  # floor division → 2
print(b % a)   # modulo         → 0

30
10
200
2.0
2
0

Обратите внимание, что / всегда возвращает float в Python 3, даже если результат является целым числом. Используйте //, когда нужно целочисленное частное.

Полный список операторов (побитовые, сравнения, логические, принадлежности, идентичности) см. в разделе Операторы Python.

Специальное значение None

None — это способ Python выразить «нет значения» или «ничего». Это единственное значение типа NoneType:

result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>
print(result is None) # True

None
<class 'NoneType'>
True

Всегда проверяйте наличие None с помощью is None (проверка идентичности), а не == None (проверка равенства). Функции, которые явно не возвращают значение через return, по умолчанию возвращают None.

Удаление переменной

Используйте оператор del, чтобы удалить имя переменной из текущей области видимости. После удаления обращение к этому имени вызовет NameError:

temp = "temporary value"
print(temp)  # temporary value

del temp
# print(temp)  # NameError: name 'temp' is not defined

del чаще всего используется для явного освобождения памяти (например, после обработки большого набора данных) или очистки локального состояния. Он удаляет привязку имени, но не обязательно сам объект — сборщик мусора Python освобождает память объекта, когда на него не указывает ни одно имя.

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

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

• Локальная область — переменная, созданная внутри функции, существует только на время выполнения этого вызова функции.
• Глобальная область — переменная, созданная на верхнем уровне модуля, доступна из любого места этого модуля.

message = "I am global"   # global variable

def greet():
    greeting = "Hello"    # local variable — not accessible outside
    print(greeting)
    print(message)        # can read global variable

greet()
# print(greeting)  # NameError — greeting does not exist here

Hello
I am global

Для изменения глобальной переменной внутри функции требуется ключевое слово global. Полное описание правила LEGB см. в разделах Глобальные переменные и Область видимости Python.

Практика