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

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

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

abs(x)

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

aiter(async_iterable)

   Возвращает *асинхронный итератор* для *асинхронного итерируемого
   объекта*. Эквивалентно вызову "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)

   When awaited, return the next item from the given *asynchronous
   iterator*, or *default* if given and the iterator is exhausted.

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

   Вызывает метод "__anext__()" у *async_iterator*, возвращая
   *ожидаемый объект*. Ожидание этого объекта возвращает следующее
   значение итератора. Если *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(x)

   Convert an integer number to a binary string prefixed with "0b".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. Some examples:

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

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

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

   См. также "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)
class bytearray(source, encoding, errors)

   Возвращает новый массив байтов. Класс "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)
class bytes(source, encoding, errors)

   Возвращает новый объект "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(i)

   Return the string representing a character whose Unicode code point
   is the integer *i*.  For example, "chr(97)" returns the string
   "'a'", while "chr(8364)" returns the string "'€'". This is the
   inverse of "ord()".

   The valid range for the argument is from 0 through 1,114,111
   (0x10FFFF in base 16).  "ValueError" will be raised if *i* is
   outside that range.

@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: Методы класса больше не могут оборачивать
   другие *дескрипторы*, такие как "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" (строки документации также удаляются).

   This function raises "SyntaxError" if the compiled source is
   invalid, and "ValueError" if the source contains null bytes.

   Если вы хотите проанализировать 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(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

   Create a new dictionary.  The "dict" object is the dictionary
   class. See "dict" and Mapping Types --- dict for documentation
   about this class.

   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(expression, globals=None, locals=None)

   Параметры:
      * **expression** ("str" | code object) -- Выражение Python.

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

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

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

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

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

     This function executes arbitrary code. Calling it with user-
     supplied input may lead to security vulnerabilities.

   The *expression* argument is parsed and evaluated as a Python
   expression (technically speaking, a condition list) using the
   *globals* and *locals* dictionaries as global and local namespace.
   If the *globals* dictionary is present and does not contain a value
   for the key "__builtins__", a reference to the dictionary of the
   built-in module "builtins" is inserted under that key before
   *expression* is parsed.  That way you can control what builtins are
   available to the executed code by inserting your own "__builtins__"
   dictionary into *globals* before passing it to "eval()".  If the
   *locals* dictionary is omitted it defaults to the *globals*
   dictionary.  If both dictionaries are omitted, the expression is
   executed with the *globals* and *locals* in the environment where
   "eval()" is called.  Note, *eval()* does not have access to the
   *nested scopes* (non-locals) in the enclosing environment.

   Пример:

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

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

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

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

   See "ast.literal_eval()" for a function that can safely evaluate
   strings with expressions containing only literals.

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

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

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

     This function executes arbitrary code. Calling it with user-
     supplied input may lead to security vulnerabilities.

   This function supports dynamic execution of Python code. *object*
   must be either a string or a code object.  If it is a string, the
   string is parsed as a suite of Python statements which is then
   executed (unless a syntax error occurs). [1] If it is a code
   object, it is simply executed.  In all cases, the code that's
   executed is expected to be valid as file input (see the section
   Файловый ввод in the Reference Manual). Be aware that the
   "nonlocal", "yield",  and "return" statements may not be used
   outside of function definitions even within the context of code
   passed to the "exec()" function. The return value is "None".

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

   Примечание:

     Most users should just pass a *globals* argument and never
     *locals*. If exec gets two separate objects as *globals* and
     *locals*, the code will be executed as if it were embedded in a
     class definition.

   If the *globals* dictionary does not contain a value for the key
   "__builtins__", a reference to the dictionary of the built-in
   module "builtins" is inserted under that key.  That way you can
   control what builtins are available to the executed code by
   inserting your own "__builtins__" dictionary into *globals* before
   passing it to "exec()".

   The *closure* argument specifies a closure--a tuple of cellvars.
   It's only valid when the *object* is a code object containing free
   variables. The length of the tuple must exactly match the number of
   free variables referenced by the code object.

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

   Примечание:

     The built-in functions "globals()" and "locals()" return the
     current global and local dictionary, respectively, which may be
     useful to pass around for use as the second and third argument to
     "exec()".

   Примечание:

     The default *locals* act as described for function "locals()"
     below: modifications to the default *locals* dictionary should
     not be attempted. Pass an explicit *locals* dictionary if you
     need to see effects of the code on *locals* after function
     "exec()" returns.

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

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=set())

   Return a new "frozenset" object, optionally with elements taken
   from *iterable*.  "frozenset" is a built-in class.  See "frozenset"
   and Set Types --- set, frozenset for documentation about this
   class.

   Для других контейнеров см. встроенные классы "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(x)

   Convert an integer number to a lowercase hexadecimal string
   prefixed with "0x". If *x* is not a Python "int" object, it has to
   define an "__index__()" method that returns an integer. Some
   examples:

   >>> 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(object)
iter(object, sentinel)

   Return an *iterator* object.  The first argument is interpreted
   very differently depending on the presence of the second argument.
   Without a second argument, *object* must be a collection object
   which supports the *iterable* protocol (the "__iter__()" method),
   or it must support the sequence protocol (the "__getitem__()"
   method with integer arguments starting at "0").  If it does not
   support either of those protocols, "TypeError" is raised. If the
   second argument, *sentinel*, is given, then *object* must be a
   callable object.  The iterator created in this case will call
   *object* with no arguments for each call to its "__next__()"
   method; if the value returned is equal to *sentinel*,
   "StopIteration" will be raised, otherwise the value will be
   returned.

   См. также 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(s)

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

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

class list
class list(iterable)

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

locals()

   Update and return a dictionary representing the current local
   symbol table. Free variables are returned by "locals()" when it is
   called in function blocks, but not in class blocks. Note that at
   the module level, "locals()" and "globals()" are the same
   dictionary.

   Примечание:

     The contents of this dictionary should not be modified; changes
     may not affect the values of local and free variables used by the
     interpreter.

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)

   Retrieve the next item from the *iterator* by calling its
   "__next__()" method.  If *default* is given, it is returned if the
   iterator is exhausted, otherwise "StopIteration" is raised.

class object

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

   Примечание:

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

oct(x)

   Convert an integer number to an octal string prefixed with "0o".
   The result is a valid Python expression. If *x* is not a Python
   "int" object, it has to define an "__index__()" method that returns
   an integer. For example:

   >>> 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".
   См. Reading and Writing Files для получения дополнительных примеров
   использования этой функции.

   Аргумент *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(c)

   Given a string representing one Unicode character, return an
   integer representing the Unicode code point of that character.  For
   example, "ord('a')" returns the integer "97" and "ord('€')" (Euro
   sign) returns "8364".  This is the inverse of "chr()".

pow(base, exp, mod=None)

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

   The arguments must have numeric types.  With mixed operand types,
   the coercion rules for binary arithmetic operators apply.  For
   "int" operands, the result has the same type as the operands (after
   coercion) unless the second argument is negative; in that case, all
   arguments are converted to float and a float result is delivered.
   For example, "pow(10, 2)" returns "100", but "pow(10, -2)" returns
   "0.01".  For a negative base of type "int" or "float" and a non-
   integral exponent, a complex result is delivered.  For example,
   "pow(-9, 0.5)" returns a value close to "3j". Whereas, for a
   negative base of type "int" or "float" with an integral exponent, a
   float result is delivered. For example, "pow(-9, 2.0)" returns
   "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" — функцию удаления.

   If given, *doc* will be the docstring of the property attribute.
   Otherwise, the property will copy *fget*'s docstring (if it
   exists).  This makes it possible to create read-only properties
   easily using "property()" as a *decorator*:

      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: Строки документации объектов свойств теперь
   можно изменять.

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(seq)

   Return a reverse *iterator*.  *seq* must be an object which has a
   "__reversed__()" method or supports the sequence protocol (the
   "__len__()" method and the "__getitem__()" method with integer
   arguments starting at "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
class set(iterable)

   Return a new "set" object, optionally with elements taken from
   *iterable*.  "set" is a built-in class.  See "set" and Set Types
   --- set, frozenset for documentation about this class.

   Для других контейнеров см. встроенные классы "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".

   start

   stop

   step

      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.

   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()" гарантирует стабильность. Сортировка
   является стабильной, если она гарантирует сохранение относительного
   порядка элементов, которые сравниваются как равные --- это полезно
   для сортировки в несколько проходов (например, сортировка по
   отделу, затем по уровню зарплаты).

   The sort algorithm uses only "<" comparisons between items.  While
   defining an "__lt__()" method will suffice for sorting, **PEP 8**
   recommends that all six rich comparisons be implemented.  This will
   help avoid bugs when using the same data with other ordering tools
   such as "max()" that rely on a different underlying method.
   Implementing all six comparisons also helps avoid confusion for
   mixed type comparisons which can call reflected the "__gt__()"
   method.

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

@staticmethod

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

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

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

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

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

   Static methods in Python are similar to those found in Java or C++.
   Also, see "classmethod()" for a variant that is useful for creating
   alternate class constructors.

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

      def regular_function():
          ...

      class C:
          method = staticmethod(regular_function)

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

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

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

   Возвращает значение типа "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: Summation of floats switched to an
   algorithm that gives higher accuracy on most builds.

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*. В иерархии
   классов с одиночным наследованием *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
class tuple(iterable)

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

class type(object)
class type(name, bases, dict, **kwds)

   С одним аргументом возвращает тип *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*).

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

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

vars()
vars(object)

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

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

   Without an argument, "vars()" acts like "locals()".  Note, the
   locals dictionary is only useful for reads since updates to the
   locals dictionary are ignored.

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

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
   предлагает три разных подхода к решению этой проблемы.

   * By default, "zip()" stops when the shortest iterable is
     exhausted. It will ignore the remaining items in the longer
     iterables, cutting off the result to the length of the shortest
     iterable:

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

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

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

     Unlike the default behavior, it raises a "ValueError" if one
     iterable is exhausted before the others:

     >>> 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 стилей.
