4. Модель выполнения¶Execution model

4.2.1. Связывание имён¶Binding of names

Имена ссылаются на объекты. Имена вводятся операциями связывания имён.

Следующие конструкции связывают имена:

• формальные параметры функций,

• определения классов,

• определения функций,

• выражения присваивания,

• targets that are identifiers if occurring in an assignment:

  • заголовок цикла for,

  • после as в операторе with, в предложении except, предложении except* или в as-шаблоне структурного сопоставления с образцом,

  • в шаблоне захвата структурного сопоставления с образцом,

• операторы import.

• операторы type.

• type parameter lists.

Оператор import вида from ... import * связывает все имена, определённые в импортированном модуле, кроме тех, что начинаются с подчёркивания. Эта форма может использоваться только на уровне модуля.

Цель, встречающаяся в операторе del, также считается связанной для данной цели (хотя фактическая семантика заключается в отмене связывания имени).

Каждый оператор присваивания или импорта находится внутри блока, определённого классом или определением функции, либо на уровне модуля (блок кода верхнего уровня).

Если имя связано в блоке, оно является локальной переменной этого блока, если только не объявлено как nonlocal или global. Если имя связано на уровне модуля, оно является глобальной переменной. (Переменные блока кода модуля являются локальными и глобальными.) Если переменная используется в блоке кода, но не определена в нём, она является свободной переменной.

Каждое вхождение имени в тексте программы ссылается на связывание этого имени, установленное следующими правилами разрешения имён.

4.2.2. Разрешение имён¶Resolution of names

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

Когда имя используется в блоке кода, оно разрешается с помощью ближайшей объемлющей области видимости. Множество всех таких областей, видимых блоку кода, называется его окружением.

Когда имя не найдено вовсе, возбуждается исключение NameError. Если текущая область видимости – функция, и имя ссылается на локальную переменную, которая ещё не привязана к значению в точке использования, возбуждается исключение UnboundLocalError. UnboundLocalError является подклассом NameError.

Если операция связывания имени встречается в любом месте блока кода, все использования этого имени в блоке считаются ссылками на текущий блок. Это может приводить к ошибкам, когда имя используется в блоке до его связывания. Правило это тонкое. В Python нет объявлений, и операции связывания имени могут встречаться в любом месте блока кода. Локальные переменные блока кода можно определить, просмотрев весь текст блока на предмет операций связывания имён. Примеры см. в FAQ про UnboundLocalError.

Если оператор global встречается в блоке, все использования имён, указанных в операторе, ссылаются на привязки этих имён в пространстве имён верхнего уровня. Разрешение имён в пространстве имён верхнего уровня выполняется поиском в глобальном пространстве имён (т.е. пространстве имён модуля, содержащего блок кода) и в пространстве имён встроенных объектов (пространстве имён модуля builtins). Сначала ищется глобальное пространство имён. Если имена не найдены там, затем ищется пространство имён встроенных объектов. Если имена не найдены и там, в глобальном пространстве имён создаются новые переменные. Оператор global должен предшествовать всем использованиям перечисленных имён.

Оператор global имеет ту же область видимости, что и операция связывания имени в том же блоке. Если ближайшая охватывающая область видимости для свободной переменной содержит оператор global, свободная переменная считается глобальной.

Оператор nonlocal заставляет соответствующие имена ссылаться на ранее связанные переменные в ближайшей охватывающей области видимости функции. SyntaxError возбуждается на этапе компиляции, если указанное имя не существует ни в одной охватывающей функции. Параметры типа нельзя перепривязать с помощью оператора nonlocal.

Пространство имён модуля автоматически создаётся при первом импорте модуля. Главный модуль скрипта всегда называется __main__.

Блоки определения класса и аргументы exec() и eval() являются особыми в контексте разрешения имён. Определение класса – это исполняемый оператор, который может использовать и определять имена. Эти ссылки следуют обычным правилам разрешения имён, за исключением того, что несвязанные локальные переменные ищутся в глобальном пространстве имён. Пространство имён определения класса становится словарём атрибутов класса. Область видимости имён, определённых в блоке класса, ограничена блоком класса; она не распространяется на блоки кода методов. Это включает генераторы списков и выражения генераторов, но не включает области видимости аннотаций, которые имеют доступ к охватывающим областям видимости классов. Это означает, что следующий код не сработает:

class A:
    a = 42
    b = list(a + i for i in range(10))

Однако следующий код сработает:

class A:
    type Alias = Nested
    class Nested: pass

print(A.Alias.__value__)  # <type 'A.Nested'>

4.2.3. Области видимости аннотаций¶Annotation scopes

Списки параметров типа и type инструкции вводят области видимости аннотаций, которые в основном ведут себя как области видимости функций, но с некоторыми исключениями, обсуждаемыми ниже. Аннотации в настоящее время не используют области видимости аннотаций, но ожидается, что они будут использовать области видимости аннотаций в Python 3.13, когда будет реализован PEP 649.

Области видимости аннотаций используются в следующих контекстах:

• Списки параметров типа для обобщённых псевдонимов типов.

• Списки параметров типа для обобщённых функций. Аннотации обобщённой функции выполняются в области видимости аннотаций, но её значения по умолчанию и декораторы – нет.

• Списки параметров типа для обобщённых классов. Базовые классы и именованные аргументы обобщённого класса выполняются в области видимости аннотаций, но его декораторы – нет.

• Границы и ограничения для переменных типов (вычисляются лениво).

• Значение псевдонимов типов (лениво вычисляемое).

Области видимости аннотаций отличаются от областей видимости функций следующим образом:

• Области видимости аннотаций имеют доступ к пространству имён охватывающего класса. Если область видимости аннотаций находится непосредственно внутри области видимости класса или внутри другой области видимости аннотаций, которая находится непосредственно внутри области видимости класса, код в области видимости аннотаций может использовать имена, определённые в области видимости класса, как если бы он выполнялся непосредственно в теле класса. Это отличается от обычных функций, определённых внутри классов, которые не могут обращаться к именам, определённым в области видимости класса.

• Выражения в областях видимости аннотаций не могут содержать выражения yield, yield from, await или :=. (Эти выражения разрешены в других областях видимости, вложенных в область видимости аннотаций.)

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

• Хотя области видимости аннотаций имеют внутреннее имя, это имя не отражается в квалифицированном имени объектов, определённых внутри области. Вместо этого __qualname__ таких объектов выглядит так, как если бы объект был определён в охватывающей области.

4.2.4. Ленивое вычисление¶Lazy evaluation

Значения псевдонимов типов, созданных с помощью оператора type, вычисляются лениво. То же самое относится к границам и ограничениям переменных типов, созданных через синтаксис параметров типа. Это означает, что они не вычисляются при создании псевдонима типа или переменной типа. Вместо этого они вычисляются только тогда, когда это необходимо для разрешения доступа к атрибуту.

Пример:

>>> type Alias = 1/0
>>> Alias.__value__
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> def func[T: 1/0](): pass
>>> T = func.__type_params__[0]
>>> T.__bound__
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero

Здесь исключение возбуждается только при обращении к атрибуту __value__ псевдонима типа или атрибуту __bound__ переменной типа.

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

from typing import Literal

type SimpleExpr = int | Parenthesized
type Parenthesized = tuple[Literal["("], Expr, Literal[")"]]
type Expr = SimpleExpr | tuple[SimpleExpr, Literal["+", "-"], Expr]

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

4.2.5. Встроенные объекты и ограниченное выполнение¶Builtins and restricted execution

Пространство имён builtins, связанное с выполнением блока кода, на самом деле находится путём поиска имени __builtins__ в его глобальном пространстве имён; это должен быть словарь или модуль (в последнем случае используется словарь модуля). По умолчанию, в модуле __main__ __builtins__ является встроенным модулем builtins; во всех остальных модулях __builtins__ является псевдонимом для словаря самого модуля builtins.

4.2.6. Взаимодействие с динамическими возможностями¶Interaction with dynamic features

Разрешение имён свободных переменных происходит во время выполнения, а не во время компиляции. Это означает, что следующий код выведет 42:

i = 10
def f():
    print(i)
i = 42
f()

Функции eval() и exec() не имеют доступа к полному окружению для разрешения имён. Имена могут разрешаться в локальном и глобальном пространствах имён вызывающего кода. Свободные переменные разрешаются не в ближайшем охватывающем пространстве имён, а в глобальном. [1] Функции exec() и eval() имеют необязательные аргументы для переопределения глобального и локального пространства имён. Если указано только одно пространство имён, оно используется для обоих.