> **Источник:** https://python-all.ru/3.2/glossary.html
>
> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.

---

# Глоссарий

**`>>>`**

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

**`...`**

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

**2to3**

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

2to3 доступен в стандартной библиотеке как [`lib2to3`](https://python-all.ru/3.2/library/2to3.html#module-lib2to3); отдельная точка входа предоставляется как `Tools/scripts/2to3`. См. [*2to3 – автоматическое преобразование кода Python 2 в 3*](https://python-all.ru/3.2/library/2to3.html#to3-reference).

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

Абстрактные базовые классы дополняют

[*утиную типизацию*](https://python-all.ru/3.2/glossary.html#term-duck-typing)

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

[`hasattr()`](https://python-all.ru/3.2/library/functions.html#hasattr)

, были бы неудобны или незаметно ошибочны (например, с

[*магическими методами*](https://python-all.ru/3.2/reference/datamodel.html#special-lookup)

). ABC вводят виртуальные подклассы – классы, которые не наследуют от класса, но всё равно распознаются функциями

[`isinstance()`](https://python-all.ru/3.2/library/functions.html#isinstance)

и

[`issubclass()`](https://python-all.ru/3.2/library/functions.html#issubclass)

; см. документацию модуля

[`abc`](https://python-all.ru/3.2/library/abc.html#module-abc)

. В Python есть много встроенных ABC для структур данных (в модуле

[`collections`](https://python-all.ru/3.2/library/collections.html#module-collections)

), чисел (в модуле

[`numbers`](https://python-all.ru/3.2/library/numbers.html#module-numbers)

), потоков (в модуле

[`io`](https://python-all.ru/3.2/library/io.html#module-io)

), искателей импортов и загрузчиков (в модуле

[`importlib.abc`](https://python-all.ru/3.2/library/importlib.html#module-importlib.abc)

). Вы можете создавать собственные ABC с помощью модуля

[`abc`](https://python-all.ru/3.2/library/abc.html#module-abc)

.

**аргумент**

Значение, передаваемое в [*функцию*](https://python-all.ru/3.2/glossary.html#term-function) (или [*метод*](https://python-all.ru/3.2/glossary.html#term-method)) при её вызове. Существует два типа аргументов:

- *Именованный аргумент*: аргумент, перед которым стоит идентификатор (например, `name=`) в вызове функции или переданный как значение в словаре, перед которым стоит `**`. Например, `3` и `5` являются именованными аргументами в следующих вызовах [`complex()`](https://python-all.ru/3.2/library/functions.html#complex):

  ```python
  complex(real=3, imag=5)
  complex(**{'real': 3, 'imag': 5})
  ```
- *позиционный аргумент*: аргумент, не являющийся именованным. Позиционные аргументы могут находиться в начале списка аргументов и/или передаваться как элементы [*итерируемого объекта*](https://python-all.ru/3.2/glossary.html#term-iterable) перед `*`. Например, `3` и `5` оба являются позиционными аргументами в следующих вызовах:

  ```python
  complex(3, 5)
  complex(*(3, 5))
  ```

Аргументы присваиваются именованным локальным переменным в теле функции. См. раздел [*Вызовы*](https://python-all.ru/3.2/reference/expressions.html#calls) для правил, регулирующих это присваивание. Синтаксически для представления аргумента можно использовать любое выражение; вычисленное значение присваивается локальной переменной.

См. также запись глоссария [*параметр*](https://python-all.ru/3.2/glossary.html#term-parameter), вопрос FAQ о [*различии между аргументами и параметрами*](https://python-all.ru/3.2/faq/programming.html#faq-argument-vs-parameter), и [**PEP 362**](https://python-all.ru/3.2/glossary.html).

**атрибут**

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

*o*

имеет атрибут

*a*

, на него можно сослаться как

*o.a*

.

**BDFL**

Доброжелательный диктатор на всю жизнь, также известный как

[Гвидо ван Россум](https://python-all.ru/3.2/glossary.html)

, создатель Python.

**байткод**

Исходный код Python компилируется в байт-код – внутреннее представление программы на Python в интерпретаторе CPython. Байт-код также кэшируется в файлах `.pyc` и `.pyo`, чтобы повторное выполнение того же файла было быстрее (перекомпиляцию из исходного кода в байт-код можно избежать). Этот «промежуточный язык» выполняется на [*виртуальной машине*](https://python-all.ru/3.2/glossary.html#term-virtual-machine), которая исполняет машинный код, соответствующий каждому байт-коду. Обратите внимание, что байт-коды не должны работать между разными виртуальными машинами Python, ни быть стабильными между версиями Python.

Список инструкций байткода можно найти в документации [*модуля dis*](https://python-all.ru/3.2/library/dis.html#bytecodes).

**класс**

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

**приведение типов**

Неявное преобразование экземпляра одного типа в другой во время операции, включающей два аргумента одного типа. Например,

`int(3.15)`

преобразует число с плавающей запятой в целое число

`3`

, но в

`3+4.5`

каждый аргумент имеет разный тип (один int, другой float), и оба должны быть преобразованы в один и тот же тип, прежде чем их можно будет сложить, иначе будет возбуждено

`TypeError`

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

`float(3)+4.5`

, а не просто

`3+4.5`

.

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

Расширение привычной системы действительных чисел, в котором все числа выражаются как сумма действительной и мнимой части. Мнимые числа – это действительные кратные мнимой единицы (квадратный корень из

`-1`

), часто записываемой как

`i`

в математике или

`j`

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

`j`

, например,

`3+1j`

. Для доступа к комплексным аналогам модуля

[`math`](https://python-all.ru/3.2/library/math.html#module-math)

используйте

[`cmath`](https://python-all.ru/3.2/library/cmath.html#module-cmath)

. Использование комплексных чисел – довольно продвинутая математическая возможность. Если вы не осознаёте необходимости в них, почти наверняка их можно безопасно игнорировать.

**контекстный менеджер**

Объект, который управляет окружением, видимым в операторе

[`with`](https://python-all.ru/3.2/reference/compound_stmts.html#with)

, определяя методы

[`__enter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__enter__)

и

[`__exit__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__exit__)

. См.

[**PEP 343**](https://python-all.ru/3.2/glossary.html)

.

**CPython**

Каноническая реализация языка программирования Python, распространяемая на

[python.org](https://python-all.ru/3.2/glossary.html)

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

**декоратор**

Функция, возвращающая другую функцию, обычно применяемая как преобразование функции с использованием синтаксиса `@wrapper`. Распространённые примеры декораторов: [`classmethod()`](https://python-all.ru/3.2/library/functions.html#classmethod) и [`staticmethod()`](https://python-all.ru/3.2/library/functions.html#staticmethod).

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

```python
def f(...):
    ...
f = staticmethod(f)

@staticmethod
def f(...):
    ...
```

Та же концепция существует и для классов, но там используется реже. См. документацию по [*определениям функций*](https://python-all.ru/3.2/reference/compound_stmts.html#function) и [*определениям классов*](https://python-all.ru/3.2/reference/compound_stmts.html#class) для получения дополнительной информации о декораторах.

**дескриптор**

Любой объект, который определяет методы [`__get__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__get__), [`__set__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__set__) или [`__delete__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__delete__). Когда атрибут класса является дескриптором, его специальное поведение связывания срабатывает при поиске атрибута. Обычно использование *a.b* для получения, установки или удаления атрибута ищет объект с именем *b* в словаре класса для *a*, но если *b* является дескриптором, вызывается соответствующий метод дескриптора. Понимание дескрипторов – ключ к глубокому пониманию Python, потому что они являются основой многих возможностей, включая функции, методы, свойства, методы класса, статические методы и ссылки на суперклассы.

Подробнее о методах дескрипторов см. в [*Implementing Descriptors*](https://python-all.ru/3.2/reference/datamodel.html#descriptors).

**словарь**

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

[`__hash__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__hash__)

и

[`__eq__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__eq__)

. В Perl называется хешем.

**докстринг**

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

`__doc__`

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

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

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

[`type()`](https://python-all.ru/3.2/library/functions.html#type)

или

[`isinstance()`](https://python-all.ru/3.2/library/functions.html#isinstance)

. (Однако обратите внимание, что утиную типизацию можно дополнить

[*абстрактными базовыми классами*](https://python-all.ru/3.2/glossary.html#term-abstract-base-class)

.) Вместо этого она обычно использует проверки

[`hasattr()`](https://python-all.ru/3.2/library/functions.html#hasattr)

или программирование в стиле

[*EAFP*](https://python-all.ru/3.2/glossary.html#term-eafp)

.

**EAFP**

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

[`try`](https://python-all.ru/3.2/reference/compound_stmts.html#try)

и

[`except`](https://python-all.ru/3.2/reference/compound_stmts.html#except)

. Этот подход контрастирует со стилем

[*LBYL*](https://python-all.ru/3.2/glossary.html#term-lbyl)

, распространённым во многих других языках, таких как C.

**выражение**

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

[*инструкции*](https://python-all.ru/3.2/glossary.html#term-statement)

, которые нельзя использовать как выражения, например

[`if`](https://python-all.ru/3.2/reference/compound_stmts.html#if)

. Присваивания также являются инструкциями, а не выражениями.

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

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

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

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

На самом деле существует три категории файловых объектов: необработанные двоичные файлы, буферизованные двоичные файлы и текстовые файлы. Их интерфейсы определены в модуле [`io`](https://python-all.ru/3.2/library/io.html#module-io). Канонический способ создания файлового объекта – использование функции [`open()`](https://python-all.ru/3.2/library/functions.html#open).

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

Синоним для

[*файлового объекта*](https://python-all.ru/3.2/glossary.html#term-file-object)

.

**искатель**

Объект, который пытается найти

[*загрузчик*](https://python-all.ru/3.2/glossary.html#term-loader)

для модуля. Он должен реализовывать метод с именем

`find_module()`

. См.

[**PEP 302**](https://python-all.ru/3.2/glossary.html)

для подробностей и

[`importlib.abc.Finder`](https://python-all.ru/3.2/library/importlib.html#importlib.abc.Finder)

для

[*абстрактного базового класса*](https://python-all.ru/3.2/glossary.html#term-abstract-base-class)

.

**целочисленное деление**

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

`//`

. Например, выражение

`11 // 4`

вычисляется в

`2`

в отличие от

`2.75`

, возвращаемого при истинном делении с плавающей запятой. Обратите внимание, что

`(-11) // 4`

равно

`-3`

, потому что это

`-2.75`

, округлённое

*вниз*

. См.

[**PEP 238**](https://python-all.ru/3.2/glossary.html)

.

**функция**

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

[*аргументов*](https://python-all.ru/3.2/glossary.html#term-argument)

, которые могут использоваться при выполнении тела. См. также

[*параметр*](https://python-all.ru/3.2/glossary.html#term-parameter)

,

[*метод*](https://python-all.ru/3.2/glossary.html#term-method)

, и раздел

[*Определения функций*](https://python-all.ru/3.2/reference/compound_stmts.html#function)

.

**future**

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

Импортировав модуль [`__future__`](https://python-all.ru/3.2/library/__future__.html#module-__future__) и вычислив его переменные, можно увидеть, когда новая возможность была впервые добавлена в язык и когда она стала поведением по умолчанию:

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

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

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

**генератор**

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

[`yield`](https://python-all.ru/3.2/reference/simple_stmts.html#yield)

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

[`next()`](https://python-all.ru/3.2/library/functions.html#next)

. Каждый

[`yield`](https://python-all.ru/3.2/reference/simple_stmts.html#yield)

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

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

Выражение, которое возвращает итератор. Оно выглядит как обычное выражение, за которым следует выражение [`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for), определяющее переменную цикла, диапазон и необязательное выражение [`if`](https://python-all.ru/3.2/reference/compound_stmts.html#if). Комбинированное выражение генерирует значения для внешней функции:

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

**GIL**

См.

[*глобальная блокировка интерпретатора*](https://python-all.ru/3.2/glossary.html#term-global-interpreter-lock)

.

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

Механизм, используемый интерпретатором [*CPython*](https://python-all.ru/3.2/glossary.html#term-cpython), чтобы гарантировать, что только один поток выполняет [*байткод Python*](https://python-all.ru/3.2/glossary.html#term-bytecode) в один момент времени. Это упрощает реализацию CPython, делая объектную модель (включая критически важные встроенные типы, такие как [`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict)) неявно безопасной для конкурентного доступа. Блокировка всего интерпретатора облегчает его многопоточность, но ценой потери большей части параллелизма, который могли бы дать многопроцессорные машины.

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

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

**хешируемый**

Объект является *хэшируемым*, если у него есть хэш-значение, которое никогда не меняется в течение его жизни (нужен метод [`__hash__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__hash__)), и его можно сравнивать с другими объектами (нужен метод [`__eq__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__eq__)). Хэшируемые объекты, которые сравниваются как равные, должны иметь одинаковое хэш-значение.

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

Все неизменяемые встроенные объекты Python хешируемы, а изменяемые контейнеры (например, списки или словари) – нет. Объекты, являющиеся экземплярами пользовательских классов, по умолчанию хешируемы; все они сравниваются неравными (кроме сравнения с самими собой), и их хеш-значение равно [`id()`](https://python-all.ru/3.2/library/functions.html#id).

**IDLE**

Интегрированная среда разработки для Python. IDLE – это базовый редактор и среда интерпретатора, которая поставляется со стандартной дистрибуцией Python.

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

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

**импортёр**

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

[*искателем*](https://python-all.ru/3.2/glossary.html#term-finder)

, так и

[*загрузчиком*](https://python-all.ru/3.2/glossary.html#term-loader)

.

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

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

`python`

без аргументов (возможно, выбрав его из главного меню компьютера). Это очень удобный способ опробовать новые идеи или изучить модули и пакеты (вспомните

`help(x)`

).

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

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

[*интерактивный*](https://python-all.ru/3.2/glossary.html#term-interactive)

.

**итерируемый объект**

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

[`list`](https://python-all.ru/3.2/library/functions.html#list)

,

[`str`](https://python-all.ru/3.2/library/functions.html#str)

, и

[`tuple`](https://python-all.ru/3.2/library/functions.html#tuple)

), а также некоторые непоследовательные типы, например

[`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict)

,

[*файловые объекты*](https://python-all.ru/3.2/glossary.html#term-file-object)

и объекты любых классов, для которых вы определили методы

[`__iter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__iter__)

или

[`__getitem__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getitem__)

. Итерируемые объекты можно использовать в цикле

[`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for)

и во многих других местах, где требуется последовательность (

[`zip()`](https://python-all.ru/3.2/library/functions.html#zip)

,

[`map()`](https://python-all.ru/3.2/library/functions.html#map)

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

[`iter()`](https://python-all.ru/3.2/library/functions.html#iter)

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

[`iter()`](https://python-all.ru/3.2/library/functions.html#iter)

или самостоятельно работать с объектами итераторов. Инструкция

`for`

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

[*итератор*](https://python-all.ru/3.2/glossary.html#term-iterator)

,

[*последовательность*](https://python-all.ru/3.2/glossary.html#term-sequence)

и

[*генератор*](https://python-all.ru/3.2/glossary.html#term-generator)

.

**итератор**

Объект, представляющий поток данных. Повторные вызовы метода [`__next__()`](https://python-all.ru/3.2/library/stdtypes.html#iterator.__next__) итератора (или передача его встроенной функции [`next()`](https://python-all.ru/3.2/library/functions.html#next)) возвращают последовательные элементы потока. Когда данные заканчиваются, вместо них возбуждается исключение [`StopIteration`](https://python-all.ru/3.2/library/exceptions.html#StopIteration). После этого итератор считается исчерпанным, и любые дальнейшие вызовы его метода `__next__()` будут снова возбуждать [`StopIteration`](https://python-all.ru/3.2/library/exceptions.html#StopIteration). Итераторы должны иметь метод [`__iter__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__iter__), который возвращает сам объект итератора, так что каждый итератор также является итерируемым объектом и может использоваться в большинстве мест, где принимаются другие итерируемые объекты. Одним заметным исключением является код, пытающийся выполнить несколько проходов по итерации. Объект-контейнер (например, [`list`](https://python-all.ru/3.2/library/functions.html#list)) создаёт новый свежий итератор каждый раз, когда вы передаёте его функции [`iter()`](https://python-all.ru/3.2/library/functions.html#iter) или используете в цикле [`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for). Попытка сделать то же самое с итератором просто вернёт тот же самый исчерпанный итератор, который использовался в предыдущем проходе, из-за чего он будет выглядеть как пустой контейнер.

Дополнительную информацию можно найти в [*Iterator Types*](https://python-all.ru/3.2/library/stdtypes.html#typeiter).

**функция ключа**

Ключевая функция (или функция сравнения) – это вызываемый объект, возвращающий значение, используемое для сортировки или упорядочивания. Например, [`locale.strxfrm()`](https://python-all.ru/3.2/library/locale.html#locale.strxfrm) используется для получения ключа сортировки, учитывающего правила сортировки, зависящие от локали.

Ряд инструментов в Python принимают функции-ключи для управления порядком или группировкой элементов. К ним относятся [`min()`](https://python-all.ru/3.2/library/functions.html#min), [`max()`](https://python-all.ru/3.2/library/functions.html#max), [`sorted()`](https://python-all.ru/3.2/library/functions.html#sorted), `list.sort()`, [`heapq.nsmallest()`](https://python-all.ru/3.2/library/heapq.html#heapq.nsmallest), [`heapq.nlargest()`](https://python-all.ru/3.2/library/heapq.html#heapq.nlargest) и [`itertools.groupby()`](https://python-all.ru/3.2/library/itertools.html#itertools.groupby).

Существует несколько способов создания ключевой функции. Например, метод [`str.lower()`](https://python-all.ru/3.2/library/stdtypes.html#str.lower) может служить ключевой функцией для сортировки без учёта регистра. Кроме того, специальную ключевую функцию можно построить из [`lambda`](https://python-all.ru/3.2/reference/expressions.html#lambda)-выражения, например `lambda r: (r[0], r[2])`. Также модуль [`operator`](https://python-all.ru/3.2/library/operator.html#module-operator) предоставляет три конструктора ключевых функций: [`attrgetter()`](https://python-all.ru/3.2/library/operator.html#operator.attrgetter), [`itemgetter()`](https://python-all.ru/3.2/library/operator.html#operator.itemgetter) и [`methodcaller()`](https://python-all.ru/3.2/library/operator.html#operator.methodcaller). См. [*Руководство по сортировке*](https://python-all.ru/3.2/howto/sorting.html#sortinghowto) с примерами создания и использования ключевых функций.

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

См.

[*аргумент*](https://python-all.ru/3.2/glossary.html#term-argument)

.

**лямбда**

Анонимная встроенная функция, состоящая из одного

[*выражения*](https://python-all.ru/3.2/glossary.html#term-expression)

, которое вычисляется при вызове функции. Синтаксис создания лямбда-функции:

`lambda [аргументы]: выражение`

**LBYL**

Сначала подумай, потом делай (Look before you leap). Этот стиль кодирования явно проверяет предусловия перед выполнением вызовов или поиском. Этот стиль противопоставляется подходу [*EAFP*](https://python-all.ru/3.2/glossary.html#term-eafp) и характеризуется наличием множества инструкций [`if`](https://python-all.ru/3.2/reference/compound_stmts.html#if).

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

**список**

Встроенная в Python

[*последовательность*](https://python-all.ru/3.2/glossary.html#term-sequence)

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

**генератор списка**

Компактный способ обработать все или часть элементов последовательности и вернуть список с результатами.

`result = ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]`

генерирует список строк, содержащих чётные шестнадцатеричные числа (0x..) в диапазоне от 0 до 255. Часть

[`if`](https://python-all.ru/3.2/reference/compound_stmts.html#if)

необязательна. Если её опустить, обрабатываются все элементы из

`range(256)`

.

**загрузчик**

Объект, который загружает модуль. Должен определять метод

`load_module()`

. Загрузчик обычно возвращается

[*искателем*](https://python-all.ru/3.2/glossary.html#term-finder)

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

[**PEP 302**](https://python-all.ru/3.2/glossary.html)

и

[`importlib.abc.Loader`](https://python-all.ru/3.2/library/importlib.html#importlib.abc.Loader)

в качестве

[*абстрактного базового класса*](https://python-all.ru/3.2/glossary.html#term-abstract-base-class)

.

**отображение**

Объект-контейнер, поддерживающий произвольный поиск по ключу и реализующий методы, указанные в

[`Mapping`](https://python-all.ru/3.2/library/collections.html#collections.Mapping)

или

[`MutableMapping`](https://python-all.ru/3.2/library/collections.html#collections.MutableMapping)

[*абстрактных базовых классах*](https://python-all.ru/3.2/library/collections.html#collections-abstract-base-classes)

. Примеры включают

[`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict)

,

[`collections.defaultdict`](https://python-all.ru/3.2/library/collections.html#collections.defaultdict)

,

[`collections.OrderedDict`](https://python-all.ru/3.2/library/collections.html#collections.OrderedDict)

и

[`collections.Counter`](https://python-all.ru/3.2/library/collections.html#collections.Counter)

.

**метакласс**

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

Дополнительную информацию можно найти в [*Настройка создания классов*](https://python-all.ru/3.2/reference/datamodel.html#metaclasses).

**метод**

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

[*аргумента*](https://python-all.ru/3.2/glossary.html#term-argument)

(который обычно называется

`self`

). См. также

[*функция*](https://python-all.ru/3.2/glossary.html#term-function)

и

[*вложенная область видимости*](https://python-all.ru/3.2/glossary.html#term-nested-scope)

.

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

Порядок разрешения методов (Method Resolution Order) – это порядок, в котором базовые классы просматриваются при поиске члена класса. См.

[The Python 2.3 Method Resolution Order](https://python-all.ru/3.2/glossary.html)

.

**MRO**

См.

[*порядок разрешения методов*](https://python-all.ru/3.2/glossary.html#term-method-resolution-order)

.

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

Изменяемые объекты могут менять своё значение, сохраняя свой

[`id()`](https://python-all.ru/3.2/library/functions.html#id)

. См. также

[*неизменяемый*](https://python-all.ru/3.2/glossary.html#term-immutable)

.

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

Любой класс, подобный кортежу, индексируемые элементы которого также доступны через именованные атрибуты (например, [`time.localtime()`](https://python-all.ru/3.2/library/time.html#time.localtime) возвращает подобный кортежу объект, в котором *year* доступен либо по индексу, например `t[0]`, либо через именованный атрибут, например `t.tm_year`).

Именованный кортеж может быть встроенным типом, например [`time.struct_time`](https://python-all.ru/3.2/library/time.html#time.struct_time), или может быть создан с помощью обычного определения класса. Полнофункциональный именованный кортеж также можно создать с помощью фабричной функции [`collections.namedtuple()`](https://python-all.ru/3.2/library/collections.html#collections.namedtuple). Последний подход автоматически предоставляет дополнительные возможности, такие как самодокументируемое представление, например `Employee(name='jones', title='programmer')`.

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

Место, где хранится переменная. Пространства имён реализованы в виде словарей. Существуют локальное, глобальное и встроенное пространства имён, а также вложенные пространства имён в объектах (в методах). Пространства имён поддерживают модульность, предотвращая конфликты имён. Например, функции

`builtins.open()`

и

[`os.open()`](https://python-all.ru/3.2/library/os.html#os.open)

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

[`random.seed()`](https://python-all.ru/3.2/library/random.html#random.seed)

или

[`itertools.islice()`](https://python-all.ru/3.2/library/itertools.html#itertools.islice)

показывает, что эти функции реализованы модулями

[`random`](https://python-all.ru/3.2/library/random.html#module-random)

и

[`itertools`](https://python-all.ru/3.2/library/itertools.html#module-itertools)

соответственно.

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

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

[`nonlocal`](https://python-all.ru/3.2/reference/simple_stmts.html#nonlocal)

позволяет выполнять запись во внешние области видимости.

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

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

`__slots__`

, дескрипторы, свойства,

[`__getattribute__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getattribute__)

, методы класса и статические методы.

**объект**

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

[*класса нового стиля*](https://python-all.ru/3.2/glossary.html#term-new-style-class)

.

**параметр**

Именованная сущность в определении [*функции*](https://python-all.ru/3.2/glossary.html#term-function) (или метода), которая указывает на [*аргумент*](https://python-all.ru/3.2/glossary.html#term-argument) (или в некоторых случаях аргументы), который может принимать функция. Существует пять типов параметров:

- *позиционный или ключевой*: указывает аргумент, который может быть передан либо [*позиционно*](https://python-all.ru/3.2/glossary.html#term-argument), либо в качестве [*ключевого аргумента*](https://python-all.ru/3.2/glossary.html#term-argument). Это вид параметра по умолчанию, например *foo* и *bar* в следующем примере:

  ```python
  def func(foo, bar=None): ...
  ```
- *Только для позиционной передачи*: указывает аргумент, который может быть передан только по позиции. В Python нет синтаксиса для определения параметров только для позиционной передачи. Однако некоторые встроенные функции имеют такие параметры (например, [`abs()`](https://python-all.ru/3.2/library/functions.html#abs)).
- *только ключевой*: указывает аргумент, который может быть передан только по ключевому слову. Параметры только по ключевым словам можно определить, включив один вариативно-позиционный параметр или просто `*` в список параметров определения функции перед ними, например *kw\_only1* и *kw\_only2* в следующем примере:

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

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

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

См. также глоссарий [*аргумент*](https://python-all.ru/3.2/glossary.html#term-argument), вопрос из FAQ о [*разнице между аргументами и параметрами*](https://python-all.ru/3.2/faq/programming.html#faq-argument-vs-parameter), класс `inspect.Parameter`, раздел [*Определения функций*](https://python-all.ru/3.2/reference/compound_stmts.html#function) и [**PEP 362**](https://python-all.ru/3.2/glossary.html).

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

См.

[*аргумент*](https://python-all.ru/3.2/glossary.html#term-argument)

.

**Python 3000**

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

**Питоничный**

Идея или фрагмент кода, который тесно следует наиболее распространённым идиомам языка Python, а не использует концепции, общие для других языков. Например, распространённая идиома в Python – перебор всех элементов итерируемого объекта с помощью оператора [`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for). Во многих других языках такой конструкции нет, поэтому люди, не знакомые с Python, иногда используют числовой счётчик:

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

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

```python
for piece in food:
    print(piece)
```

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

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

[*CPython*](https://python-all.ru/3.2/glossary.html#term-cpython)

. Модуль

[`sys`](https://python-all.ru/3.2/library/sys.html#module-sys)

определяет функцию

[`getrefcount()`](https://python-all.ru/3.2/library/sys.html#sys.getrefcount)

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

**slots**

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

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

[*Итерируемый объект*](https://python-all.ru/3.2/glossary.html#term-iterable)

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

[`__getitem__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getitem__)

и определяет метод

[`__len__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__len__)

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

[`list`](https://python-all.ru/3.2/library/functions.html#list)

,

[`str`](https://python-all.ru/3.2/library/functions.html#str)

,

[`tuple`](https://python-all.ru/3.2/library/functions.html#tuple)

и

[`bytes`](https://python-all.ru/3.2/library/functions.html#bytes)

. Обратите внимание, что

[`dict`](https://python-all.ru/3.2/library/stdtypes.html#dict)

тоже поддерживает

[`__getitem__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__getitem__)

и

[`__len__()`](https://python-all.ru/3.2/reference/datamodel.html#object.__len__)

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

[*неизменяемые*](https://python-all.ru/3.2/glossary.html#term-immutable)

ключи, а не целые числа.

**срез**

Объект, обычно содержащий часть

[*последовательности*](https://python-all.ru/3.2/glossary.html#term-sequence)

. Срез создаётся с помощью синтаксиса индексации,

`[]`

с двоеточиями между числами, если указано несколько, как в

`variable_name[1:3:5]`

. Синтаксис квадратных скобок (индексации) внутри использует объекты

[`slice`](https://python-all.ru/3.2/library/functions.html#slice)

.

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

A method that is called implicitly by Python to execute a certain operation on a type, such as addition. Such methods have names starting and ending with double underscores. Special methods are documented in

[*Special method names*](https://python-all.ru/3.2/reference/datamodel.html#specialnames)

.

**инструкция**

Инструкция (statement) – это часть блока (блока кода). Инструкцией является либо

[*выражение*](https://python-all.ru/3.2/glossary.html#term-expression)

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

[`if`](https://python-all.ru/3.2/reference/compound_stmts.html#if)

,

[`while`](https://python-all.ru/3.2/reference/compound_stmts.html#while)

или

[`for`](https://python-all.ru/3.2/reference/compound_stmts.html#for)

.

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

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

**тип**

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

`__class__`

или может быть получен с помощью

`type(obj)`

.

**универсальные символы новой строки**

A manner of interpreting text streams in which all of the following are recognized as ending a line: the Unix end-of-line convention

`'\n'`

, the Windows convention

`'\r\n'`

, and the old Macintosh convention

`'\r'`

. See

[**PEP 278**](https://python-all.ru/3.2/glossary.html)

and

[**PEP 3116**](https://python-all.ru/3.2/glossary.html)

, as well as

[`str.splitlines()`](https://python-all.ru/3.2/library/stdtypes.html#str.splitlines)

for an additional use.

**представление**

Объекты, возвращаемые

[`dict.keys()`](https://python-all.ru/3.2/library/stdtypes.html#dict.keys)

,

[`dict.values()`](https://python-all.ru/3.2/library/stdtypes.html#dict.values)

и

[`dict.items()`](https://python-all.ru/3.2/library/stdtypes.html#dict.items)

, называются представлениями словаря. Это ленивые последовательности, которые видят изменения в базовом словаре. Чтобы принудительно преобразовать представление словаря в полноценный список, используйте

`list(dictview)`

. См.

[*Объекты представления словаря*](https://python-all.ru/3.2/library/stdtypes.html#dict-views)

.

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

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

[*байт-код*](https://python-all.ru/3.2/glossary.html#term-bytecode)

, генерируемый компилятором байт-кода.

**Дзен Python**

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

`import this`

».