# Встроенные функции

Интерпретатор Python имеет ряд встроенных функций и типов, которые всегда доступны. Они перечислены здесь в алфавитном порядке.

Встроенные функции
A `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` B `bin()` `bool()` `breakpoint()` `bytearray()` `bytes()` C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` `dict()` `dir()` `divmod()` | E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` `frozenset()` G `getattr()` `globals()` H `hasattr()` `hash()` `help()` `hex()` I `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()` | L `len()` `list()` `locals()` M `map()` `max()` `memoryview()` `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()` | R `range()` `repr()` `reversed()` `round()` S `set()` `setattr()` `slice()` `sorted()` `staticmethod()` `str()` `sum()` `super()` T `tuple()` `type()` V `vars()` Z `zip()` _ `__import__()`

abs(number, /)

  Возвращает абсолютное значение number. Аргумент может быть целым числом, числом с плавающей точкой или объектом, реализующим `__abs__()`. Если аргумент является комплексным числом, возвращается его модуль.

aiter(async_iterable, /)

  Возвращает асинхронный итератор для :term:` асинхронного итерируемого объекта`. Эквивалентно вызову `x.__aiter__()`.

  Примечание: В отличие от `iter()`, у `aiter()` нет варианта с двумя аргументами.

  Добавлено в версии 3.10.

all(iterable, /)

  Возвращает `True`, если все элементы iterable истинны (или если iterable пустой). Эквивалентно:

      def all(iterable):
          for element in iterable:
              if not element:
                  return False
          return True

awaitable anext(async_iterator, /)
awaitable anext(async_iterator, default, /)

  При ожидании возвращает следующий элемент указанного асинхронного итератора, или default, если он передан и итератор исчерпан.

  Это асинхронный вариант встроенной функции `next()` и ведёт себя аналогично.

  Вызывает метод `__anext__()` у async_iterator, возвращая awaitable. При ожидании возвращается следующее значение итератора. Если default задан, то он возвращается, если итератор исчерпан, в противном случае возбуждается исключение `StopAsyncIteration`.

  Добавлено в версии 3.10.

any(iterable, /)

  Возвращает `True`, если любой элемент iterable истинный. Если iterable пуст, возвращает `False`. Эквивалентно:

      def any(iterable):
          for element in iterable:
              if element:
                  return True
          return False

ascii(object, /)

  Как и `repr()`, возвращает строку с представлением object, пригодным для печати, но экранирует не-ASCII символы в строке, возвращаемой `repr()`, с помощью `\x`, `\u` или `\U` последовательностей. Это генерирует строку, аналогичную той, которую возвращает `repr()` в Python 2.

bin(integer, /)

  Преобразует целое число в строку с его двоичным представлением и префиксом «0b». Результат является корректным выражение Python. Если integer не является `int`, он должен определять метод `__index__()`, возвращающий целое число. Примеры:

      >>> bin(3)
      '0b11'
      >>> bin(-10)
      '-0b1010'

  В зависимости от необходимости префикса «0b», вы можете использовать любой из следующих способов.

      >>> format(14, '#b'), format(14, 'b')
      ('0b1110', '1110')
      >>> f'{14:#b}', f'{14:b}'
      ('0b1110', '1110')

  См. также `enum.bin()` для представления отрицательных значений в дополнительном коде.

  См. также `format()` для получения дополнительной информации.

class bool(object=False, /)

  Возвращает логическое значение, т. е. одно из значений — `True` или `False`. Аргумент преобразуется с использованием стандартной процедуры проверки истинности. Если аргумент ложный или опущен, возвращается `False`; в противном случае возвращается `True`. Класс `bool` является подклассом `int` (см. Numeric Types — int, float, complex). От него нельзя создавать производные классы дальше. Его единственными экземплярами являются `False` и `True` (см. Boolean Type - bool).

  Изменено в версии 3.7: Параметр теперь является только позиционным.

breakpoint(*args, **kws)

  Эта функция останавливает выполнение и переводит вас в отладчик в месте вызова. Точнее, вызывается `sys.breakpointhook()`, которому передаются без изменений `args` и `kws`. По умолчанию `sys.breakpointhook()` вызывает `pdb.set_trace()`, не ожидая никаких аргументов. В этом случае функция служит удобным сокращением, чтобы не импортировать `pdb` и не писать больше кода для входа в отладчик. Однако `sys.breakpointhook()` можно связать с какой-либо другой функцией, и тогда `breakpoint()` автоматически вызовет её, позволяя вам перейти в выбранный отладчик. Если `sys.breakpointhook()` недоступна, возбудится исключение `RuntimeError`.

  По умолчанию поведение функции `breakpoint()` может быть изменено с помощью переменной окружения `PYTHONBREAKPOINT`. См. подробности использования в `sys.breakpointhook()`.

  Обратите внимание, что это не гарантируется, если `sys.breakpointhook()` была заменена.

  Возбуждает событие аудита `builtins.breakpoint` с аргументом `breakpointhook`.

  Добавлено в версии 3.7.

class bytearray(source=b'')
class bytearray(source, encoding, errors='strict')

  Возвращает новый массив байтов. Класс `bytearray` является изменяемой последовательностью целых чисел в диапазоне 0 <= x < 256. Он имеет большинство обычных методов изменяемых последовательностей, описанных в Mutable Sequence Types, а также большинство методов, которые имеет тип `bytes`, см. Bytes and Bytearray Operations.

  Необязательный параметр source может быть использован для инициализации массива несколькими различными способами:

  - Если это строка, вы также должны указать параметр encoding (и, при необходимости, errors); затем `bytearray()` преобразует строку в байты с использованием `str.encode()`.

  - Если это целое число, массив будет иметь такой размер и будет инициализирован нулевыми байтами.

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

  - Если это итерируемый объект, он должен содержать целые числа в диапазоне `0 <= x < 256`, которые используются в качестве начального содержимого массива.

  Если аргумент не задан, создаётся массив размером 0.

  Смотрите также Binary Sequence Types — bytes, bytearray, memoryview и Bytearray Objects.

class bytes(source=b'')
class bytes(source, encoding, errors='strict')

  Возвращает новый объект «bytes», который является неизменяемой последовательностью целых чисел в диапазоне `0 <= x < 256`. `bytes` — это неизменяемая версия `bytearray`. Ему присущи те же методы, не изменяющие содержимое, и то же поведение при индексировании и срезах.

  Соответственно, аргументы конструктора интерпретируются так же, как и для `bytearray()`.

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

  См. также Binary Sequence Types — bytes, bytearray, memoryview, Bytes Objects и Bytes and Bytearray Operations.

callable(object, /)

  Возвращает `True`, если аргумент object является вызываемым, `False`, если нет. Если это возвращает `True`, всё равно возможно, что вызов завершится неудачей, но если это `False`, вызов object никогда не будет успешным. Обратите внимание, что классы являются вызываемыми (вызов класса возвращает новый экземпляр); экземпляры являются вызываемыми, если их класс имеет метод `__call__()`.

  Добавлено в версии 3.2: Эта функция была сперва удалена в Python 3.0, а затем восстановлена в Python 3.2.

chr(codepoint, /)

  Возвращает строку, представляющую символ с указанной кодовой позицией Unicode. Например, `chr(97)` возвращает строку `'a'`, а `chr(8364)` — строку `'€'`. Это обратная функция к `ord()`.

  Допустимый диапазон для аргумента составляет от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе счисления). Если значение вне этого диапазона, выбрасывается исключение `ValueError`.

@classmethod

  Преобразует метод в метод класса.

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

      class C:
          @classmethod
          def f(cls, arg1, arg2): ...

  Конутрукция `@classmethod` является формой вызова декоратора — см. Function definitions для подробностей.

  Метод класса можно вызвать как на самом классе (например, `C.f()`), так и на его экземпляре (например, `C().f()`). Во втором случае экземпляр игнорируется — используется только его класс. Если метод класса вызывается для производного класса, в качестве неявного первого аргумента передаётся объект производного класса.

  Методы класса отличаются от статических методов C++ или Java. Если вам нужны последние, см. `staticmethod()` в этом разделе. Дополнительную информацию о методах класса см. в Иерархия стандартных типов.

  Изменено в версии 3.9: Методы класса теперь могут оборачивать другие дескрипторы, такие как `property()`.

  Изменено в версии 3.10: Методы класса теперь наследуют атрибуты метода (`__module__`, `__name__`, `__qualname__`, `__doc__` и `__annotations__`) и имеют новый атрибут `__wrapped__`.

  Устарело с версии 3.11, удалено в версии 3.13: Методы класса больше не могут оборачивать другие дескрипторы, такие как `property()`.

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

  Компилирует source в код или объект AST. Объекты кода могут быть выполнены с помощью функций `exec()` или `eval()`. source может быть обычной строкой, байтовой строкой или объектом AST. См. документацию модуля `ast` для получения информации о работе с объектами AST.

  Аргумент filename должен содержать имя файла, из которого был прочитан код; передайте любое узнаваемое значение, если код не был прочитан из файла (обычно используется `'<string>'`).

  Аргумент mode определяет, какой тип кода должен быть скомпилирован; он может быть `'exec'`, если source состоит из последовательности инструкций, `'eval'`, если он состоит из одного выражения, или `'single'`, если он состоит из одной интерактивной инструкции (в последнем случае, инструкции выражений, которые вычисляются в нечто отличное от `None`, будут напечатаны).

  Необязательные аргументы flags и dont_inherit управляют активацией опций компилятора и разрешением новоых возможностей. Если оба они отсутствуют (или равны нулю), код компилируется с флагами, действующими в коде, вызывающем `compile()`. Если задан аргумент flags, а dont_inherit отсутствует (или равен нулю), то указанные опции компилятора и нового поведения добавляются к существующим. Если dont_inherit — ненулевое значение, то используется только flags, игнорируя опции окружающего кода.

  Опции компилятора и новые возможности задаются битами, которые можно объединять через побитовое OR. Битовое поле, необходимое для указания нужного нового поведения, можно найти в атрибуте `compiler_flag` экземпляра класса `_Feature` в модуле `__future__`. Флаги компилятора можно найти в модуле `ast` с префиксом `PyCF_`.

  Аргумент optimize определяет уровень оптимизации компилятора; значение по умолчанию `-1` выбирает уровень оптимизации интерпретатора, заданный опцией `-O`. Явные уровни: `0` (без оптимизации; `__debug__` истинен), `1` (удаляются assert, `__debug__` ложен) и `2` (строки документации также удаляются).

  Эта функция возбуждает исключения `SyntaxError` или `ValueError`, если исходный код для компиляции некорректен.

  Если вы хотите проанализировать Python-код и получить его представление в виде AST, см. `ast.parse()`.

  Возбуждает событие аудита `compile` с аргументами `source` и `filename`. Это событие также может быть вызвано неявной компиляцией.

  Примечание

  При компиляции строки с многострочным кодом в режимах `'single'` или `'eval'`, ввод должен заканчиваться хотя бы одним символом новой строки. Это необходимо для обнаружения неполных и полных инструкций в модуле `code`.

  Предупреждение

  Возможно вызвать сбой интерпретатора Python с помощью компиляции достаточно большой или сложной строки в объект AST из-за ограничений глубины стека в компиляторе AST Python’а.

  Изменено в версии 3.2: Разрешено использование новых строк Windows и Mac. Также, исходный код в режиме `'exec'` больше не обязан заканчиваться новой строкой. Добавлен параметр optimize.

  Изменено в версии 3.5: Ранее, при обнаружении нулевых байтов в source, возбуждалось исключение `TypeError`.

  Добавлено в версии 3.8: Опция `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` теперь может передаваться для включения на верхнем уровне поддержки `await`, `async for` и `async with`.

class complex(number=0, /)
class complex(string, /)
class complex(real=0, imag=0)

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

  Примеры:

      >>> complex('+1.23')
      (1.23+0j)
      >>> complex('-4.5j')
      -4.5j
      >>> complex('-1.23+4.5j')
      (-1.23+4.5j)
      >>> complex('\t( -1.23+4.5J )\n')
      (-1.23+4.5j)
      >>> complex('-Infinity+NaNj')
      (-inf+nanj)
      >>> complex(1.23)
      (1.23+0j)
      >>> complex(imag=-4.5)
      -4.5j
      >>> complex(-1.23, 4.5)
      (-1.23+4.5j)

  Если аргумент является строкой, он должен содержать либо действительную часть (в том же формате, что и для `float()`), либо мнимую часть (в том же формате, но с суфиксом `'j'` или `'J'`), либо как действительную, так и мнимую части (знак мнимой части в этом случае обязателен). При желании строка может быть окружена пробелами и круглыми скобками `'('` и `')'`, которые игнорируются. Строка не должна содержать пробелов между `'+'`, `'-'`, суффиксом `'j'` или `'J'` и десятичным числом. Например, `complex('1+2j')` подходит, но `complex('1 + 2j')` возбуждает исключение `ValueError`. Точнее, после удаления скобок и пробелов с обоих концов, строка должна соответствовать правилам `complexvalue` следующей грамматики:

      complexvalue ::= floatvalue |
                       floatvalue ("j" | "J") |
                       floatvalue sign absfloatvalue ("j" | "J")

  Если аргументом является число, конструктор выполняет числовое преобразование, аналогично `int` и `float`. Для произвольного объекта Python `x`, вызов `complex(x)` обращается к `x.__complex__()`. Если `__complex__()` не определён, то вызов передаётся к `__float__()`. Если `__float__()` не определён, то вызов передётся к `__index__()`.

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

  Если все аргументы опущены, возвращается `0j`.

  Описание комплексного типа приведено в Numeric Types — int, float, complex.

  Изменено в версии 3.6: Разрешена группировка цифр с использованием подчеркивания, как в коде литералов.

  Изменено в версии 3.8: Использование `__index__()`, если `__complex__()` и `__float__()` не определены.

delattr(object, name, /)

  Это родственник функции `setattr()`. Аргументы — это объект и строка. Строка должна быть именем одного из атрибутов объекта. Функция удаляет указанный атрибут, если объект это позволяет. Например, `delattr(x, 'foobar')` эквивалентно `del x.foobar`. name не обязательно должно быть идентификатором Python (см. `setattr()`).

class dict(**kwargs)
class dict(mapping, /, **kwargs)
class dict(iterable, /, **kwargs)

  Создаёт новый словарь. Объект `dict` является классом словаря. См. также Mapping Types — dict для получения документации по этому классу.

  For other containers see the built-in `list`, `set`, and `tuple` classes, as well as the `collections` module.

dir()
dir(object, /)

  Без аргументов возвращает список имён в текущей локальной области видимости. С аргументом попытается вернуть список допустимых атрибутов для этого объекта.

  Если объект имеет метод с именем `__dir__()`, этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, которые реализуют пользовательские функции `__getattr__()` или `__getattribute__()`, настраивать способ отображения их атрибутов в функции `dir()`.

  Если объект не предоставляет `__dir__()`, функция пытается собрать информацию из атрибута `__dict__` объекта, если он определён, и из его типа объекта. Полученный список не обязательно является полным и может быть неточным, когда у объекта есть пользовательская `__getattr__()`.

  Стандартный механизм `dir()` ведет себя по-разному с различными типами объектов, поскольку он пытается предоставить наиболее актуальную, а не полную информацию:

  - Если объект является модулем, список содержит имена атрибутов модуля.

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

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

  Результирующий список отсортирован в алфавитном порядке. Например:

      >>> import struct
      >>> dir()   # show the names in the module namespace
      ['__builtins__', '__name__', 'struct']
      >>> dir(struct)   # show the names in the struct module
      ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
       '__initializing__', '__loader__', '__name__', '__package__',
       '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
       'unpack', 'unpack_from']
      >>> class Shape:
      ...     def __dir__(self):
      ...         return ['area', 'perimeter', 'location']
      ...
      >>> s = Shape()
      >>> dir(s)
      ['area', 'location', 'perimeter']

  Примечание

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

divmod(a, b, /)

  Принимает два (не комплексных) числа в качестве аргументов и возвращает пару чисел: частное и остаток от целочисленного деления. При смешанных типах операндов применяются правила для бинарных арифметических операторов. Для целых чисел результат совпадает с `(a // b, a % b)`. Для чисел с плавающей точкой результатом будет `(q, a % b)`, где q обычно равно `math.floor(a / b)`, но может быть на 1 меньше этого значения. В любом случае `q * b + a % b` очень близко к a. Если `a % b` не равно нулю, оно имеет тот же знак, что и b, и выполняется условие `0 <= abs(a % b) < abs(b)`.

enumerate(iterable, start=0)

  Возвращает объект перечисления. iterable должен быть последовательностью, итератором или другим объектом, поддерживающим итерацию. Метод `__next__()` итератора, возвращаемого функцией `enumerate()`, возвращает кортеж, содержащий счётчик (начиная с start, по умолчанию 0) и значения, полученные при итерации по iterable.

      >>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
      >>> list(enumerate(seasons))
      [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
      >>> list(enumerate(seasons, start=1))
      [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

  Эквивалентно:

      def enumerate(iterable, start=0):
          n = start
          for elem in iterable:
              yield n, elem
              n += 1

eval(source, /, globals=None, locals=None)
  Параметры:

    - source (`str` | code object) – Выражение Python.

    - globals (`dict` | `None`) – Глобальное пространство имён (по умолчанию: `None`).

    - locals (mapping | `None`) – Локальное пространство имён (по умолчанию: `None`).

  Результат:

    Результат вычисленного выражения.

  выбрасывает исключение:

    Синтаксические ошибки сообщаются как исключения.

  Предупреждение

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

  Аргумент source анализируется и вычисляется как выражение Python (строго говоря, как список выражений) с использованием отображений globals и locals в качестве глобального и локального пространств имён. Если словарь globals передан и не содержит ключа `__builtins__`, ссылка на словарь встроенного модуля `builtins` вставляется под этим ключом перед разбором source. Переопределение `__builtins__` можно использовать для ограничения или изменения доступных имён, но это не является механизмом безопасности: выполняемый код по-прежнему может получить доступ ко всем встроенным именам. Если locals опущен, по умолчанию используется словарь globals. Если оба эти отображения опущены, переданный исходный код выполняется с globals и locals из окружения, в котором вызывается `eval()`. Обратите внимание, что eval() будет иметь доступ к вложенным областям видимости (нелокальным именам) во внешнем окружении, только если на них уже есть ссылки в той области видимости, из которой вызывается `eval()` (например, с помощью инструкции `nonlocal`).

  Пример:

      >>> x = 1
      >>> eval('x+1')
      2

      >>> eval("1, 2")
      (1, 2)

  Эта функция также может использоваться для выполнения произвольных объектов кода (таких, как созданные с помощью `compile()`). В этом случае вместо строки нужно передать объект кода. Если объект кода был скомпилирован с аргументом mode равным `'exec'`, возвращаемое значение `eval()` будет `None`.

  Подсказки: динамическое выполнение инструкций поддерживается функцией `exec()`. Функции `globals()` и `locals()` возвращают текущие глобальный и локальный пространства имён соответственно, которые могут быть полезны для передачи в `eval()` или `exec()`.

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

  См. функцию `ast.literal_eval()` для вычисления строк, содержащих выражения, состоящие только из литералов.

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

  Изменено в версии 3.13: Аргументы globals и locals теперь можно передавать как именованные.

  Изменено в версии 3.13: Семантика пространства имён locals по умолчанию была скорректирована, как описано для встроенной функции `locals()`.

exec(source, /, globals=None, locals=None, *, closure=None)

  Предупреждение

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

  Эта функция поддерживает динамическое выполнение кода Python. Аргумент source должен быть либо строкой, либо объектом кода. Если это строка, она анализируется как набор инструкций Python, которые затем выполняются (если не возникает синтаксическая ошибка). [1] Если это объект кода, он просто выполняется. Во всех случаях ожидается, что выполняемый код будет допустимым в качестве входного файла (см. раздел File input в Справочном руководстве). Имейте в виду, что инструкции `nonlocal`, `yield` и `return` не могут использоваться вне определений функций, даже в контексте кода, переданного в функцию `exec()`. Возвращаемое значение — `None`.

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

  Примечание

  Когда `exec` получает два отдельных объекта: globals и locals — код будет выполнен так, как если бы он был встроен в определение класса. Это означает, что функции и классы, определённые в исполняемом коде, не смогут получить доступ к переменным, присвоенным на верхнем уровне (поскольку переменные «верхнего уровня» рассматриваются как переменные класса в его определении).

  Если словарь globals не содержит значения для ключа `__builtins__`, ссылка на словарь встроенного модуля `builtins` вставляется под этим ключом. Переопределение `__builtins__` можно использовать для ограничения или изменения доступных имён, но это не является механизмом безопасности: выполняемый код по-прежнему может получить доступ ко всем встроенным именам.

  Аргумент closure указывает замыкание — кортеж переменных ячеек. Это допустимо только для объекта кода, содержащего свободные (замыкающие) переменные. Длина кортежа должна точно соответствовать длине атрибута `co_freevars` объекта кода.

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

  Примечание

  Встроенные функции `globals()` и `locals()` возвращают текущие глобальное и локальное пространства имён соответственно, которые может быть полезно использовать в качестве второго и третьего аргументов `exec()` .

  Примечание

  Поведение locals по умолчанию такое же, как описано для функции `locals()` ниже. Передайте явный словарь locals, если вам нужно увидеть изменения в locals после возврата из функции `exec()`.

  Изменено в версии 3.11: Добавлен параметр closure.

  Изменено в версии 3.13: Аргументы globals и locals теперь можно передавать как именованные.

  Изменено в версии 3.13: Семантика пространства имён locals по умолчанию была скорректирована, как описано для встроенной функции `locals()`.

filter(function, iterable, /)

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

  Обратите внимание, что `filter(function, iterable)` эквивалентно генераторному выражению `(item for item in iterable if function(item))`, если функция не равна `None`, и `(item for item in iterable if item)`, если функция равна `None`.

  См. также дополнительную функцию `itertools.filterfalse()`, возвращающую элементы iterable, для которых function ложно.

class float(number=0.0, /)
class float(string, /)

  Возвращает число с плавающей точкой, созданное из числа или строки.

  Примеры:

      >>> float('+1.23')
      1.23
      >>> float('   -12345\n')
      -12345.0
      >>> float('1e-003')
      0.001
      >>> float('+1E6')
      1000000.0
      >>> float('-Infinity')
      -inf

  Если аргумент является строкой, оно должна содержать десятичное число, опционально с предшествующим знаком и окружённое пробелами. Необязательный знак может быть `'+'` или `'-'`; знак `'+'` не влияет на результат. Аргумент также может быть строкой, представляющей NaN (не число), а также положительную или отрицательную бесконечности. Более точно, входная строка, после удаления начальных и конечных пробелов, должна соответствовать правилу `floatvalue` следующей грамматики:

      sign          ::= "+" | "-"
      infinity      ::= "Infinity" | "inf"
      nan           ::= "nan"
      digit         ::= <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
      digitpart     ::= digit (["_"] digit)*
      number        ::= [digitpart] "." digitpart | digitpart ["."]
      exponent      ::= ("e" | "E") [sign] digitpart
      floatnumber   ::= number [exponent]
      absfloatvalue ::= floatnumber | infinity | nan
      floatvalue    ::= [sign] absfloatvalue

  Регистр не имеет значения, поэтому, например, «inf», «Inf», «INFINITY» и «iNfINity» - все допустимые написания для положительной бесконечности.

  В противном случае, если аргумент является целым числом или числом с плавающей точкой, возвращается число с плавающей точкой с тем же значением (в учётом точности Python). Если аргумент находится за пределами диапазона чисел с плавающей точкой Python, будет выброшено исключение `OverflowError`.

  Для произвольного объекта Python `x`, `float(x)` делегирует вызов методу `x.__float__()`. Если `__float__()` не определён, то вызывается `__index__()`.

  Если аргумент не задан, возвращается `0.0`.

  Тип float описан в Numeric Types — int, float, complex.

  Изменено в версии 3.6: Разрешена группировка цифр с использованием подчеркивания, как в коде литералов.

  Изменено в версии 3.7: Параметр теперь является только позиционным.

  Изменено в версии 3.8: Используется метод `__index__()`, если `__float__()` не определён.

format(value, format_spec='', /)

  Преобразовывает value в «отформатированное» представление, в соответствии с format_spec. Интерпретация format_spec будет зависеть от типа аргумента value; однако существует стандартный синтаксис форматирования, который используется большинством встроенных типов: Format specification mini-language.

  Значение по умолчанию для format_spec — пустая строка, которая обычно даёт тот же эффект, что и вызов `str(value)`.

  Вызов `format(value, format_spec)` преобразуется в `type(value).__format__(value, format_spec)`, который обходит словарь экземпляра при поиске метода `__format__()` значения. Выбрасывается исключение `TypeError`, если поиск метода достигает `object` при непустом format_spec, или если format_spec или возвращаемое значение не являются строками.

  Изменено в версии 3.4: `object().__format__(format_spec)` возбуждает исключение `TypeError`, если format_spec не является пустой строкой.

class frozenset(iterable=(), /)

  Возвращает новый объект `frozenset`, содержащий элементы из необязательного параметра iterable. `frozenset` — это встроенный класс. См. также Set Types — set, frozenset с документацией по этому классу.

  Для других контейнеров см. встроенные классы `set`, `list`, `tuple` и `dict`, а также модуль `collections`.

getattr(object, name, /)
getattr(object, name, default, /)

  Возвращает значение указанного атрибута object. Аргумент name должен быть строкой. Если строка является именем одного из атрибутов объекта, результатом будет значение этого атрибута. Например, `getattr(x, 'foobar')` эквивалентно `x.foobar`. Если указанный атрибут не существует, возвращается default, если он предоставлен, в противном случае возбуждается исключение `AttributeError`. Аргумент name не обязательно должен быть идентификатором Python (см. `setattr()`).

  Примечание

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

globals()

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

hasattr(object, name, /)

  Аргументы — это объект и строка. Результат будет `True`, если строка является именем одного из атрибутов объекта, и `False` в противном случае. (Это реализовано с помощью вызова `getattr(object, name)` и проверки, возбуждает ли это исключение `AttributeError` или нет.)

hash(object, /)

  Возвращает хэш-значение объекта (если оно есть). Хэш-значения — это целые числа. Они используются для быстрого сравнения ключей словаря во время поиска по нему. Числовые значения, которые сравниваются как равные, имеют одно и то же хэш-значение (даже если они разных типов, как в случае с 1 и 1.0).

  Примечание

  Обратите внимание, что для объектов с пользовательскими методами `__hash__()`, функция `hash()` усекает возвращаемое значение в зависимости от разрядности хост-машины.

help()
help(request)

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

  Обратите внимание, что если при вызове `help()` в списке параметров функции появляется слеш (/), это означает, что параметры перед ним являются только-позиционными. Дополнительную информацию см. в ЧаВо по только-позиционным параметрам.

  Эта функция добавляется во встроенное пространство имён модулем `site`.

  Изменено в версии 3.4: Изменения в модулях `pydoc` и `inspect` привели к тому, что сигнатуры вызываемых объектов теперь отображаются более полно и последовательно.

hex(integer, /)

  Преобразовывает целое число в строку с его шестнадцатеричным представлением в нижнем регистре с префиксом «0x». Если integer не является объектом Python `int`, он должен определять метод `__index__()`, который возвращает целое число. Примеры:

      >>> hex(255)
      '0xff'
      >>> hex(-42)
      '-0x2a'

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

      >>> '%#x' % 255, '%x' % 255, '%X' % 255
      ('0xff', 'ff', 'FF')
      >>> format(255, '#x'), format(255, 'x'), format(255, 'X')
      ('0xff', 'ff', 'FF')
      >>> f'{255:#x}', f'{255:x}', f'{255:X}'
      ('0xff', 'ff', 'FF')

  См. также `format()` для получения дополнительной информации.

  См. также `int()` для преобразования шестнадцатеричной строки в целое число с основанием 16.

  Примечание

  Для получения строки с шестнадцатеричным представлением числа с плавающей точкой используйте метод `float.hex()`.

id(object, /)

  Возвращает «идентификатор» объекта. Это целое число, которое гарантированно будет уникальным и постоянным для данного объекта в течение его времени жизни. У двух объектов с неперекрывающимися временами жизни может быть одно и то же значение `id()`.

  Это адрес объекта в памяти.

  Возбуждает событие аудита `builtins.id` с аргументом `id`.

input()
input(prompt, /)

  Если аргумент prompt указан, он выводится в стандартный поток вывода без завершающего символа новой строки. Затем функция считывает строку из ввода, преобразует её в строку (удаляя завершающий символ новой строки) и возвращает её. При чтении EOF возбуждается исключение `EOFError`. Пример:

      >>> s = input('--> ')
      --> Monty Python's Flying Circus
      >>> s
      "Monty Python's Flying Circus"

  Если модуль `readline` был загружен, то функция `input()` будет использовать его для предоставления расширенных функций редактирования строк и истории.

  Возбуждает событие аудита `builtins.input` с аргументом `prompt` перед чтением ввода

  Возбуждает событие аудита `builtins.input/result` с результатом после успешного чтения ввода.

class int(number=0, /)
class int(string, /, base=10)

  Возвращает целочисленный объект, созданный из числа или строки, или возвращает `0`, если аргументы не указаны.

  Примеры:

      >>> int(123.45)
      123
      >>> int('123')
      123
      >>> int('   -12_345\n')
      -12345
      >>> int('FACE', 16)
      64206
      >>> int('0xface', 0)
      64206
      >>> int('01110011', base=2)
      115

  If the argument defines `__int__()`, `int(x)` returns `x.__int__()`. If the argument defines `__index__()`, it returns `x.__index__()`. If the argument defines `__trunc__()`, it returns `x.__trunc__()`. For floating-point numbers, this truncates towards zero.

  Если аргумент не является числом или задано base, то он должен быть строкой, или экземпляром `bytes` или `bytearray`, представляющим целое число в системе счисления по основанию base. Дополнительно строка может начинаться с `+` или `-` (без пробела после них), содержать ведущие нули, быть окружённой пробелами и иметь одиночные подчеркивания между цифрами.

  Запись целого числа в системе счисления с основанием n содержит цифры, каждая из которых представляет значение от 0 до n-1. Значения 0–9 могут быть представлены любыми десятичными цифрами Юникода. Значения 10–35 могут быть представлены символами от `a` до `z` (или от `A` до `Z`). По умолчанию base равно 10. Допустимые основания: 0 и 2–36. Записи чисел в системах счисления с основаниями 2, 8 и 16 могут дополнительно иметь префиксы `0b`/`0B`, `0o`/`0O` или `0x`/`0X`, как литералы целых чисел в коде. Для основания 0 строка интерпретируется аналогично целочисленному литералу в коде, то есть фактическим основанием является 2, 8, 10 или 16 в зависимости от префикса. Основание 0 также запрещает ведущие нули: `int('010', 0)` недопустимо, в то время как `int('010')` и `int('010', 8)` допустимы.

  Тип целого числа описан в Numeric Types — int, float, complex.

  Изменено в версии 3.4: Если base не является экземпляром класса `int` и у объекта base есть метод `base.__index__`, этот метод вызывается для получения целого числа для base. В предыдущих версиях вместо `base.__index__` использовался метод `base.__int__`.

  Изменено в версии 3.6: Разрешена группировка цифр с использованием подчеркивания, как в коде литералов.

  Изменено в версии 3.7: Первый параметр теперь только позиционный.

  Изменено в версии 3.8: Используется `__index__()`, если `__int__()` не определён.

  Изменено в версии 3.11: The delegation to `__trunc__()` is deprecated.

  Изменено в версии 3.11: Строковые представления чисел `int` (как входные, так и выходные) могут быть ограничены, чтобы избежать атак типа «отказ в обслуживании». Возбуждается исключение `ValueError`, когда превышен предел во время преобразования строки в `int` или когда преобразование `int` в строку превысило бы предел. См. документацию по ограничению длины строкового представления целых чисел.

isinstance(object, classinfo, /)

  Возвращает `True`, если аргумент object является экземпляром аргумента classinfo, или его (прямого, косвенного или виртуального) подкласса. Если object не является объектом данного типа, функция всегда возвращает `False`. Если classinfo является кортежем объектов типа (или других таких кортежей рекурсивно) или объединением типов Union Type, возвращается `True`, если object является экземпляром любого из типов. Если classinfo не является типом или кортежем типов и таких кортежей, возбуждается исключение `TypeError`. `TypeError` может не возбуждаться для недопустимого типа, если более ранняя проверка прошла успешно.

  Изменено в версии 3.10: classinfo может быть Union Type.

issubclass(class, classinfo, /)

  Return `True` if class is a subclass (direct, indirect, or virtual) of classinfo. A class is considered a subclass of itself. classinfo may be a tuple of class objects (or recursively, other such tuples) or a Union Type, in which case return `True` if class is a subclass of any entry in classinfo. In any other case, a `TypeError` exception is raised.

  Изменено в версии 3.10: classinfo может быть Union Type.

iter(iterable, /)
iter(callable, sentinel, /)

  Возвращает объект итератора. Первый аргумент интерпретируется по-разному в зависимости от наличия второго. Без второго аргумента object должен быть объектом коллекции, поддерживающий протокол итерации (метод `__iter__()`) или протокол последовательности (метод `__getitem__()` с целочисленными аргументами, начиная с `0`). Если он не поддерживает ни один из этих протоколов, возбуждается исключение `TypeError`. Если задан второй аргумент sentinel, то object должен быть вызываемым объектом. Итератор, созданный в этом случае, будет вызывать object без аргументов при каждом вызове его метода `__next__()`; если возвращаемое значение равно sentinel, возбуждается исключение `StopIteration`, в противном случае это значение возвращается.

  См. также Iterator Types.

  Одно из полезных применений второй формы `iter()` — это создание блочного считывателя. Например, чтение блоков фиксированной ширины из бинарного файла базы данных до достижения конца файла:

      from functools import partial
      with open('mydata.db', 'rb') as f:
          for block in iter(partial(f.read, 64), b''):
              process_block(block)

len(object, /)

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

  Функция `len` выбрасывает исключение `OverflowError` на длинах, превышающих `sys.maxsize`, таких как `range(2 ** 100)`.

class list(iterable=(), /)

  Вместо того чтобы быть функцией, `list` на самом деле является изменяемым типом последовательности, как указано в Lists и Sequence Types — list, tuple, range.

locals()

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

  В области видимости модуля, а также при использовании `exec()` или `eval()` с одним пространством имён, эта функция возвращает то же пространство имён, что и `globals()`.

  В области видимости класса она возвращает пространство имён, которое будет передано метаклассу при создании класса.

  При использовании `exec()` или `eval()` с отдельными локальными и глобальными аргументами, функция возвращает локальное пространство имён, переданное при вызове функции.

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

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

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

  Вызов `locals()` как части генераторного выражения эквивалентен вызову его во вложенной функции генератора.

  Изменено в версии 3.12: Поведение `locals()` во включении было обновлено, как описано в PEP 709.

  Изменено в версии 3.13: В рамках PEP 667 теперь определена семантика изменения объектов отображения, возвращаемых этой функцией. Поведение в оптимизированных областях видимости теперь такое, как описано выше. Помимо этого определения, поведение в других областях видимости осталось таким же, как в предыдущих версиях.

map(function, iterable, *iterables)

  Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see `itertools.starmap()`.

max(iterable, /, *, key=None)
max(iterable, /, *, default, key=None)
max(arg1, arg2, /, *args, key=None)

  Возвращает наибольший элемент итерируемого объекта или наибольший из двух и более аргументов.

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

  Есть два необязательных аргумента, передаваемых только по имени. Аргумент key определяет функцию упорядочивания с одним аргументом, подобную таковой в `list.sort()`. Аргумент default задаёт объект, который будет возвращён, если предоставленный итерируемый объект пуст. Если итерируемый объект пуст и default не задан, возбуждается исключение `ValueError`.

  Если несколько элементов являются максимальными, функция вернёт первый найденный. Это согласуется с другими инструментами, сохраняющими стабильность сортировки, такими как `sorted(iterable, key=keyfunc, reverse=True)[0]` и `heapq.nlargest(1, iterable, key=keyfunc)`.

  Изменено в версии 3.4: Добавлен только-именованный параметр default.

  Изменено в версии 3.8: Параметр key может быть `None`.

class memoryview(object)

  Возвращает объект «представления памяти», созданный из переданного аргумента. См. Memory Views для получения дополнительной информации.

min(iterable, /, *, key=None)
min(iterable, /, *, default, key=None)
min(arg1, arg2, /, *args, key=None)

  Возвращает наименьший элемент итерируемого объекта или наименьший из двух и более аргументов.

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

  Есть два необязательных аргумента, передаваемых только по имени. Аргумент key определяет функцию упорядочивания с одним аргументом, подобную таковой в `list.sort()`. Аргумент default задаёт объект, который будет возвращён, если предоставленный итерируемый объект пуст. Если итерируемый объект пуст и default не задан, возбуждается исключение `ValueError`.

  Если несколько элементов являются минимальными, функция возвращает первый найденный. Это согласуется с другими инструментами, сохраняющими стабильность сортировки, такими как `sorted(iterable, key=keyfunc)[0]` и `heapq.nsmallest(1, iterable, key=keyfunc)`.

  Изменено в версии 3.4: Добавлен только-именованный параметр default.

  Изменено в версии 3.8: Параметр key может быть `None`.

next(iterator, /)
next(iterator, default, /)

  Получает следующий элемент из итератора, вызывая его метод `__next__()`. Если указан default, он возвращается, когда итератор исчерпан, в противном случае выбрасывается исключение `StopIteration`.

class object

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

  Примечание

  Экземпляры `object` не имеют атрибута `__dict__`, поэтому нельзя добавлять произвольные атрибуты экземплярам `object`.

oct(integer, /)

  Преобразовывает целое число в строку с его восьмеричным представлением и префиксом «0o». Результат является корректным выражением Python. Если integer не является объектом Python класса `int`, он должен определить метод `__index__()`, который возвращает целое число. Например:

      >>> oct(8)
      '0o10'
      >>> oct(-56)
      '-0o70'

  Если вы хотите преобразовать целое число в восьмеричное представление с префиксом «0o» или без него, вы можете использовать любой из следующих способов.

      >>> '%#o' % 10, '%o' % 10
      ('0o12', '12')
      >>> format(10, '#o'), format(10, 'o')
      ('0o12', '12')
      >>> f'{10:#o}', f'{10:o}'
      ('0o12', '12')

  См. также `format()` для получения дополнительной информации.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

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

  Аргумент file — это путеподобный объект, задающий путь (абсолютный или относительный от текущего рабочего каталога) к файлу, который должен быть открыт, или целочисленный дескриптор файла, который должен быть обёрнут. (Если задан файловый дескриптор, он закрывается при закрытии возвращаемого объекта ввода/вывода, если closefd не установлено в `False`.)

  Аргумент mode — необязательная строка, определяющая режим открытия файла. По умолчанию установлено значение `'r'`, что означает «открытие для чтения в текстовом режиме». Другими распространенными значениями являются `'w'` для записи (очистив файл, если он уже существует), `'x'` для эксклюзивного создания и `'a'` для добавления (что в некоторых Unix системах это означает, что все записи добавляются в конец файла независимо от текущей позиции указателя). В текстовом режиме, если аргумент encoding не указан, используемая кодировка зависит от платформы: вызывается `locale.getencoding()` для получения текущей локальной кодировки. (Для чтения и записи необработанных байтов используйте бинарный режим и оставьте encoding неуказанной.) Доступны следующие режимы:

  Символ | Значение
  --- | ---
  `'r'` | открыть для чтения (по умолчанию)
  `'w'` | открыть для записи, предварительно очистив файл
  `'x'` | открыть для эксклюзивного создания, ошибка если файл уже существует
  `'a'` | открыть для записи, добавляя в конец файла, если он существует
  `'b'` | бинарный режим
  `'t'` | текстовый режим (по умолчанию)
  `'+'` | открыть для обновления (чтение и запись)

  Режим по умолчанию — `'r'` (открытие для чтения текста, синоним `'rt'`). Режимы `'w+'` и `'w+b'` открывают и очищают файл. Режимы `'r+'` и `'r+b'` открывают файл без очистки.

  Как упоминается в Overview, Python различает бинарный и текстовый ввод/вывод. Файлы, открытые в бинарном режиме (если в аргументе mode указано `'b'`), возвращают содержимое в виде объектов `bytes` без какой-либо декодировки. В текстовом режиме (по умолчанию или когда в аргументе mode указано `'t'`), содержимое файла возвращается как `str`, при этом байты сначала декодируются с использованием кодировки, зависящей от платформы, или переданной в аргументе encoding, если она указана.

  Примечание

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

  Аргумент buffering — это необязательное целое число, задающее политику буферизации. Передайте 0, чтобы отключить буферизацию (разрешено только в бинарном режиме), 1, чтобы выбрать построчную буферизацию (используется только при записи в текстовом режиме), и целое число > 1, чтобы задать размер буфера фиксированного размера в байтах. Обратите внимание, что указание размера буфера таким образом применяется для бинарного буферизованного ввода/вывода, но `TextIOWrapper` (т.е. файлы, открытые с `mode='r+'`), будут иметь другую буферизацию. Чтобы отключить буферизацию в `TextIOWrapper`, рассмотрите возможность использования флага `write_through` для `io.TextIOWrapper.reconfigure()`. Если аргумент buffering не указан, политика буферизации по умолчанию работает следующим образом:

  - Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s «block size» and falling back on `io.DEFAULT_BUFFER_SIZE`. On many systems, the buffer will typically be 4096 or 8192 bytes long.

  - «Интерактивные» текстовые файлы (файлы, для которых `isatty()` возвращает `True`) используют построчную буферизацию. Остальные текстовые файлы используют ту же политику, что и бинарные файлы.

  Атрубит encoding — это имя кодировки, используемой для декодирования или кодирования файла. Это следует использовать только в текстовом режиме. Кодировка по умолчанию зависит от платформы (то есть от значения, что возвращает функция `locale.getencoding()`), однако может использоваться любая кодировка текста, поддерживаемая Python. Список поддерживаемых кодировок см. в модуле `codecs`.

  errors is an optional string that specifies how encoding and decoding errors are to be handled—this cannot be used in binary mode. A variety of standard error handlers are available (listed under Error Handlers), though any error handling name that has been registered with `codecs.register_error()` is also valid. The standard names include:

  - `'strict'` to raise a `ValueError` exception if there is an encoding error. The default value of `None` has the same effect.

  - `'ignore'` ignores errors. Note that ignoring encoding errors can lead to data loss.

  - `'replace'` causes a replacement marker (such as `'?'`) to be inserted where there is malformed data.

  - `'surrogateescape'` will represent any incorrect bytes as low surrogate code units ranging from U+DC80 to U+DCFF. These surrogate code units will then be turned back into the same bytes when the `surrogateescape` error handler is used when writing data. This is useful for processing files in an unknown encoding.

  - `'xmlcharrefreplace'` is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference `&#nnn;`.

  - `'backslashreplace'` replaces malformed data by Python’s backslashed escape sequences.

  - `'namereplace'` (also only supported when writing) replaces unsupported characters with `\N{...}` escape sequences.

  Аргумент newline определяет, как анализировать символы новой строки из потока. Он может принимать значения `None`, `''`, `'\n'`, `'\r'` и `'\r\n'`. Это работает следующим образом:

  - При чтении ввода из потока, если newline равно `None`, включается режим универсальных переводов строк. Строки во вводе могут заканчиваться на `'\n'`, `'\r'` или `'\r\n'`, и они преобразуются в `'\n'` перед возвратом вызывающей стороне. Если newline равно `''`, также включается режим универсальных переводов строк, но концы строк возвращаются вызывающей стороне без преобразования. Если newline имеет любое другое допустимое значение, строки ввода завершаются только заданной строкой, и конец строки возвращается вызывающей стороне без изменений.

  - При записи вывода в поток, если newline равно `None`, все записываемые символы `'\n'` будут преобразованы в системный разделитель строк по умолчанию, `os.linesep`. Если newline равно `''` или `'\n'`, преобразование не выполняется. Если newline равно любому другому допустимому значению, все записанные символы `'\n'` будут преобразованы в заданную строку.

  Если closefd равно `False` и вместо имени файла был передан файловый дескриптор, базовый файловый дескриптор будет оставлен открытым при закрытии файла. Если указано имя файла, closefd должно быть равно `True` (значение по умолчанию); в противном случае будет возбуждена ошибка.

  Пользовательский открыватель можно использовать, передав вызываемый объект в аргументе opener. В этом случае базовый файловый дескриптор для файлового объекта получается вызовом opener с аргументами (file, flags). opener должен вернуть открытый файловый дескриптор (передача `os.open` в качестве opener приводит к поведению, аналогичному передаче `None`).

  Новый созданный файл является ненаследуемым.

  Следующий пример использует параметр dir_fd функции `os.open()` для открытия файла относительно заданного каталога:

      >>> import os
      >>> dir_fd = os.open('somedir', os.O_RDONLY)
      >>> def opener(path, flags):
      ...     return os.open(path, flags, dir_fd=dir_fd)
      ...
      >>> with open('spamspam.txt', 'w', opener=opener) as f:
      ...     print('Это будет записано в somedir/spamspam.txt', file=f)
      ...
      >>> os.close(dir_fd)  # не допускаем утечки файлового дескриптора

  Тип файлового объекта, возвращаемого функцией `open()`, зависит от режима. При использовании `open()` для открытия файла в текстовом режиме (`'w'`, `'r'`, `'wt'`, `'rt'`, и т.д.), возвращается подкласс `io.TextIOBase` (а точнее `io.TextIOWrapper`). При использовании её для открытия файла в бинарном режиме с буферизацией, возвращаемый класс является подклассом `io.BufferedIOBase`. Точный класс может варьироваться: в режиме чтения файла возвращается `io.BufferedReader`; в режимах записи и добавления возвращается `io.BufferedWriter`, а в режиме чтения/записи возвращается `io.BufferedRandom`. При отключении буферизации возвращается необработанный поток, подкласс `io.RawIOBase`, а именно `io.FileIO`.

  См. также модули обработки файлов, такие как `fileinput`, `io` (где объявлена функция `open()`), `os`, `os.path`, `tempfile` и `shutil`.

  Возбуждает событие аудита `open` с аргументами `path`, `mode`, `flags`.

  Аргументы `mode` и `flags` могут быть изменены или выведены из оригинального вызова.

  Изменено в версии 3.3:

  - Добавлен параметр opener.

  - Добавлен режим `'x'`.

  - Ранее возбуждалось исключение `IOError`, теперь это псевдоним `OSError`.

  - Теперь возбуждается исключение `FileExistsError`, если открываемый в режиме эксклюзивного создания (`'x'`) файл уже существует.

  Изменено в версии 3.4:

  - Файл теперь не наследуется.

  Изменено в версии 3.5:

  - Если системный вызов прерывается и обработчик сигнала не возбуждает исключение, функция теперь повторяет системный вызов вместо возбуждения исключения `InterruptedError` (см. PEP 475 с объяснением причин).

  - Добавлен обработчик ошибок `'namereplace'`.

  Изменено в версии 3.6:

  - Добавлена поддержка объектов, реализующих интерфейс `os.PathLike`.

  - В Windows открытие буфера консоли может вернуть подкласс `io.RawIOBase`, отличный от `io.FileIO`.

  Изменено в версии 3.11: Режим `'U'` был удалён.

ord(character, /)

  Возвращает порядковый номер символа.

  Если аргумент — это строка из одного символа, возвращается его кодовая позиция Unicode. Например, `ord('a')` возвращает целое число `97`, а `ord('€')` (знак евро) возвращает `8364`. Это обратная функция по отношению к `chr()`.

  Если аргумент — объект `bytes` или `bytearray` длины 1, возвращается значение единственного байта. Например, `ord(b'a')` возвращает целое число `97`.

pow(base, exp, mod=None)

  Возвращает base в степени exp; если указан mod, возвращает base в степени exp, по модулю mod (вычисляется эффективнее, чем `pow(base, exp) % mod`). Двухаргументная форма `pow(base, exp)` эквивалентна использованию оператора возведения в степень: `base**exp`.

  Если аргументы являются разными встроенными числовые типами, применяются правила приведение для бинарных арифметических операторов. Для операндов типа `int` результат имеет тот же тип, что и операнды (после приведение), если только второй аргумент не является отрицательным; в этом случае все аргументы преобразуются в тип float и результат тоже имеет тип float. Например, `pow(10, 2)` возвращает `100`, но `pow(10, -2)` возвращает `0.01`. Для отрицательного основания типа `int` или `float` и нецелого показателя степени возвращается комплексный результат. Например, `pow(-9, 0.5)` возвращает значение, близкое к `3j`. В то время как для отрицательного основания типа `int` или `float` и целого показателя степени получается результат float. Например, `pow(-9, 2.0)` возвращает `81.0`.

  Для операндов base и exp типа `int`, если mod присутствует, он также должен быть числом целого типа, не равным нулю. Если mod указан и exp отрицательное, base должно быть взаимно простым с mod. В этом случае возвращается `pow(inv_base, -exp, mod)`, где inv_base является обратным к base по модулю mod.

  Вот пример вычисления обратного значения для `38` по модулю `97`:

      >>> pow(38, -1, mod=97)
      23
      >>> 23 * 38 % 97 == 1
      True

  Изменено в версии 3.8: Для операндов `int` трехаргументная форма `pow` теперь позволяет второму аргументу быть отрицательным, что позволяет вычислять обратные элементы по модулю.

  Изменено в версии 3.8: Разрешены именованные аргументы. Ранее поддерживались только позиционные аргументы.

print(*objects, sep=' ', end='\n', file=None, flush=False)

  Печатает objects в текстовый поток file, разделяя их строкой sep и завершая строкой end. sep, end, file и flush, если они переданы, должны быть указаны в виде именованных аргументов.

  Все неименованные аргументы преобразуются в строки, как это делает функция `str()`, и записываются в поток, разделенные sep и с последующим end. И sep, и end должны быть строками; они также могут быть `None`, что означает использование значений по умолчанию. Если objects не указаны, `print()` просто выводит end.

  Аргумент file должен быть объектом с методом `write(string)`; если он отсутствует или равен `None`, будет использоваться `sys.stdout`. Поскольку выводимые аргументы преобразуются в текстовые строки, функцию `print()` нельзя использовать с файловыми объектами, открытыми в бинарном режиме. Вместо этого используйте `file.write(...)`.

  Буферизация вывода обычно определяется объектом file. Однако, если аргумент flush истинный, поток принудительно сбрасывается.

  Изменено в версии 3.3: Добавлен именованный аргумент flush.

class property(fget=None, fset=None, fdel=None, doc=None)

  Возвращает атрибут свойства.

  fget — функция для получения значения атрибута. fset — функция для установки значения атрибута. fdel — функция для удаления значения атрибута. И doc создаёт строку документации для атрибута.

  Типичное использование — это определение управляемого атрибута `x`:

      class C:
          def __init__(self):
              self._x = None

          def getx(self):
              return self._x

          def setx(self, value):
              self._x = value

          def delx(self):
              del self._x

          x = property(getx, setx, delx, "Я — свойство 'x'.")

  Если c является экземпляром C, то `c.x` вызывает функцию получения значения атрибута, `c.x = value` — функцию установки, а `del c.x` — функцию удаления.

  Если указано, doc будет строкой документации атрибута свойства. В противном случае, свойство будет копировать строку документации fget (если она существует). Это позволяет легко создавать свойства только для чтения, используя `@property` в качестве декоратора:

      class Parrot:
          def __init__(self):
              self._voltage = 100000

          @property
          def voltage(self):
              """Вернуть текущее напряжение."""
              return self._voltage

  Декоратор `@property` превращает метод `voltage()` в функцию для получения значения атрибута только для чтения с тем же именем, и устанавливает строку документации для voltage равной «Вернуть текущее напряжение.»

  @getter
  @setter
  @deleter

    Объект свойства имеет методы `getter`, `setter` и `deleter`, которые можно использовать в качестве декораторов. Они создают копию свойства с соответствующей функцией доступа, установленной в декорированную функцию. Это лучше всего объяснить на примере:

        class C:
            def __init__(self):
                self._x = None

            @property
            def x(self):
                """Я — свойство 'x'."""
                return self._x

            @x.setter
            def x(self, value):
                self._x = value

            @x.deleter
            def x(self):
                del self._x

    Этот код полностью эквивалентен первому примеру. Убедитесь, что дополнительные функции имеют то же самое имя, что и исходное свойство (в данном случае `x`.)

    Возвращаемый объект свойства также имеет атрибуты `fget`, `fset` и `fdel`, соответствующие аргументам конструктора.

  Изменено в версии 3.5: Строки документации объектов свойств теперь можно изменять.

  __name__

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

    Добавлено в версии 3.13.

class range(stop, /)
class range(start, stop, step=1, /)

  Вместо того чтобы быть функцией, `range` на самом деле является неизменяемым типом последовательности, как описано в Ranges и Sequence Types — list, tuple, range.

repr(object, /)

  Возвращает строку, содержащую представление объекта пригодное для печати. Для многих типов эта функция пытается вернуть строку, которая бы выдала объект с тем же значением при передаче в `eval()`; в противном случае, представление — это строка, заключенная в угловые скобки, которая содержит имя типа объекта вместе с дополнительной информацией, часто включающей имя и адрес объекта. Класс может контролировать, что эта функция возвращает для его экземпляров, определяя метод `__repr__()`. Если `sys.displayhook()` недоступен, эта функция выбросит `RuntimeError`.

  Этот класс имеет собственное представление, которое может быть вычислено:

      class Person:
         def __init__(self, name, age):
            self.name = name
            self.age = age

         def __repr__(self):
            return f"Person('{self.name}', {self.age})"

reversed(object, /)

  Возвращает обратный итератор. Аргумент должен быть объектом, который имеет метод `__reversed__()` или поддерживает протокол последовательности (методы `__len__()` и `__getitem__()` с целыми числовыми аргументами, начинающимися с `0`).

round(number, ndigits=None)

  Возвращает number округлённое с точностью до ndigits разрядов после десятичной точки. Если ndigits опущено или равно `None`, то возвращается ближайшее целое число к входному значению.

  Для встроенных типов, поддерживающих функцию `round()`, значения округляются до ближайшего кратного 10 в степени минус ndigits; если два кратных значения одинаково близки, округление происходит в сторону чётного числа (таким образом, например, и `round(0.5)`, и `round(-0.5)` равны `0`, а `round(1.5)` равно `2`). Любое целое значение является верным для ndigits (положительное, нулевое или отрицательное). Возвращаемое значение является целым числом, если ndigits опущено или равно `None`. В противном случае, возвращаемое значение имеет тот же тип, что и number.

  Для произвольного объекта Python `number` функция `round` делегирует вызов методу `number.__round__`.

  Примечание

  Поведение `round()` для чисел с плавающей точкой может быть удивительным: например, `round(2.675, 2)` возвращает `2.67` вместо ожидаемого `2.68`. Это не ошибка, это результат того факта, что большинство десятичных дробей не могут быть точно представлены в виде float. См. Арифметика с плавающей точкой: проблемы и ограничения для получения дополнительной информации.

class set(iterable=(), /)

  Возвращает новый объект `set`, содержащий элементы из необязательного параметра iterable. `set` — это встроенный класс. См. также Set Types — set, frozenset с документацией по этому классу.

  Для других контейнеров см. встроенные классы `frozenset`, `list`, `tuple` и `dict`, а также модуль `collections`.

setattr(object, name, value, /)

  Это аналог `getattr()`. Аргументы — это объект, строка и произвольное значение. Строка может задавать существующий или новый атрибут. Функция присваивает значение атрибуту, если объект позволяет это сделать. Например, `setattr(x, 'foobar', 123)` эквивалентно `x.foobar = 123`.

  name не обязательно должно быть идентификатором Python, как определено в Identifiers and keywords, если только объект не решит это проверять, например, в пользовательском методе `__getattribute__()` или через `__slots__`. Атрибут, имя которого не является идентификатором, не будет доступен с использованием точечной нотации, но доступен через `getattr()` и т.д..

  Примечание

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

class slice(stop, /)
class slice(start, stop, step=None, /)

  Возвращает объект среза, представляющий набор индексов, заданных как `range(start, stop, step)`. Аргументы start и step по умолчанию равны `None`.

  Slice objects have read-only data attributes `start`, `stop`, and `step` which merely return the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.

  start
  stop
  step

  Slice objects are also generated when extended indexing syntax is used. For example: `a[start:stop:step]` or `a[start:stop, i]`. See `itertools.islice()` for an alternate version that returns an iterator.

  Изменено в версии 3.12: Объекты срезов теперь являются хэшируемыми (при условии, что `start`, `stop` и `step` являются хэшируемыми).

sorted(iterable, /, *, key=None, reverse=False)

  Возвращает новый отсортированный список из элементов в iterable.

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

  key указывает на функцию с одним аргументом, которая используется для извлечения ключа сравнения из каждого элемента в iterable (например, `key=str.lower`). Значение по умолчанию — `None` (сравнение элементов напрямую).

  reverse — логическое значение. Если установлено значение `True`, то элементы списка сортируются так, как если бы каждое сравнение было обращено.

  Используйте `functools.cmp_to_key()` для преобразования старого стиля функции cmp в функцию key.

  Встроенная функция `sorted()` гарантирует стабильность. Сортировка является стабильной, если она гарантирует сохранение относительного порядка элементов, которые сравниваются как равные — это полезно для сортировки в несколько проходов (например, сортировка по отделу, затем по уровню зарплаты).

  Алгоритм сортировки использует только сравнения `<` между элементами. В то время как определения метода `__lt__()` будет достаточно для сортировки, PEP 8 рекомендует реализовать все шесть расширенных сравнений. Это поможет избежать ошибок при использовании тех же данных с другими инструментами упорядочивания, такими как `max()`, которые полагаются на другой базовый метод. Реализация всех шести сравнений также помогает избежать путаницы при сравнении смешанных типов, которые могут вызывать отраженный метод `__gt__()`.

  Для примеров сортировки и краткого руководства по ней см. Sorting Techniques.

@staticmethod

  Преобразовывает метод в статический метод.

  Статический метод не получает неявный первый аргумент. Чтобы объявить статический метод, используйте эту идиому:

      class C:
          @staticmethod
          def f(arg1, arg2, argN): ...

  Конутрукция `@staticmethod` является формой вызова декоратора — см. Function definitions для подробностей.

  Статический метод можно вызывать как у класса (например, `C.f()`), так и у его экземпляра (например, `C().f()`). Более того, статический метод как дескриптор также является вызываемым, поэтому его можно использовать в определении класса (например, `f()`).

  Статические методы в Python аналогичны тем, которые можно найти в Java или C++. Также см. `@classmethod` для варианта, который полезен для создания альтернативных конструкторов класса.

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

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

  Для получения дополнительной информации о статических методах см. Иерархия стандартных типов.

  Изменено в версии 3.10: Статические методы теперь наследуют атрибуты метода (`__module__`, `__name__`, `__qualname__`, `__doc__` и `__annotations__`), имеют новый атрибут `__wrapped__` и могут вызываться как обычные функции.

class str(*, encoding='utf-8', errors='strict')
class str(object)
class str(object, encoding, errors='strict')
class str(object, *, errors)

  Возвращает значение типа `str` для object. См. `str()` для подробностей.

  `str` — это встроенный класс строки. Для получения общей информации о строках см. Text Sequence Type — str.

sum(iterable, /, start=0)

  Суммирует start и элементы iterable слева направо и возвращает итоговую сумму. Элементы iterable обычно являются числами, и значение start не может быть строкой.

  Для некоторых случаев использования есть хорошие альтернативы `sum()`. Предпочтительный и быстрый способ объединения последовательности строк — вызов `''.join(sequence)`. Для сложения чисел с плавающей точкой с повышенной точностью, см. `math.fsum()`. Для объединения серии итерируемых объектов рассмотрите возможность использования `itertools.chain()`.

  Изменено в версии 3.8: Параметр start может быть указан как именованный аргумент.

  Изменено в версии 3.12: Суммирование чисел с плавающей точкой переключено на алгоритм, который обеспечивает более высокую точность и лучшую коммутативность на большинстве сборок.

class super
class super(type, object_or_type=None, /)

  Возвращает прокси-объект, который делегирует вызовы методов родительскому или родственному классу относительно type. Это полезно для доступа к унаследованным методам, которые были переопределены в классе.

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

  Например, если значение `__mro__` для object_or_type равно `D -> B -> C -> A -> object`, а значение type равно `B`, то `super()` будет искать `C -> A -> object`.

  Атрибут `__mro__` класса, соответствующего object_or_type, перечисляет порядок поиска разрешения метода, используемый как `getattr()`, так и `super()`. Атрибут является динамическим и может меняться при каждом обновлении иерархии наследования.

  Если второй аргумент опущен, возвращаемый объект super является неcвязанным. Если второй аргумент является объектом, `isinstance(obj, type)` должно быть истиной. Если второй аргумент является типом, `issubclass(type2, type)` должно быть истиной (это полезно для методов класса).

  При вызове непосредственно внутри обычного метода класса оба аргумента могут быть опущены («`super()` без аргументов»). В этом случае type будет охватывающим классом, а obj будет первым аргументом непосредственно охватывающей функции (обычно `self`). (Это означает, что `super()` без аргументов не будет работать должным образом во вложенных функциях, включая генераторные выражения, которые неявно создают вложенные функции.)

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

  Второй сценарий использования — поддержка совместного множественного наследования в динамической среде выполнения. Этот сценарий использования уникален для Python и не встречается в статически компилируемых языках или языках, которые поддерживают только одиночное наследование. Это позволяет реализовывать «ромбовидные диаграммы», где несколько базовых классов реализуют один и тот же метод. Хороший дизайн предписывает, чтобы такие реализации имели одинаковую сигнатуру вызова в каждом случае (потому что порядок вызовов определяется во время выполнения, адаптируется к изменениям в иерархии классов и может включать родственные классы, которые неизвестны до времени выполнения).

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

      class C(B):
          def method(self, arg):
              super().method(arg)    # Делает то же самое, что и:
                                     # super(C, self).method(arg)

  В дополнение к поиску методов, `super()` также работает для поиска атрибутов. Один из возможных случаев использования — вызов дескрипторов в родительском или родственном классе.

  Обратите внимание, что `super()` реализован как часть процесса связывания для поиска явных точечных атрибутов, таких как `super().__getitem__(name)`. Он делает это, реализуя собственный метод `__getattribute__()` для поиска классов в предсказуемом порядке, который поддерживает кооперативное множественное наследование. Следовательно, `super()` не определён для неявного поиска с использованием инструкций или операторов, таких как `super()[name]`.

  Также обратите внимание, что помимо формы без аргументов, `super()` не ограничен использованием только внутри методов. Форма с двумя аргументами явно задаёт все параметры и создаёт корректные ссылки. Форма без аргументов работает только внутри определения класса, так как компилятор заполняет необходимые детали для правильного получения определяемого класса, а также доступа к текущему экземпляру для обычных методов.

  Для практических рекомендаций по проектированию кооперативных классов с использованием `super()`, см. руководство по использованию super().

class tuple(iterable=(), /)

  Вместо того чтобы быть функцией, `tuple` на самом деле является неизменяемым типом последовательности, как описано в Tuples и Sequence Types — list, tuple, range.

class type(object, /)
class type(name, bases, dict, /, **kwargs)

  С одним аргументом возвращает тип object. Возвращаемое значение представляет собой объект типа и, как правило, совпадает с `object.__class__`.

  Для проверки типа объекта рекомендуется использовать встроенную функцию `isinstance()`, так как она учитывает подклассы.

  С тремя аргументами возвращает объект нового типа. По сути, это динамическая форма инструкции `class`. Строка name задаёт имя класса и становится его атрибутом `__name__`. Кортеж bases содержит базовые классы и становится его атрибутом `__bases__`; если он пуст, к нему добавляется `object`, высший базовый класс для всех классов. Словарь dict содержит определения атрибутов и методов для тела класса; он может быть скопирован или обёрнут, прежде чем он станет атрибутом `__dict__`. Следующие две инструкции создают идентичные объекты `type`:

      >>> class X:
      ...     a = 1
      ...
      >>> X = type('X', (), dict(a=1))

  См. также:

  - Документация по атрибутам и методам классов.

  - Type Objects

  Дополнительные именованные аргументы, переданные в форме с тремя аргументами, передаются соответствующему механизму метакласса (обычно `__init_subclass__()`) таким же образом, как ключи в определении класса (кроме metaclass).

  В отличие от инструкции `class`, трёхаргументная форма не вызывает метод метакласса `__prepare__` (см. Preparing the class namespace). Используйте `types.new_class()` для динамического создания класса с подходящим метаклассом.

  См. также Customizing class creation.

  Изменено в версии 3.6: Подклассы `type`, которые не переопределяют `type.__new__`, больше не могут использовать форму с одним аргументом для получения типа объекта.

vars()
vars(object, /)

  Возвращает атрибут `__dict__` для модуля, класса, экземпляра или любого другого объекта с атрибутом `__dict__`.

  Такие объекты, как модули и экземпляры, имеют обновляемый атрибут `__dict__`; однако другие объекты могут иметь ограничения на запись в свои атрибуты `__dict__` (например, классы используют `types.MappingProxyType` для предотвращения прямого обновления словаря).

  Без аргумента `vars()` действует как `locals()`.

  Возбуждается исключение `TypeError`, если указан объект, но у него нет атрибута `__dict__` (например, если его класс определяет атрибут `__slots__`).

  Изменено в версии 3.13: Результат вызова этой функции без аргумента был обновлён, как описано для встроенной функции `locals()`.

zip(*iterables, strict=False)

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

  Пример:

      >>> for item in zip([1, 2, 3], ['сахар', 'специи', 'всё хорошее']):
      ...     print(item)
      ...
      (1, 'сахар')
      (2, 'специи')
      (3, 'всё хорошее')

  Более формально: `zip()` возвращает итератор кортежей, где i-й кортеж содержит i-й элемент каждого из переданных итерируемых объектов.

  Другой способ представить себе `zip()`— он превращает строки в столбцы, а столбцы в строки. Это похоже на транспонирование матрицы.

  `zip()` ленивый: элементы не будут обрабатываться, пока не будет выполнено итерирование по ним, например, с помощью цикла `for` или преобразования в `list`.

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

  - По умолчанию, `zip()` останавливается, когда заканчивается самый короткий итерируемый объект. Остальные элементы в более длинных объектах игнорируются, а результат обрезается до длины самого короткого:

        >>> list(zip(range(3), ['фу', 'фи', 'фа', 'фум']))
        [(0, 'фу'), (1, 'фи'), (2, 'фа')]

  - `zip()` часто используется в случаях, когда предполагается, что итерируемые объекты имеют одинаковую длину. В такой ситуации рекомендуется использовать опцию `strict=True`. Вывод в таком случае не будет отличаться от обычного вызова `zip()`:

        >>> list(zip(('а', 'б', 'в'), (1, 2, 3), strict=True))
        [('а', 1), ('б', 2), ('в', 3)]

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

        >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
        ...     print(item)
        ...
        (0, 'fee')
        (1, 'fi')
        (2, 'fo')
        Traceback (most recent call last):
          ...
        ValueError: zip() argument 2 is longer than argument 1

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

  - Более короткие итерируемые объекты можно дополнить постоянным значением, чтобы все объекты имели одинаковую длину. Это делается с помощью `itertools.zip_longest()`.

  Крайние случаи: При передаче одного итерируемого объекта `zip()` возвращает итератор кортежей, состоящих из одного элемента. При отсутствии аргументов возвращается пустой итератор.

  Советы и приёмы:

  - Порядок вычисления итерируемых объектов слева направо гарантирован. Это позволяет использовать идиому для кластеризации серии данных в группы длиной n с использованием `zip(*[iter(s)]*n, strict=True)`. Это повторяет тот же итератор `n` раз, чтобы каждый выходной кортеж содержал результат `n` вызовов итератора. Это приводит к разделению входных данных на блоки длиной n.

  - `zip()` в сочетании с оператором `*` можно использовать для распаковки списка:

        >>> x = [1, 2, 3]
        >>> y = [4, 5, 6]
        >>> list(zip(x, y))
        [(1, 4), (2, 5), (3, 6)]
        >>> x2, y2 = zip(*zip(x, y))
        >>> x == list(x2) and y == list(y2)
        True

  Изменено в версии 3.10: Добавлен аргумент `strict`.

__import__(name, globals=None, locals=None, fromlist=(), level=0)

  Примечание

  Это продвинутая функция, которая не нужна в повседневном программировании на Python, в отличие от `importlib.import_module()`.

  Эта функция вызывается инструкцией `import`. Её можно заменить (импортировав модуль `builtins` и присвоив `builtins.__import__`) для изменения семантики инструкции `import`, но это настоятельно не рекомендуется, так как обычно проще использовать хуки импорта (см. PEP 302) для достижения тех же целей, и это не вызывает проблем с кодом, который предполагает использование реализации импорта по умолчанию. Прямое использование `__import__()` также не рекомендуется, лучше использовать `importlib.import_module()`.

  Функция импортирует модуль name, потенциально используя заданные globals и locals для определения того, как интерпретировать имя в контексте пакета. fromlist содержит имена объектов или подмодулей, которые должны быть импортированы из модуля name. Стандартная реализация вообще не использует аргумент locals и использует аргумент globals только для определения контекста пакета инструкции `import`.

  Аргумент level указывает, следует ли использовать абсолютные или относительные импорты. `0` (значение по умолчанию) означает, что выполняются только абсолютные импорты. Положительные значения для level указывают количество родительских каталогов для поиска относительно каталога модуля, вызывающего `__import__()` (см. PEP 328 для подробностей).

  Когда переменная name имеет форму `package.module`, обычно возвращается пакет верхнего уровня (имя до первой точки), а не модуль, указанный в name. Однако, если указан непустой аргумент fromlist, возвращается модуль, указанный в name.

  Например, инструкция `import spam` приводит к байт-коду, похожему на следующий код:

      spam = __import__('spam', globals(), locals(), [], 0)

  Инструкция `import spam.ham` приводит к такому вызову:

      spam = __import__('spam.ham', globals(), locals(), [], 0)

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

  С другой стороны, инструкция `from spam.ham import eggs, sausage as saus` приводит к

      _temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
      eggs = _temp.eggs
      saus = _temp.sausage

  Здесь модуль `spam.ham` возвращается из `__import__()`. Из этого объекта извлекаются имена для импорта и присваиваются соответствующим переменным.

  Если вы просто хотите импортировать модуль (возможно, внутри пакета) по имени, используйте `importlib.import_module()`.

  Изменено в версии 3.3: Отрицательные значения для level больше не поддерживаются (что также изменяет значение по умолчанию на 0).

  Изменено в версии 3.9: Когда используются опции командной строки `-E` или `-I`, переменная окружения `PYTHONCASEOK` теперь игнорируется.

Примечания

[1]

Обратите внимание, что парсер принимает переводы строк только в стиле Unix. Если вы считываете код из файла, убедитесь, что используете режим конвертации переводов строк для их преобразования из Windows или Mac стилей.