Переменная в Python

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

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

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 нет ограничения по размеру — они могут быть настолько большими, насколько хватит памяти устройства.
• Их можно импортировать из других файлов, удалять, проверять их существование в текущей области видимости, печатать в форматированной строке.