Код

#статьи

1 мар 2023
0

Переменные в Python: что это такое и какие они бывают

Как хранить данные в Python, чтобы обращаться к ним было легко и приятно.

Иллюстрация: Оля Ежак для Skillbox Media

Иван Стуков

Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.

Если вы откроете любую программу в Python, то, скорее всего, увидите много таких равенств:

x = 4
name = 'Виктория'
coin_flipping_result = ['орёл', 'решка', 'решка', 'орёл']

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

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

Переменная — это область памяти компьютера, у которой есть имя. Структурно она состоит из трёх частей:

Имя, или идентификатор, — это название, придуманное программистом, чтобы обращаться к переменной. В примерах выше это x, name и coin_flipping_result.
Значение — это информация, которая хранится в памяти компьютера и с которой работает программа. В примерах выше это 4, 'Виктория' и ['орёл', 'решка', 'решка', 'орёл']. Они всегда принадлежат к какому-либо типу данных.
Адрес — это номер ячейки памяти, в которой хранится значение переменной.

Приведём наглядную аналогию. Представьте большой производственный склад, заполненный стеллажами, на которых стоят коробки. Склад — это общая память компьютера. Допустим, на третьем стеллаже, на второй полке, в шестой ячейке стоит какая-нибудь коробка. Если в неё что-нибудь положить и наклеить этикетку с названием — коробка будет переменной. То, что в ней лежит, — это её значение. Третий стеллаж, вторая полка, пятая ячейка — её адрес, а этикетка — её имя.

Наглядное представление переменной в Python
Инфографика: Майя Мальгина для Skillbox Media

Как давать имена переменным

Создавая переменную на языке Python, программисты придумывают ей названия по определённым правилам именования:

первый символ должен быть заглавной или строчной латинской буквой или нижним подчёркиванием _;
остальные символы могут быть заглавными или строчными латинскими буквами, нижними подчёркиваниями и цифрами;
нельзя использовать пробелы;
имя переменной не должно совпадать ни с каким из зарезервированных в Python ключевых слов.

Приведём несколько примеров.

Какие имена можно давать переменным: x, X, xyz, _x_y_z, XYZ, xyz_123, _123, x1Y2z2.
Как нельзя называть переменные: 1, 1x, x y z, x&y.

Python чувствителен к регистру. Таким образом, name и Name будут считаться разными переменными.

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

print('Hello, world!')
>>> Hello, world!

print = 14
print('Hello, world')
>>> TypeError: 'int' object is not callable

Чуть позже мы объясним, почему так происходит.

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

Синтаксис Python позволяет использовать разные стили для именования переменных:

lowercase — все буквы строчные;
lower_case_with_underscores — все буквы строчные, между словами нижние подчёркивания;
UPPERCASE — все буквы заглавные;
UPPER_CASE_WITH_UNDERSCORES — все буквы заглавные, между словами нижние подчёркивания;
CamelCase — каждое слово начинается с заглавной буквы;
mixedCase — каждое слово, кроме первого, начинается с заглавной буквы;
Camel_Case_With_Underscores — каждое слово начинается с заглавной буквы, между словами нижние подчёркивания (это некрасиво, никогда так не делайте).

Тем не менее среди Python-разработчиков принят стандарт PEP 8 — это руководство, в котором собраны рекомендации по оформлению кода. То есть сообщество само для себя устанавливает дополнительные ограничения при именовании переменных:

использовать lowercase, при необходимости разбивая слова нижними подчёркиваниями, если это нужно для улучшения читаемости;
если в готовом проекте преобладает mixedCase, то писать стоит в этом стиле — чтобы сохранялась обратная совместимость;
не давать имена l (строчная L), O (заглавная o) и I (заглавная i) — в некоторых шрифтах они неотличимы от нуля и единицы.

Следуйте советам PEP 8, чтобы ваш код был понятным и легко поддерживаемым.

Как объявить переменную и присвоить ей значение в Python

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

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

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

x = 4
print(x)
>>> 4

x = 'слово'
print(x)
>>> слово

В языках со статической типизацией, таких как C++ и Java, подобный трюк не пройдёт: компилятор сообщит об ошибке — ведь переменная изначально хранила целое число, а не строку. А в Python это возможно, потому что переменные ссылаются не на сами данные, а на их адрес в памяти.

Как работает инициализация переменных

В Python все данные представлены в виде объектов. У каждого из них есть свой идентификатор — адрес области памяти, в которой он находится.

Этот идентификатор можно узнать с помощью функции id():

x = 4
print(id(x))
>>> 2056817043856

Когда мы инициализировали x, программа создала объект с числом 4, принадлежащий к классу (типу данных) int.

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

y = 4
print(id(y))
>>> 2056817043856

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

Объект один, адрес один, а ссылающихся на него переменных — две
Инфографика: Майя Мальгина для Skillbox Media

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

x = 1.2
y = 'строка'

Теперь x и y ссылаются на другие объекты с другими адресами. И так как больше ни одна переменная не ссылается на объект по адресу 2056817043856, то его автоматически удалит сборщик мусора.

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

Если нескольким переменным нужно присвоить одно и то же значение, это можно сделать в одну строку с помощью следующей конструкции:

x = y = z = 4

Проверим:

print(x, y, z)
>>> 4 4 4

Для присвоения разных значений тоже есть способ:

x, y, z = 1, 'игрек', ['список', 'со', 'строками']
print(x, y, z)
>>> 1 игрек ['список', 'со', 'строками']

Импорт переменных

Если переменную нужно импортировать из другого файла, то используют конструкцию from <имя файла> import <имя переменной>.

Например, у нас есть файл variables1.py:

name = 'Виктория'
age = 23
city = 'Москва'

Используем переменную name в файле variables2.py:

from variables1 import name
print(name)
>>> Виктория

При этом доступа к другим переменным из variables1.py в таком случае нет:

from variables1 import name
print(age)
>>> NameError: name 'age' is not defined

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

from variables1 import name, age
print(name, age)
>>> Виктория 23

Для импорта всех объектов после import ставят звёздочку *:

from variables1 import *
print(name, age, city)
>>> Виктория 23 Москва

Удаление переменных

Чтобы удалить переменную, используют ключевое слово del:

x = 4
del x
print(x)
>>> NameError: name 'x' is not defined

Типы переменных в Python

Все переменные существуют внутри определённой области видимости. В Python их три:

локальная — внутри одной функции;
глобальная — внутри целой программы (py-файла);
нелокальная — внутри двух смежных функций (внутренней и внешней).

Переменные, которые принадлежат к той или иной области видимости, образуют её пространство имён.

Локальные переменные

Любые переменные, которые объявлены внутри функции, остаются только в этой функции. Например:

def local_namespace():
    x = 4
    x = x ** 2
    return x

print(local_namespace())
>>> 16

Мы можем, как обычно, распоряжаться x: изменять значение, проводить операции, возвращать — но только до тех пор, пока мы делаем это внутри функции local_namespace().

Если мы решим обратиться к x где-то в другой части программы, то интерпретатор её просто не увидит:

def local_namespace():
    x = 4
    x = x ** 2
    return x

print(x)
>>> NameError: name 'x' is not defined

И наоборот: функция может распоряжаться только теми переменными, которые находятся внутри неё:

x = 4

def local_namespace():
    x = x ** 2
    return x

print(local_namespace())

>>> UnboundLocalError: local variable 'x' referenced before assignment

При этом функция может считывать переменные из глобальной области видимости — просто не имеет права изменять их.

x = 4

def local_namespace():
    y = x ** 2
    return y

print(x)
print(local_namespace())
>>> 4
>>> 16

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

x = 0

def local_namespace():
    x = 4
    x = x ** 2
    return x

print(x)
print(local_namespace())
>>> 0
>>> 16

Глобальные переменные

Любая переменная, которую объявляют вне функций, является глобальной. Она существует в пространстве имён всего py-файла.

Как мы показали выше, к ней можно обратиться внутри функции, но нельзя изменять. Чтобы исправить это, существует ключевое слово global:

x = 4

def local_namespace():
    global x
    x = x ** 2
    return x

print(local_namespace())
>>> 16

Если мы создаём новую переменную внутри функции, то тем же ключевым словом global можем сделать её глобальной:

def local_namespace():
    global x
    x = 4
    return x

print(local_namespace())
print(x)
>>> 4
>>> 4

Нелокальные переменные

Нелокальные переменные используются, когда одна функция вложена в другую, и охватывают пространство имён только этих двух функций.

Их создают с помощью ключевого слова nonlocal.

def nonlocal_namespace():
    x = 4
    def local_namespace():
        nonlocal x
        x = x ** 2
        return x
    return local_namespace()

print(nonlocal_namespace())
>>> 16

При этом в глобальной области видимости к нелокальной переменной мы обратиться не можем:

def nonlocal_namespace():
    x = 4
    def local_namespace():
        nonlocal x
        x = x ** 2
        return x
    return local_namespace()

print(x)
>>> NameError: name 'x' is not defined

Проверка существования переменной

В Python есть функции globals() и locals(). Они возвращают словарь с таблицей глобальных и локальных символов соответственно. В них, помимо прочего, хранятся данные о переменных.

Ключом в этих словарях является строка с именем переменной — так можно проверить её существование:

name = 'Виктория'
if 'name' in globals():
    print(True)
>>> True

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

name = 'Виктория'
if 'name' in globals():
    print(globals().get('name'))
>>> Виктория

Точно так же можно делать и в локальной области видимости:

def local_namespace():
    name = 'Виктория'
    if 'name' in locals():
        print(locals().get('name'))

local_namespace()
>>> Виктория

Максимально возможное значение переменной

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

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

Печать одиноких и множественных переменных

Для печати в Python используется функция print(). С её помощью можно вывести как одиночную переменную, так и несколько, перечислив их через запятую:

name, age, city = 'Виктория', 23, 'Москва'
print(name)
print(name, age, city)
>>> Виктория
>>> Виктория 23 Москва

Также в Python можно форматировать печать переменных. Для этого предусмотрено несколько способов, но самый удобный из них — f-строки. Нужно передать функции print() строку c буквой f перед ней. Сами переменные указываются в фигурных скобках: {имя переменной}.

name, age, city = 'Виктория', 23, 'Москва'
print(f'Имя: {name}. Возраст: {age}. Город: {city}.')
>>> Имя: Виктория. Возраст: 23. Город: Москва.

Итоги

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