# Глоссарий

`>>>`

  Стандартное приглашение Python в интерактивной оболочке. Часто встречается в примерах кода, которые можно выполнить интерактивно в интерпретаторе.

`...`

  Может обозначать:

  - Стандартное приглашение Python в интерактивной оболочке при вводе блока кода с отступом, внутри пары соответствующих друг другу разделителей (круглых, квадратных или фигурных скобок, а также тройных кавычек) или после указания декоратора.

  - Форму записи объекта Ellipsis в виде многоточия.

абстрактный базовый класс

  Абстрактные базовые классы дополняют утиную типизацию, предоставляя способ определения интерфейсов в случаях, когда другие методы, вроде функции `hasattr()`, были бы громоздкими или могли бы привести к трудноуловимым ошибкам (например, при работе с магическими методами). Абстрактные базовые классы вводят виртуальные подклассы — классы, которые не наследуются от другого класса, но тем не менее распознаются функциями `isinstance()` и `issubclass()`; см. документацию модуля `abc`. Python предоставляет множество встроенных абстрактных базовых классов для структур данных (в модуле `collections.abc`), чисел (в модуле `numbers`), потоков (в модуле `io`), а также для механизма поиска и загрузки при импорте (в модуле `importlib.abc`). Создавать собственные абстрактные базовые классы можно с помощью модуля `abc`.

функция аннотации

  Вызываемый объект, который можно вызвать для получения аннотации объекта. Функции аннотации обычно являются функциями, автоматически создаваемыми в качестве атрибута `__annotate__` функций, классов и модулей. Функции аннотации являются подмножеством вычисляющих функций.

аннотация

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

  Аннотации локальных переменных недоступны во время выполнения, но аннотации глобальных переменных, атрибутов классов и функций можно получить, вызвав `annotationlib.get_annotations()` для модулей, классов и функций соответственно.

  См. аннотацию переменных, аннотацию функций, PEP 484, PEP 526 и PEP 649, в которых описывается эта функциональность. См. также раздел Annotations Best Practices с рекомендациями по работе с аннотациями.

аргумент

  Значение, передаваемое в функцию (или метод) при вызове функции. Есть два вида аргументов:

  - именованный аргумент: аргумент, которому в вызове функции предшествует идентификатор (например, `name=`), или значение, передаваемое в словаре с предшествующим ему `**`. Например, `3` и `5` являются именованными аргументами в следующих вызовах `complex()`:

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

  - позиционный аргумент: аргумент, который не является именованным. Позиционные аргументы могут находиться в начале списка аргументов и/или передаваться как элементы итерируемого объекта, перед которым стоит `*`. Например, `3` и `5` являются позиционными аргументами в следующих вызовах:

        complex(3, 5)
        complex(*(3, 5))

  Аргументы присваиваются именованным локальным переменным в теле функции. Правила такого присваивания см. в разделе Calls. Синтаксически для представления аргумента можно использовать любое выражение. Его значение вычисляется и присваивается локальной переменной.

  См. также статью глоссария параметр, раздел о различии между аргументами и параметрами в часто задаваемых вопросах и PEP 362.

асинхронный менеджер контекста

  Объект, управляющий окружением, доступным в инструкции `async with`, посредством определения методов `__aenter__()` и `__aexit__()`. Представлен в PEP 492.

асинхронный генератор

  Неформально используется для обозначения либо асинхронной генераторной функции, либо асинхронного генераторного итератора — в зависимости от контекста. Формальные термины асинхронная генераторная функция и асинхронный генераторный итератор редко используются на практике; почти всегда достаточно термина «асинхронный генератор».

асинхронная генераторная функция

  Функция, возвращающая асинхронный генераторный итератор. Она похожа на функцию сопрограммы, определённую с помощью `async def`, но содержит выражения `yield`, генерирующие последовательность значений, которые можно использовать в цикле `async for`. См. PEP 525.

  Асинхронная генераторная функция может содержать выражения `await`, а также инструкции `async for` и `async with`.

асинхронный генераторный итератор

  Объект, созданный асинхронной генераторной функцией.

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

  Каждое выражение `yield` временно приостанавливает выполнение, сохраняя состояние выполнения (включая локальные переменные и ожидающие выполнения инструкции try). Когда асинхронный генераторный итератор фактически возобновляется при ожидании очередного объекта после вызова `__anext__()`, он продолжает выполнение с того места, на котором остановился. См. PEP 492 и PEP 525.

асинхронный итерируемый объект

  Объект, который можно использовать в инструкции `async for`. Должен возвращать асинхронный итератор из своего метода `__aiter__()`. Представлен в PEP 492.

асинхронный итератор

  Объект, реализующий методы `__aiter__()` и `__anext__()`. Метод `__anext__()` должен возвращать объект, допускающий ожидание. Инструкция `async for` ожидает объекты, возвращаемые методом асинхронного итератора `__anext__()`, до тех пор, пока тот не вызовет исключение `StopAsyncIteration`. Представлен в PEP 492.

атомарная операция

  Операция, которая выполняется как единый неделимый шаг: ни один другой поток не может увидеть её в промежуточном состоянии, а все её эффекты становятся видимыми одновременно. Python не гарантирует атомарность инструкций высокого уровня (например, `x += 1` выполняет несколько операций в байт-коде и не является атомарной). Атомарность гарантируется только там, где это явно указано в документации. См. также состояние гонки и гонка данных.

присоединённое состояние потока

  Состояние потока, активное для текущего потока ОС.

  Когда состояние потока присоединено к потоку ОС, послений получает доступ ко всему C API Python и может безопасно вызывать интерпретатор байт-кода.

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

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

атрибут

  Значение, связанное с объектом, на который обычно ссылаются по имени, с помощью выражения с точками. Например, если объект o имеет атрибут a, на него ссылаются как o.a.

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

ожидаемый объект

  Объект, который можно использовать в выражении `await`. Это может быть сопрограмма или объект с методом `__await__()`. См. также PEP 492.

BDFL

  «Великодушный пожизненный диктатор» («Benevolent Dictator For Life»), он же Гвидо ван Россум, создатель Python.

двоичный файл

  Файловый объект, способный читать и записывать объекты, подобные байтам. Примеры двоичных файлов: файлы, открытые в двоичном режиме (`'rb'`, `'wb'` или `'rb+'`), `sys.stdin.buffer`, `sys.stdout.buffer`, а также экземпляры `io.BytesIO` и `gzip.GzipFile`.

  См. также текстовый файл для файлового объекта, способного читать и записывать объекты `str`.

заимствованная ссылка

  В C API Python заимствованная ссылка — это ссылка на объект, владение которым не передаётся коду, использующему эту ссылку. Если объект уничтожается, такая ссылка становится висящим указателем. Например, сборщик мусора может удалить последнюю сильную ссылку на объект и тем самым уничтожить его.

  За исключением случаев, когда объект не может быть уничтожен до последнего использования заимствованной ссылки, её рекомендуется преобразовать на месте в сильную ссылку, вызвав функцию `Py_INCREF()`. А для создания новой сильной ссылки можно использовать функцию `Py_NewRef()`.

объект, подобный bytes

  Объект, поддерживающий Buffer Protocol и способный экспортировать непрерывный C-буфер. Сюда входят все объекты `bytes`, `bytearray` и `array.array`, а также многие распространённые объекты `memoryview`. Объекты, подобные bytes, можно использовать для различных операций с двоичными данными, включая сжатие, сохранение в двоичный файл и отправку через сокет.

  Некоторым операциям требуется, чтобы двоичные данные были изменяемыми. В документации такие объекты часто называются «объектами, подобными bytes, доступными для чтения и записи». Примерами изменяемых объектов буфера являются `bytearray`и :class:`memoryview` типа `bytearray`. Другим операциям требуется, чтобы двоичные данные хранились в неизменяемых объектах («объектах, подобных bytes, доступных только для чтения»); к таким объектам относятся, например, `bytes` и `memoryview` типа `bytes`.

байт-код

  Исходный код Python компилируется в байт-код — внутреннее представление программы Python в интерпретаторе CPython. Байт-код также кэшируется в файлах `.pyc` благодаря повторное выполнение того же файла происходит быстрее (повторной компиляции исходного кода в байт-код можно избежать). Этот «промежуточный язык» выполняется на виртуальной машине, которая исполняет машинный код, соответствующий каждой инструкции байт-кода. Следует учитывать, что байт-код не предназначен для работы на разных виртуальных машинах Python и не гарантирует стабильность между разными версиями Python.

  Список инструкций байт-кода можно найти в документации к модулю dis.

вызываемый объект

  Вызываемый объект — это объект, который можно вызвать, возможно, с набором аргументов (см. аргумент), используя следующий синтаксис:

      callable(argument1, argument2, argumentN)

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

функция обратного вызова

  Подпрограмма в виде функции, переданная в качестве аргумента для выполнения в некоторый момент в будущем.

класс

  Шаблон для создания пользовательских объектов. Определения классов обычно содержат определения методов, которые работают с экземплярами класса.

переменная класса

  Переменная, определённая в классе и предназначенная для изменения только на уровне класса (то есть не в экземпляре класса).

переменная замыкания

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

  Например, в функции `inner` в приведённом ниже коде `x` и `print` являются свободными переменными, но только `x` является переменной замыкания:

      def outer():
          x = 0
          def inner():
              nonlocal x
              x += 1
              print(x)
          return inner

  Из-за атрибута `codeobject.co_freevars` (который, несмотря на своё название, содержит только имена переменных замыкания, а не перечисляет все свободные переменные, на которые имеются ссылки) более общий термин свободная переменная иногда используется даже тогда, когда имеется в виду именно переменная замыкания.

комплексное число

  Расширение привычной системы действительных чисел, в которой все числа выражаются как сумма действительной и мнимой частей. Мнимые числа — это произведения действительных чисел и мнимой единицы (квадратного корня из `-1`), которую в математике обычно обозначают `i`, а в инженерных дисциплинах — `j`. Python имеет встроенную поддержку комплексных чисел, которые записываются с использованием последнего обозначения; мнимая часть записывается с суффиксом `j`, например `3+1j`. Чтобы получить доступ к комплексным аналогам функций модуля `math`, используйте `cmath`. Использование комплексных чисел — довольно продвинутая математическая возможность. Если вы не осознаёте необходимости в них, вы почти наверняка можете спокойно их игнорировать.

конкурентность

  Способность компьютерной программы выполнять несколько задач одновременно. Python предоставляет библиотеки для написания программ, использующих различные формы конкурентности. Библиотека `asyncio` предназначена для работы с асинхронными задачами и сопрограммами. `threading` предоставляет доступ к потокам операционной системы, а `multiprocessing` — к процессам операционной системы. Многоядерные процессоры могут одновременно выполнять потоки и процессы на разных ядрах ЦП (см. параллелизм).

конкурентное изменение

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

контекст

  Этот термин имеет разные значения в зависимости от того, где и как он используется. Некоторые распространённые значения:

  - Временное состояние или окружение, устанавливаемое менеджером контекста с помощью инструкции `with`.

  - Коллекция связей «ключ—значение», содержащихся в конкретном объекте `contextvars.Context` и доступных через объекты `ContextVar`. См. также контекстная переменная.

  - Объект `contextvars.Context`. См. также текущий контекст.

протокол управления контекстом

  Методы `__enter__()` и `__exit__()`, вызываемые инструкцией `with`. См. PEP 343.

менеджер контекста

  Объект, реализующий протокол управления контекстом и управляющий окружением, доступным внутри инструкции `with`. См. PEP 343.

переменная контекста

  Переменная, значение которой зависит от того, какой контекст является текущим контекстом. Доступ к значениям осуществляется через объекты `contextvars.ContextVar`. Переменные контекста в основном используются для изоляции состояния между конкурентно выполняемыми асинхронными задачами.

непрерывный

  Буфер считается непрерывным, если он является либо C-непрерывным, либо Fortran-непрерывным. Буферы нулевой размерности являются непрерывными и в смысле C, и в смысле Fortran. В одномерных массивах элементы должны быть расположены в памяти друг за другом в порядке возрастания индексов, начиная с нулевого. При последовательном обходе элементов многомерных C-непрерывных массивов в порядке возрастания их адресов в памяти быстрее всего изменяется последний индекс. В Fortran-непрерывных массивах, напротив, быстрее всего изменяется первый индекс.

сопрограмма

  Сопрограммы являются более обобщённой формой подпрограмм. Подпрограмма запускается в одной точке и завершается в другой. Сопрограмма же может запускаться, завершаться и возобновляться в различных точках. Она может быть реализована с помощью инструкции `async def`. См. также PEP 492.

сопрограммная функция

  Функция, возвращающая сопрограмму. Сопрограммная функция может быть определена с помощью инструкции `async def` и может содержать выражения `await`, а также инструкции `async for` и `async with`. Представлены в PEP 492.

CPython

  Каноническая реализация языка программирования Python, распространяемая на python.org. Термин «CPython» используется, когда необходимо отличить эту реализацию от других, таких как Jython или IronPython.

текущий контекст

  Контекст (объект `contextvars.Context`), который в данный момент используется объектами `ContextVar` для доступа (получения и изменения) к значениям переменных контекста. У каждого потока есть собственный текущий контекст. Фреймворки для выполнения асинхронных задач (см. `asyncio`) связывают каждую задачу с контекстом, который становится текущим контекстом всякий раз, когда задача начинает или возобновляет выполнение.

циклический изолят

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

гонка данных

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

взаимная блокировка

  Ситуация, при которой две или более задачи (потоки, процессы или сопрограммы) бесконечно ждут друг от друга освобождения ресурсов или завершения действий, не позволяя ни одной из них продолжить выполнение. Например, если поток A удерживает блокировку 1 и ждёт блокировку 2, а поток B удерживает блокировку 2 и ждёт блокировку 1, оба потока будут ждать бесконечно. В Python взаимные блокировки часто возникают из-за получения нескольких блокировок в конфликтующем порядке или из-за циклических зависимостей между join и await. Взаимных блокировок можно избежать, всегда получая несколько блокировок в одном и том же порядке. См. также блокировка и реентерабельность.

декоратор

  Функция, возвращающая другую функцию; обычно применяется для преобразования функции с помощью синтаксиса `@wrapper`. Типичные примеры декораторов — `@classmethod` и `@staticmethod`.

  Синтаксис декораторов является лишь синтаксическим сахаром: следующие два определения функций семантически эквивалентны:

      def f(arg):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(arg):
          ...

  Тот же принцип применяется и к классам, но используется реже. Подробнее о декораторах см. документацию по определениям функций и определениям классов.

дескриптор

  Любой объект, определяющий методы `__get__()`, `__set__()` или `__delete__()`. Когда атрибут класса является дескриптором, при обращении к этому атрибуту срабатывает специальный механизм связывания. Обычно выражение a.b для получения, изменения или удаления атрибута ищет объект с именем b в словаре класса a, но если b является дескриптором, вызывается соответствующий метод дескриптора. Понимание дескрипторов является ключом к глубокому пониманию Python, поскольку они лежат в основе многих возможностей языка, включая функции, методы, свойства, методы класса, статические методы и обращение к суперклассам.

  Подробнее о методах дескрипторов см. раздел Implementing Descriptors или Практическое руководство по дескрипторам.

словарь

  Ассоциативный массив, в котором произвольные ключи сопоставляются со значениями. Ключами могут быть любые объекты, имеющие методы `__hash__()` и `__eq__()`. В Perl называется хэшем.

включение словаря

  Компактный способ обработать все или часть элементов итерируемого объекта и вернуть словарь с результатами. `results = {n: n ** 2 for n in range(10)}` создаёт словарь, содержащий ключ `n`, сопоставленный со значением `n ** 2`. См. раздел Comprehensions.

представление словаря

  Объекты, возвращаемые методами `dict.keys()`, `dict.values()` и `dict.items()`, называются представлениями словаря. Они предоставляют динамическое представление элементов словаря, то есть при изменении словаря эти изменения отражаются в представлении. Чтобы преобразовать представление словаря в полноценный список, используйте `list(dictview)`. См. раздел Dictionary view objects.

строка документации

  Строковый литерал, который является первым выражением в классе, функции или модуле. Хотя при выполнении набора инструкций он игнорируется, компилятор распознаёт его и помещает в атрибут `__doc__` содержащего его класса, функции или модуля. Поскольку к нему можно получить доступ средствами интроспекции, это стандартное место для документации объекта.

утиная типизация

  Стиль программирования, при котором тип объекта не используется для определения его интерфейса. Вместо этого метод или атрибут просто вызывается или используется («Если что-то выглядит как утка и крякает как утка, значит, это и есть утка».) Делая акцент на интерфейсах, а не на конкретных типах, хорошо спроектированный код повышает свою гибкость, позволяя выполнять полиморфную замену объектов. Утиная типизация избегает проверок с использованием `type()` или `isinstance()`. (Однако обратите внимание, что утиная типизация может быть дополнена абстрактными базовыми классами.) Вместо этого обычно используются проверки `hasattr()` или программирование в стиле EAFP.

dunder

  Неформальное сокращение от «double underscore» («двойное подчёркивание»), используемое при упоминании специального метода. Например, `__init__` часто произносится как «dunder init».

EAFP

  «Проще попросить прощения, чем разрешения» («Easier to ask for forgiveness than permission»). Распространённый в Python стиль программирования, при котором предполагается наличие допустимых ключей или атрибутов, а исключения перехватываются, если это предположение оказывается неверным. Этот чистый и быстрый стиль характеризуется наличием множества инструкций `try` и `except`. Этот подход противопоставляется стилю LBYL, распространённому во многих других языках, например в C.

вычисляющая функция

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

выражение

  Фрагмент синтаксиса, который может быть вычислен до некоторого значения. Другими словами, выражение представляет собой совокупность элементов выражения, таких как литералы, имена, доступ к атрибутам, операторы или вызовы функций, каждый из которых возвращает значение. Не все языковые конструкции являются выражениями. Существуют также инструкции, которые не могут использоваться как выражения, например `while`. Присваивания также являются инструкциями, а не выражениями.

модуль расширения

  Модуль, написанный на C или C++, использующий C API Python для взаимодействия с ядром и пользовательским кодом.

f-строка
f-строки

  Строковые литералы с префиксом `f` или `F` обычно называются «f-строками» — это сокращение от форматированные строковые литералы. См. также PEP 498.

файловый объект

  Объект, предоставляющий файлово-ориентированный API (с такими методами, как `read()` или `write()`) к базовому ресурсу. В зависимости от способа создания, файловый объект может выступать посредником при доступе к реальному файлу на диске или к другому типу устройства хранения или связи (например, стандартному вводу/выводу, буферам в памяти, сокетам, каналам и т. д.). Файловые объекты также называются объектами, подобными файлам или потоками.

  На самом деле существует три категории файловых объектов: сырые двоичные файлы, буферизованные двоичные файлы и текстовые файлы. Их интерфейсы определены в модуле `io`. Канонический способ создания файлового объекта — использование функции `open()`.

объект, подобный файлу

  Синоним файлового объекта.

кодировка файловой системы и обработчик ошибок

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

  Кодировка файловой системы должна гарантировать успешное декодирование всех байтов со значениями меньше 128. Если кодировка файловой системы не обеспечивает эту гарантию, функции API могут возбуждать исключение `UnicodeError`.

  Функции `sys.getfilesystemencoding()` и `sys.getfilesystemencodeerrors()` можно использовать для получения кодировки файловой системы и обработчика ошибок.

  Кодировка файловой системы и обработчик ошибок настраиваются при запуске Python функцией `PyConfig_Read()`: см. члены `filesystem_encoding` и `filesystem_errors` объекта `PyConfig`.

  См. также кодировку локали.

поисковик

  Объект, который пытается найти загрузчик для импортируемого модуля.

  Существует два типа поисковиков: поисковики мета-пути, используемые с `sys.meta_path` и поисковики элемента пути, используемые с `sys.path_hooks`.

  Подробнее см. в Finders and loaders и `importlib`.

целочисленное деление с округлением вниз

  Математическое деление, округляющее результат до ближайшего целого числа в меньшую сторону. Оператор целочисленного деления с округлением вниз — это `//`. Например, выражение `11 // 4` вычисляется как `2`, в отличие от `2.75`, возвращаемого истинным делением чисел с плавающей точкой. Обратите внимание, что `(-11) // 4` равно `-3`, поскольку это значение `-2.75`, округлённое вниз. См. также PEP 238.

свободная многопоточность

  Модель потоков, в которой несколько потоков могут одновременно выполнять байт-код Python в одном интерпретаторе. Это противопоставляется глобальной блокировке интерпретатора, которая позволяет выполнять байт-код Python только одному потоку за раз. См. PEP 703.

сборка с поддержкой свободной многопоточности

  Сборка CPython, поддерживающая свободную многопоточность и настроенная с помощью параметра `--disable-gil` перед компиляцией.

  См. Python support for free threading.

свободная переменная

  Формально, как определено в модели выполнения языка, свободная переменная — это любая переменная, используемая в пространстве имён, которая не является локальной переменной в этом пространстве имён. См. пример в статье о переменной замыкания. На практике, из-за названия атрибута `codeobject.co_freevars`, этот термин также иногда используется как синоним переменной замыкания.

функция

  Последовательность инструкций, возвращающая некоторое значение вызывающему её коду. Ей также может быть передано ноль или более аргументов, которые могут использоваться при выполнении её тела. См. также параметр, метод и раздел Function definitions.

аннотация функции

  Аннотация параметра функции или возвращаемого значения.

  Аннотации функций обычно используются для подсказок типов. Например, ожидается, что эта функция принимает два аргумента типа `int`, а также возвращает значение типа `int`:

      def sum_two_numbers(a: int, b: int) -> int:
         return a + b

  Синтаксис аннотации функции описан в разделе Function definitions.

  См. аннотация переменной и PEP 484, которые описывают эту функциональность. Рекомендации по работе с аннотациями см. также в Annotations Best Practices.

__future__

  Инструкция future, `from __future__ import <feature>`, указывает компилятору обрабатывать текущий модуль с использованием синтаксиса или семантики, которые станут стандартными в будущей версии Python. Модуль `__future__` документирует возможные значения feature. Импортировав этот модуль и изучив его переменные, можно узнать, когда новая функциональность была впервые добавлена в язык и когда она станет (или стала) используемой по умолчанию:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

сборка мусора

  Процесс освобождения памяти, когда она больше не используется. Python выполняет сборку мусора с помощью подсчёта ссылок и сборщика циклического мусора, способного обнаруживать и разрывать циклы ссылок. Сборщиком мусора можно управлять с помощью модуля `gc`.

генератор

  Неформально используется для обозначения либо генераторной функции, либо генераторного итератора в зависимости от контекста. Формальные термины генераторная функция и генераторный итератор на практике используются редко; одного слова «генератор» почти всегда достаточно.

генераторная функция

  Функция, возвращающая объект генератора. Выглядит как обычная функция, но содержит выражения `yield`, порождающие последовательность значений, которые можно использовать в цикле `for` или получать по одному с помощью функции `next()`. См. Yield expressions.

генераторный итератор

  Объект, созданный генераторной функцией или генераторным выражением.

  Каждое выражение `yield` временно приостанавливает обработку кода, сохраняя состояние выполнения (включая локальные переменные и незавершённые инструкции try). Когда генераторный итератор возобновляет выполнение, он продолжает его с того места, где остановился (в отличие от функций, которые при каждом вызове начинают выполнение заново).

  Генераторные итераторы также реализуют метод `send()`, позволяющий передать значение приостановленному генератору, и метод `throw()`, позволяющий возбудить исключение в точке, где генератор был приостановлен. См. Generator-iterator methods.

генераторное выражение

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

      >>> sum(i*i for i in range(10))         # сумма квадратов 0, 1, 4, ... 81
      285

обобщённая функция

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

  См. также статью глоссария одинарная диспетчеризация, декоратор `@functools.singledispatch` и PEP 443.

обобщённый тип

  Тип, который можно параметризовать. Обычно это класс-контейнер, такой как `list` или `dict`. Используется для подсказок типов и аннотаций.

  Подробнее см. обобщённые псевдонимы типов, PEP 483, PEP 484, PEP 585 и модуль `typing`.

GIL

  См. глобальную блокировку интерпретатора.

глобальная блокировка интерпретатора

  Механизм, используемый интерпретатором CPython для обеспечения того, чтобы одновременно только один поток выполнял байт-код Python. Это упрощает реализацию CPython, поскольку объектная модель (включая такие важные встроенные типы, как `dict`) автоматически становится безопасной при конкурентном доступе. Блокировка всего интерпретатора упрощает реализацию многопоточности в интерпретаторе, но за это приходится жертвовать значительной частью параллелизма, предоставляемого многопроцессорными системами.

  Однако некоторые модули расширений, как стандартные, так и сторонние, спроектированы так, чтобы освобождать GIL при выполнении вычислительно интенсивных задач, таких как сжатие или хэширование. Кроме того, при выполнении операций ввода-вывода GIL всегда освобождается.

  Начиная с Python 3.13, GIL можно отключить с помощью параметра конфигурации сборки `--disable-gil`. После сборки Python с этой опцией код необходимо запустить с `-X gil=0` или после установки переменной окружения `PYTHON_GIL=0`. Эта возможность позволяет повысить производительность многопоточных приложений и упрощает эффективное использование многоядерных процессоров. Подробнее см. PEP 703.

  В предыдущих версиях C API Python функция могла объявить, что для её использования необходимо удерживать GIL. Под этим подразумевалось наличие присоединённого состояния потока.

глобальное состояние

  Данные, доступные во всей программе, такие как переменные на уровне модуля, переменные классов или статические переменные языка C в модулях расширений. В многопоточных программах глобальное состояние, совместно используемое потоками, обычно требует синхронизации, чтобы избежать состояний гонки и гонок данных.

pyc на основе хэша

  Файл кэша байт-кода, который использует хэш, а не время последнего изменения соответствующего исходного файла для определения его актуальности. См. Cached bytecode invalidation.

хэшируемый

  Объект является хэшируемым, если он имеет хэш-значение, которое никогда не меняется в течение его времени жизни (для этого требуется метод `__hash__()`) и его можно сравнивать с другими объектами (для этого нужен `__eq__()`). Хэшируемые объекты, которые считаются равными, должны иметь одинаковое хэш-значение.

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

  Большинство неизменяемых встроенных объектов Python являются хэшируемыми; изменяемые контейнеры (такие как списки или словари) — нет; неизменяемые контейнеры (такие как кортежи и замороженные множества) хэшируемы только в том случае, если их элементы хэшируемы. Объекты, являющиеся экземплярами пользовательских классов, по умолчанию хэшируемы. Все они неравны друг другу (кроме самих себя), а их хэш-значение получается из их `id()`.

IDLE

  Интегрированная среда разработки и обучения для языка Python. IDLE — Python editor and shell — это базовый редактор и оболочка интерпретатора, входящие в стандартный дистрибутив Python.

бессмертный

  Бессмертные объекты — это деталь реализации CPython, представленная в PEP 683.

  Если объект бессмертен, его счётчик ссылок никогда не изменяется и, следовательно, он никогда не освобождается во время работы интерпретатора. Например, `True` и `None` бессмертны в CPython.

  Бессмертные объекты можно определить с помощью `sys._is_immortal()` или с помощью `PyUnstable_IsImmortal()` в C API.

неизменяемый

  Объект с фиксированным значением. К неизменяемым объектам относятся числа, строки и кортежи. Такой объект нельзя изменить. Если требуется сохранить другое значение, необходимо создать новый объект. Они играют важную роль там, где требуется постоянное хэш-значение, например в качестве ключа словаря. Неизменяемые объекты по своей природе потокобезопасны, поскольку после создания их состояние не может быть изменено, что исключает проблемы, связанные с неправильно синхронизированным конкурентным изменением.

путь импорта

  Список расположений (или элементов пути), в которых поисковик по пути ищет импортируемые модули. Во время импорта этот список расположений обычно берётся из `sys.path`, но для подпакетов он также может быть получен из атрибута `__path__` родительского пакета.

импортирование

  Процесс, посредством которого код Python из одного модуля становится доступен коду Python в другом модуле.

импортёр

  Объект, который находит и загружает модуль; является одновременно и поисковиком, и загрузчиком.

индекс

  Числовое значение, представляющее позицию элемента в последовательности.

  В Python индексация начинается с нуля. Например, `things[0]` обозначает первый элемент `things`, а `things[1]` — второй.

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

  См. также индексатор.

интерактивный

  Python имеет интерактивный интерпретатор, то есть вы можете вводить инструкции и выражения в приглашении интерпретатора, немедленно выполнять их и видеть результаты. Просто запустите `python` без аргументов (возможно, выбрав его в главном меню компьютера). Это очень удобный способ проверить новые идеи или исследовать модули и пакеты (помните о `help(x)`). Подробнее об интерактивном режиме см. Интерактивный режим.

интерпретируемый

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

завершение работы интерпретатора

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

  Основная причина завершения работы интерпретатора заключается в том, что модуль `__main__` или выполняемый скрипт завершил выполнение.

итерируемый

  Объект, способный возвращать свои элементы по одному. К итерируемым относятся все последовательности (такие как `list`, `str` и `tuple`), а также некоторые типы, не являющиеся последовательностями, например `dict`, файловые объекты и объекты любых определяемых вами классов, в которых реализован метод `__iter__()` или `__getitem__()`, реализующий семантику последовательностей.

  Итерируемые объекты можно использовать в цикле `for` и во многих других местах, где требуется последовательность (`zip()`, `map()` и т. д.). Когда итерируемый объект передаётся в качестве аргумента встроенной функции `iter()`, она возвращает итератор этого объекта. Такой итератор предназначен для однократного прохода по набору значений. При работе с итерируемыми объектами обычно нет необходимости самостоятельно вызывать `iter()` или работать с объектами-итераторами. Инструкция `for` делает это автоматически, создавая временную безымянную переменную, в которой хранится итератор на время выполнения цикла. См. также итератор, последовательность и генератор.

итератор

  Объект, представляющий поток данных. Повторные вызовы метода `__next__()` итератора (или передача его встроенной функции `next()`) возвращают следующие элементы в потоке. Когда данные заканчиваются, вместо этого возбуждается исключение `StopIteration`. После этого итератор считается исчерпанным, и любые последующие вызовы его метода `__next__()` снова возбуждают `StopIteration`. Итераторы должны иметь метод `__iter__()`, возвращающий сам объект-итератор, поэтому каждый итератор также является итерируемым объектом и может использоваться в большинстве мест, где принимаются другие итерируемые объекты. Одно важное исключение — код, пытающийся выполнить несколько проходов по данным. Контейнер (например, `list`) создаёт новый итератор при каждом вызове для него функции `iter()` или использовании его в цикле `for`. При попытке сделать то же самое с итератором возвращается тот же исчерпанный объект-итератор, использовавшийся при предыдущем проходе, из-за чего он выглядит как пустой контейнер.

  Больше информации можно найти в Iterator Types.

  CPython не всегда соблюдает требование о наличии у итератора метода `__iter__()`. Также обратите внимание, что CPython со свободной многопоточностью не гарантирует потокобезопасность операций над итераторами.

ключ

  Значение, идентифицирующее элемент отображения. См. также индексатор.

ключевая функция

  Ключевая функция или функция сопоставления — это вызываемый объект, который возвращает значение, используемое для сортировки или упорядочивания. Например, функция `locale.strxfrm()` используется для получения ключа сортировки, учитывающего специфичные для локали правила сортировки.

  Ряд инструментов Python поддерживает ключевые функции для управления порядком или группировкой элементов. К ним относятся `min()`, `max()`, `sorted()`, `list.sort()`, `heapq.merge()`, `heapq.nsmallest()`, `heapq.nlargest()` и `itertools.groupby()`.

  Существует несколько способов создать ключевую функцию. Например, метод `str.casefold()` может использоваться как ключевая функция для сортировки без учёта регистра. В качестве альтернативы ключевую функцию можно создать с помощью `lambda` выражения, например `lambda r: (r[0], r[2])`. Кроме того, `operator.attrgetter()`, `operator.itemgetter()` и `operator.methodcaller()` являются тремя конструкторами ключевых функций. См. практическое руководство по сортировке для примеров создания и использования ключевых функций.

именованный аргумент

  Смотри аргумент.

лямбда

  Анонимная встроенная функция, состоящая из одного выражения, которое вычисляется при вызове функции. Синтаксис создания лямбда-функции: `lambda [parameters]: expression`

LBYL

  «Посмотри, прежде чем прыгнуть» («Look before you leap»). Стиль программирования, при котором перед выполнением вызовов или обращений явно проверяются предварительные условия. Этот стиль противопоставляется подходу EAFP и характеризуется наличием множества инструкций `if`.

  В многопоточной среде подход LBYL может привести к возникновению состояния гонки между «проверкой» и «действием». Например, код `if key in mapping: return mapping[key]` может завершиться ошибкой, если другой поток удалит key из mapping после проверки, но до обращения к элементу. Эту проблему можно решить с помощью блокировок или используя подход EAFP. См. также потокобезопасный.

лексический анализатор

  Официальное название для токенизатора. См. токен.

список

  Встроенная последовательность Python. Несмотря на своё название, она больше похожа на массив в других языках, чем на связный список, поскольку доступ к элементам имеет сложность O(1). См. Time complexity of operations on built-in types.

включение списка

  Компактный способ обработать все или часть элементов последовательности и вернуть список с результатами. Например, `result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]` создаёт список строк, содержащих чётные шестнадцатеричные числа (0x..) в диапазоне от 0 до 255. Условие `if` является необязательным. Если оно опущено, обрабатываются все элементы `range(256)`.

блокировка

  Примитив синхронизации, который позволяет только одному потоку одновременно получать доступ к общему ресурсу. Поток должен захватить блокировку перед доступом к защищённому ресурсу и освободить её после этого. Если поток пытается захватить блокировку, которая уже удерживается другим потоком, он будет заблокирован до тех пор, пока блокировка не станет доступной. Модуль Python `threading` предоставляет `Lock` (простую блокировку) и `RLock` (реентерабельную блокировку). Блокировки используются для предотвращения состояний гонки и обеспечения потокобезопасного доступа к общим данным. Существуют альтернативные шаблоны проектирования, не использующие блокировки, например очереди, шаблоны «производитель — потребитель» и локальное состояние потока. См. также взаимная блокировка и реентерабельность.

свободный от блокировок

  Операция, которая не захватывает никакой блокировки и использует атомарные инструкции процессора для обеспечения корректности. Операции без блокировок могут выполняться конкурентно, не блокируя друг друга, и не могут быть заблокированы операциями, удерживающими блокировки. В версии Python со свободной многопоточностью встроенные типы, такие как `dict` и `list`, предоставляют операции чтения без блокировок. Это означает, что другие потоки могут наблюдать промежуточные состояния при многошаговых изменениях, даже если эти изменения удерживают блокировку объекта.

загрузчик

  Объект, загружающий модуль. Он должен определять методы `exec_module()` и `create_module()` для реализации интерфейса `Loader`. Загрузчик обычно возвращается поисковиком. См. также:

  - Finders and loaders

  - `importlib.abc.Loader`

  - PEP 302

кодировка локали

  В Unix это кодировка локали LC_CTYPE. Её можно установить с помощью `locale.setlocale(locale.LC_CTYPE, new_locale)`.

  В Windows это кодовая страница ANSI (например: `"cp1252"`).

  В Android и VxWorks Python использует `"utf-8"` в качестве кодировки локали.

  Для получения кодировки локали можно использовать `locale.getencoding()`.

  См. также кодировку файловой системы и обработчик ошибок.

магический метод

  Неформальный синоним термина специальный метод.

отображение

  Контейнерный объект, который поддерживает поиск по произвольным ключам и реализует методы, определённые в абстрактных базовых классах `collections.abc.Mapping` или `collections.abc.MutableMapping`. Примеры включают `dict`, `collections.defaultdict`, `collections.OrderedDict` и `collections.Counter`.

поисковик мета-пути

  Поисковик, возвращаемый при поиске в `sys.meta_path`. Поисковики мета-пути связаны с поисковиками элемента пути, но отличаются от них.

  См. `importlib.abc.MetaPathFinder` для получения информации о методах, которые реализуют поисковики мета-пути.

метакласс

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

  Подробнее см. Metaclasses.

метод

  Функция, определённая внутри тела класса. Если она вызывается как атрибут экземпляра этого класса, метод получает объект экземпляра в качестве первого аргумента (который обычно называется `self`). См. также функция и вложенная область видимости.

порядок разрешения методов

  Порядок разрешения методов — это порядок, в котором базовые классы просматриваются при поиске члена класса. См. The Python 2.3 Method Resolution Order для подробностей алгоритма, используемого интерпретатором Python начиная с версии 2.3.

модуль

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

  См. также пакет.

спецификация модуля

  Пространство имён, содержащее связанную с импортом информацию, используемую для загрузки модуля. Экземпляр `importlib.machinery.ModuleSpec`.

  См. также Module specs.

MRO

  Смотри порядок разрешения методов.

изменяемый

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

именованный кортеж

  Термин «именованный кортеж» применяется к любому типу или классу, который наследуется от кортежа и чьи индексируемые элементы также доступны через именованные атрибуты. У такого типа или класса могут быть и другие возможности.

  Несколько встроенных типов являются именованными кортежами, включая значения, возвращаемые функциями `time.localtime()` и `os.stat()`. Другой пример — `sys.float_info`:

      >>> sys.float_info[1]                   # доступ по индексу
      1024
      >>> sys.float_info.max_exp              # доступ к именованному полю
      1024
      >>> isinstance(sys.float_info, tuple)   # вид кортежа
      True

  Некоторые именованные кортежи являются встроенными типами (как в приведённых выше примерах). Кроме того, именованный кортеж можно создать из обычного определения класса, который наследуется от `tuple` и определяет именованные поля. Такой класс можно написать вручную, создать с помощью наследования от `typing.NamedTuple` или с помощью фабричной функции `collections.namedtuple()`. Последние два способа также добавляют дополнительные методы, которых может не быть у написанных вручную или встроенных именованных кортежей.

пространство имён

  Место, где хранится переменная. Пространства имён реализованы в виде словарей. Существуют локальное, глобальное и встроенное пространства имён, а также вложенные пространства имён в объектах (в методах). Пространства имён обеспечивают модульность, предотвращая конфликты имён. Например, функции `builtins.open` и `os.open()` различаются своими пространствами имён. Пространства имён также повышают читаемость и удобство сопровождения, показывая, какой модуль реализует функцию. Например, запись `random.seed()` или `itertools.islice()` показывает, что эти функции реализованы соответственно модулями `random` и `itertools`.

пакет пространства имён

  Пакет, который служит только контейнером для вложенных пакетов. Пакеты пространства имён могут не иметь физического представления и, в частности, отличаются от обычных пакетов тем, что не имеют файла `__init__.py`.

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

  Для получения дополнительной информации см. PEP 420 и Namespace packages.

  См. также модуль.

машинный код

  Код, скомпилированный в машинные инструкции и выполняющийся непосредственно на процессоре, в отличие от кода, который интерпретируется или выполняется в виртуальной машине. В контексте Python под машинным кодом обычно подразумевается код на C, C++, Rust или Fortran в модулях расширения, который может вызываться из Python. См. также модуль расширения.

вложенная область видимости

  Возможность ссылаться на переменную во внешнем определении. Например, функция, определённая внутри другой функции, может обращаться к переменным внешней функции. Обратите внимание, что вложенные области видимости по умолчанию позволяют только обращаться к переменным на чтение, но не выполнять присваивание в них. Локальные переменные при чтении и записи используются в самой внутренней области видимости. Аналогично, глобальные переменные при чтении и записи работают с глобальным пространством имён. Инструкция `nonlocal` позволяет выполнять запись во внешние области видимости.

класс нового стиля

  Устаревшее название разновидности классов, которое теперь используется для всех объектов-классов. В более ранних версиях Python только классы нового стиля могли использовать новые универсальные возможности Python, такие как `__slots__`, дескрипторы, свойства, `__getattribute__()`, методы класса и статические методы.

недетерминированный

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

объект

  Любые данные с состоянием (атрибутами или значением) и определённым поведением (методами). Также базовый класс верхнего уровня для любого класса нового стиля.

оптимизированная область видимости

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

необязательный модуль

  Модуль расширения, входящий в состав стандартной библиотеки, но отсутствующий в некоторых сборках CPython, обычно из-за отсутствия сторонних библиотек или потому, что модуль недоступен для определённой платформы.

  См. Requirements for optional modules для получения списка необязательных модулей, требующих сторонних библиотек.

пакет

  Модуль Python, который может содержать вложенные модули или, рекурсивно, вложенные пакеты. Технически, пакет — это модуль Python с атрибутом `__path__`.

  См. также обычный пакет и пакет пространства имён.

параллелизм

  Одновременное выполнение нескольких операций (например, на нескольких ядрах процессора). В сборках Python с глобальной блокировкой интерпретатора (GIL) только один поток одновременно выполняет байт-код Python, поэтому использование нескольких ядер процессора обычно требует нескольких процессов (например, `multiprocessing`) или нативных расширений, освобождающих GIL. В сборках Python со свободной многопоточностью несколько потоков Python могут одновременно выполнять код Python на разных ядрах.

параметр

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

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

        def func(foo, bar=None): ...

  - только позиционный: задаёт аргумент, который можно передать только по позиции. Параметры, доступные только по позиции, можно определить, добавив символ `/` в список параметров определения функции после них, например posonly1 и posonly2 в следующем примере:

        def func(posonly1, posonly2, /, positional_or_keyword): ...

  - только именованный: задаёт аргумент, который можно передать только по имени. Параметры, доступные только по имени, можно определить, добавив один параметр с переменным числом позиционных аргументов или отдельный символ `*` в список параметров определения функции перед ними, например kw_only1 и kw_only2 в следующем примере:

        def func(arg, *, kw_only1, kw_only2): ...

  - переменное число позиционных: задаёт, что может быть передана произвольная последовательность позиционных аргументов (в дополнение к любым позиционным аргументам, уже принимаемым другими параметрами). Такой параметр можно определить, добавив перед его именем символ `*`, например args в следующем примере:

        def func(*args, **kwargs): ...

  - переменное число именованных: задаёт, что может быть передано произвольное количество именованных аргументов (в дополнение к любым именованным аргументам, уже принимаемым другими параметрами). Такой параметр можно определить, добавив перед его именем символ `**`, например kwargs в приведённом выше примере.

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

  См. также запись глоссария аргумент, вопрос ЧаВо о разнице между аргументами и параметрами, класс `inspect.Parameter`, раздел Function definitions и PEP 362.

блокировка объекта

  Блокировка, связанная с отдельным экземпляром объекта, а не с глобальной блокировкой, общей для всех объектов. В Python со свободной многопоточностью встроенные типы, такие как `dict` и `list`, используют блокировки объектов, чтобы разрешить конкурентные операции над разными объектами, одновременно сериализуя операции над одним и тем же объектом. Операции, удерживающие блокировку объекта, не позволяют выполняться другим операциям с блокировкой над тем же объектом, но не блокируют операции без блокировок.

элемент пути

  Одно расположение в пути импорта, которое поисковик на основе пути использует для поиска модулей для импорта.

поисковик элемента пути

  Поисковик, возвращаемый вызываемым объектом из `sys.path_hooks` (то есть обработчиком элемента пути), который умеет находить модули для заданного элемента пути.

  См. `importlib.abc.PathEntryFinder` для методов, реализуемых поисковиками элементов пути.

обработчик элемента пути

  Вызываемый объект из списка `sys.path_hooks`, который возвращает поисковик элемента пути, если умеет находить модули в определённом элементе пути.

поисковик на основе пути

  Один из стандартных поисковиков мета-пути, который выполняет поиск модулей в пути импорта.

объект, подобный пути

  Объект, представляющий путь в файловой системе. Объект, подобный пути, является либо объектом `str` или `bytes`, представляющим путь, либо объектом, реализующим протокол `os.PathLike`. Объект, поддерживающий протокол `os.PathLike`, можно преобразовать в путь файловой системы в виде объекта `str` или `bytes`, вызвав функцию `os.fspath()`. Чтобы гарантировать результат типа `str` или `bytes`, можно использовать соответственно функции `os.fsdecode()` и `os.fsencode()`. Представлено в PEP 519.

PEP

  «Предложение по улучшению Python» («Python Enhancement Proposal»). PEP — это проектный документ, предоставляющий информацию сообществу Python или описывающий новую возможность Python, его процессы или окружение. PEP должны содержать краткую техническую спецификацию и обоснование предлагаемых возможностей.

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

  Смотри PEP 1.

часть

  Набор файлов в одном каталоге (возможно, хранящихся в zip-файле), которые составляют пакет пространства имён, как определено в PEP 420.

позиционный аргумент

  Смотри аргумент.

предварительный API

  Предварительный API — это API, который был намеренно исключён из гарантий обратной совместимости стандартной библиотеки. Хотя серьёзные изменения таких интерфейсов не ожидаются, пока они имеют статус предварительных, обратно несовместимые изменения (вплоть до удаления интерфейса) могут быть внесены, если основные разработчики сочтут их необходимыми. Такие изменения не будут вноситься без веской причины — они произойдут только в случае обнаружения серьёзных фундаментальных недостатков, которые не были замечены до включения API.

  Даже для предварительных API изменения, несовместимые с предыдущими версиями, рассматриваются как «крайнее средство» — всё равно будут предприняты все попытки найти обратно совместимое решение для любых выявленных проблем.

  Этот процесс позволяет стандартной библиотеке продолжать развиваться с течением времени, не закрепляя проблемные ошибки проектирования на длительные периоды. См. подробности в PEP 411.

предварительный пакет

  Смотри предварительный API.

Python 3000

  Прозвище линейки выпусков Python 3.x (возникшее задолго до выхода версии 3, когда её выпуск был ещё далёкой перспективой). Также сокращается как «Py3k».

идиоматичный для Python

  Идея или фрагмент кода, которые точно соответствуют наиболее распространённым идиомам языка Python, а не реализуют код с использованием концепций, принятых в других языках. Например, распространённая идиома Python — перебор всех элементов итерируемого объекта с помощью инструкции `for`. Во многих других языках такой конструкции нет, поэтому люди, незнакомые с Python, иногда вместо этого используют числовой счётчик:

      for i in range(len(food)):
          print(food[i])

  В отличие от более чистого и идиоматичного для Python способа:

      for piece in food:
          print(piece)

квалифицированное имя

  Имя с точками, показывающее «путь» от глобальной области видимости модуля к классу, функции или методу, определённым в этом модуле, как описано в PEP 3155. Для функций и классов верхнего уровня квалифицированное имя совпадает с именем объекта:

      >>> class C:
      ...     class D:
      ...         def meth(self):
      ...             pass
      ...
      >>> C.__qualname__
      'C'
      >>> C.D.__qualname__
      'C.D'
      >>> C.D.meth.__qualname__
      'C.D.meth'

  При использовании применительно к модулям полное квалифицированное имя означает полный путь с точками к модулю, включая все родительские пакеты, например `email.mime.text`:

      >>> import email.mime.text
      >>> email.mime.text.__name__
      'email.mime.text'

состояние гонки

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

счётчик ссылок

  Количество ссылок на объект. Когда счётчик ссылок объекта падает до нуля, объект освобождается. Некоторые объекты являются бессмертными и имеют счётчики ссылок, которые никогда не изменяются, поэтому такие объекты никогда не освобождаются. Подсчёт ссылок обычно не виден в коде Python, но является ключевым элементом реализации CPython. Программисты могут вызвать функцию `sys.getrefcount()`, чтобы получить счётчик ссылок для конкретного объекта.

  В CPython счётчики ссылок не считаются стабильными или строго определёнными значениями. Количество ссылок на объект и то, как это количество изменяется под воздействием кода Python, может отличаться между версиями.

обычный пакет

  Традиционный пакет, например каталог, содержащий файл `__init__.py`.

  См. также пакет пространства имён.

реентерабельность

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

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

  Для блокировок в Python `threading.RLock` (реентерабельная блокировка) является реентерабельной — поток, уже владеющий блокировкой, может снова захватить её без блокировки. В отличие от неё, `threading.Lock` не является реентерабельной — попытка дважды захватить её из одного и того же потока приведёт к взаимной блокировке.

  См. также блокировка и взаимная блокировка.

REPL

  Аббревиатура от «цикл чтения–вычисления–вывода» («read–eval–print loop»), другое название интерактивной оболочки интерпретатора.

__slots__

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

последовательность

  Итерируемый объект, который поддерживает эффективный доступ к элементам с использованием целочисленных индексов через специальный метод `__getitem__()` и определяет метод `__len__()`, возвращающий длину последовательности. Некоторые встроенные типы последовательностей: `list`, `str`, `tuple` и `bytes`. Обратите внимание, что `dict` также поддерживает `__getitem__()` и `__len__()`, но считается отображением, а не последовательностью, поскольку поиск выполняется с использованием произвольных хешируемых ключей, а не целых чисел.

  Абстрактный базовый класс `collections.abc.Sequence` определяет гораздо более богатый интерфейс, выходящий за пределы только `__getitem__()` и `__len__()`, добавляя методы `count()`, `index()`, `__contains__()` и `__reversed__()`. Типы, реализующие этот расширенный интерфейс, могут быть явно зарегистрированы с помощью `register()`. Дополнительную документацию по методам последовательностей в целом см. в разделе Общие операции с последовательностями.

включение множества

  Компактный способ обработать все или часть элементов итерируемого объекта и вернуть множество с результатами. `results = {c for c in 'abracadabra' if c not in 'abc'}` создаёт множество строк `{'r', 'd'}`. См. Comprehensions.

одиночная диспетчеризация

  Форма диспетчеризации обобщённой функции, при которой выбор реализации выполняется на основе типа одного аргумента.

срез

  Объект типа `slice`, используемый для описания части последовательности. Для создания объекта среза используется специальный синтаксис срезов при обращении к элементам с помощью двоеточий в квадратных скобках, например `variable_name[1:3:5]`.

слегка устаревший

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

  Лёгкое устаревание, в отличие от обычного устаревания, не предусматривает удаления API и не приводит к выдаче предупреждений.

  См. PEP 387: Лёгкое устаревание.

специальный метод

  Метод, который неявно вызывается Python для выполнения определённой операции над типом, например сложения. Такие методы имеют имена, начинающиеся и заканчивающиеся двойным подчёркиванием. Специальные методы описаны в Special method names.

стандартная библиотека

  Набор пакетов, модулей и расширений модулей, распространяемых как часть официального пакета интерпретатора Python. Точный состав этого набора может различаться в зависимости от платформы, доступных системных библиотек или других критериев. Документация находится в разделе The Python Standard Library.

  См. также `sys.stdlib_module_names` для получения списка всех возможных имён модулей стандартной библиотеки.

инструкция

  Инструкция является частью набора инструкций («блока» кода). Инструкция представляет собой либо выражение, либо одну из конструкций с ключевым словом, таких как `if`, `while` или `for`.

статический анализатор типов

  Внешний инструмент, который читает код Python и анализирует его, выявляя такие проблемы, как некорректные типы. См. также подсказки типов и модуль `typing`.

stdlib

  Сокращение от стандартная библиотека.

захват

  В C API Python «захват» аргумента означает, что владение аргументом передаётся вызываемой функции. После вызова вызывающая сторона не должна использовать эту ссылку. Как правило, функции, которые «захватывают» аргумент, делают это даже в случае ошибки.

  Полное объяснение см. в разделе Reference Count Details.

сильная ссылка

  В C API Python сильная ссылка — это ссылка на объект, которой владеет код, содержащий эту ссылку. Сильная ссылка приобретается вызовом функции `Py_INCREF()` при создании ссылки и освобождается вызовом функции `Py_DECREF()` при удалении ссылки.

  Функцию `Py_NewRef()` можно использовать для создания сильной ссылки на объект. Обычно перед выходом из области действия сильной ссылки необходимо вызвать функцию `Py_DECREF()` для этой ссылки, чтобы избежать утечки одной ссылки.

  См. также заимствованная ссылка.

индексатор

  Выражение в квадратных скобках при обращении к элементу, например `3` в `items[3]`. Обычно используется для выбора элемента контейнера. При обращении к отображению индексатор также называется ключом, а при обращении к последовательности — индексом.

примитив синхронизации

  Базовый строительный блок для координации (синхронизации) выполнения нескольких потоков с целью обеспечения потокобезопасного доступа к общим ресурсам. Модуль `threading` Python предоставляет несколько примитивов синхронизации, включая `Lock`, `RLock`, `Semaphore`, `Condition`, `Event` и `Barrier`. Кроме того, модуль `queue` предоставляет очереди с несколькими производителями и несколькими потребителями, которые особенно полезны в многопоточных программах. Эти примитивы помогают предотвращать состояния гонки и координировать выполнение потоков. См. также блокировка.

t-строка
t-строки

  Строковые литералы с префиксом `t` или `T` обычно называются «t-строками», что является сокращением от шаблонных строковых литералов.

кодировка текста

  Строка в Python представляет собой последовательность кодовых точек Unicode (в диапазоне `U+0000`–`U+10FFFF`). Чтобы сохранить или передать строку, её необходимо сериализовать в виде последовательности байтов.

  Сериализация строки в последовательность байтов называется «кодированием», а воссоздание строки из последовательности байтов называется «декодированием».

  Существует множество различных кодеков сериализации текста, которые в совокупности называются «кодировками текста».

текстовый файл

  Файловый объект, способный читать и записывать объекты `str`. Часто текстовый файл фактически обращается к байтовому потоку данных и автоматически обрабатывает кодировку текста. Примерами текстовых файлов являются файлы, открытые в текстовом режиме (`'r'` или `'w'`), `sys.stdin`, `sys.stdout` и экземпляры `io.StringIO`.

  См. также двоичный файл — файловый объект, способный читать и записывать объекты, подобные bytes.

состояние потока

  Информация, используемая средой выполнения CPython для работы в потоке ОС. Например, сюда входит текущее исключение, если таковое имеется, и состояние интерпретатора байт-кода.

  Каждое состояние потока привязано к одному потоку ОС, но у потоков может быть доступно несколько состояний потока. В каждый момент времени к потоку может быть присоединено не более одного из них.

  Присоединённое состояние потока требуется для вызова большинства функций C API Python, если иное явно не указано в документации функции. Интерпретатор байт-кода выполняется только при наличии присоединённого состояния потока.

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

  Дополнительную информацию см. в разделе Состояние потока и глобальная блокировка интерпретатора.

потокобезопасный

  Модуль, функция или класс, которые корректно работают при одновременном использовании несколькими потоками. Потокобезопасный код использует подходящие примитивы синхронизации, такие как блокировки, для защиты общего изменяемого состояния или полностью спроектирован так, чтобы избегать общего изменяемого состояния. В сборке со свободной многопоточностью встроенные типы, такие как `dict`, `list` и `set`, используют внутренние блокировки, чтобы сделать многие операции потокобезопасными, хотя потокобезопасность не всегда гарантируется. Код, не являющийся потокобезопасным, при использовании в многопоточных программах может приводить к состояниям гонки и гонкам данных.

токен

  Небольшая единица исходного кода, создаваемая лексическим анализатором (также называемым токенизатором). Имена, числа, строки, операторы, символы новой строки и подобные элементы представлены в виде токенов.

  Модуль `tokenize` предоставляет доступ к лексическому анализатору Python. Модуль `token` содержит информацию о различных типах токенов.

строка в тройных кавычках

  Строка, ограниченная тремя последовательными кавычками: либо двойными («), либо одинарными („). Хотя она не предоставляет никакой функциональности, недоступной для строк в одиночных кавычках, она полезна по нескольким причинам. Она позволяет включать в строку неэкранированные одинарные и двойные кавычки, а также может занимать несколько строк без использования символа продолжения, что делает её особенно полезной при написании строк документации.

тип

  Тип объекта Python определяет, к какому виду объектов он относится; каждый объект имеет тип. Тип объекта доступен через его атрибут `__class__` или может быть получен с помощью функции `type(obj)`.

псевдоним типа

  Синоним типа, созданный путём присваивания типа идентификатору.

  Псевдонимы типов полезны для упрощения подсказок типов. Например:

      def remove_gray_shades(
              colors: list[tuple[int, int, int]]) -> list[tuple[int, int, int]]:
          pass

  можно сделать более читабельным следующим образом:

      Color = tuple[int, int, int]

      def remove_gray_shades(colors: list[Color]) -> list[Color]:
          pass

  См. `typing` и PEP 484, в которых описана эта возможность.

подсказка типа

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

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

  Подсказки типов глобальных переменных, атрибутов классов и функций, но не локальных переменных, можно получить с помощью функции `typing.get_type_hints()`.

  См. `typing` и PEP 484, в которых описана эта возможность.

универсальные переводы строк

  Способ интерпретации текстовых потоков, при котором все следующие последовательности распознаются как обозначающие конец строки: соглашение Unix о конце строки `'\n'`, соглашение Windows `'\r\n'` и старое соглашение Macintosh `'\r'`. См. PEP 278 и PEP 3116, а также `bytes.splitlines()` для дополнительного применения.

аннотация переменной

  Аннотация переменной или атрибута класса.

  При аннотировании переменной или атрибута класса присваивание является необязательным:

      class C:
          field: 'annotation'

  Аннотации переменных обычно используются для подсказок типов: например, ожидается, что эта переменная будет принимать значения типа `int`:

      count: int = 0

  Синтаксис аннотаций переменных описан в разделе Аннотированные инструкции присваивания.

  См. аннотация функции, PEP 484 и PEP 526, которые описывают эту функциональность. См. также Annotations Best Practices для получения рекомендаций по работе с аннотациями.

виртуальное окружение

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

  См. также `venv`.

виртуальная машина

  Компьютер, полностью реализованный программным обеспечением. Виртуальная машина Python выполняет байт-код, созданный компилятором байт-кода.

моржовый оператор

  Неформальный способ назвать оператор `:=` в выражении присваивания , поскольку он немного похож на моржа, если наклонить голову.

Дзен Python

  Список принципов проектирования и философских положений Python, которые помогают понимать и использовать язык. Этот список можно получить, набрав «`import this`» в интерактивной оболочке.