functions.md

1> **Источник:** https://python-all.ru/3.9/library/functions.html2>3> «Документация Python на русском» – неофициальный перевод официальной документации Python: версии от 2.6 до 3.16, полнотекстовый поиск, английский оригинал рядом с переводом. Эта Markdown-версия страницы предназначена для работы с LLM: вставьте её в ChatGPT, Claude или Cursor.45---67# Встроенные функции89Интерпретатор Python включает ряд встроенных функций и типов, которые доступны всегда. Они перечислены здесь в алфавитном порядке.1011|  |  | Встроенные функции |  |  |12| --- | --- | --- | --- | --- |13| [`abs()`](https://python-all.ru/3.9/library/functions.html#abs) | [`delattr()`](https://python-all.ru/3.9/library/functions.html#delattr) | [`hash()`](https://python-all.ru/3.9/library/functions.html#hash) | [`memoryview()`](https://python-all.ru/3.9/library/functions.html#func-memoryview) | [`set()`](https://python-all.ru/3.9/library/functions.html#func-set) |14| [`all()`](https://python-all.ru/3.9/library/functions.html#all) | [`dict()`](https://python-all.ru/3.9/library/functions.html#func-dict) | [`help()`](https://python-all.ru/3.9/library/functions.html#help) | [`min()`](https://python-all.ru/3.9/library/functions.html#min) | [`setattr()`](https://python-all.ru/3.9/library/functions.html#setattr) |15| [`any()`](https://python-all.ru/3.9/library/functions.html#any) | [`dir()`](https://python-all.ru/3.9/library/functions.html#dir) | [`hex()`](https://python-all.ru/3.9/library/functions.html#hex) | [`next()`](https://python-all.ru/3.9/library/functions.html#next) | [`slice()`](https://python-all.ru/3.9/library/functions.html#slice) |16| [`ascii()`](https://python-all.ru/3.9/library/functions.html#ascii) | [`divmod()`](https://python-all.ru/3.9/library/functions.html#divmod) | [`id()`](https://python-all.ru/3.9/library/functions.html#id) | [`object()`](https://python-all.ru/3.9/library/functions.html#object) | [`sorted()`](https://python-all.ru/3.9/library/functions.html#sorted) |17| [`bin()`](https://python-all.ru/3.9/library/functions.html#bin) | [`enumerate()`](https://python-all.ru/3.9/library/functions.html#enumerate) | [`input()`](https://python-all.ru/3.9/library/functions.html#input) | [`oct()`](https://python-all.ru/3.9/library/functions.html#oct) | [`staticmethod()`](https://python-all.ru/3.9/library/functions.html#staticmethod) |18| [`bool()`](https://python-all.ru/3.9/library/functions.html#bool) | [`eval()`](https://python-all.ru/3.9/library/functions.html#eval) | [`int()`](https://python-all.ru/3.9/library/functions.html#int) | [`open()`](https://python-all.ru/3.9/library/functions.html#open) | [`str()`](https://python-all.ru/3.9/library/functions.html#func-str) |19| [`breakpoint()`](https://python-all.ru/3.9/library/functions.html#breakpoint) | [`exec()`](https://python-all.ru/3.9/library/functions.html#exec) | [`isinstance()`](https://python-all.ru/3.9/library/functions.html#isinstance) | [`ord()`](https://python-all.ru/3.9/library/functions.html#ord) | [`sum()`](https://python-all.ru/3.9/library/functions.html#sum) |20| [`bytearray()`](https://python-all.ru/3.9/library/functions.html#func-bytearray) | [`filter()`](https://python-all.ru/3.9/library/functions.html#filter) | [`issubclass()`](https://python-all.ru/3.9/library/functions.html#issubclass) | [`pow()`](https://python-all.ru/3.9/library/functions.html#pow) | [`super()`](https://python-all.ru/3.9/library/functions.html#super) |21| [`bytes()`](https://python-all.ru/3.9/library/functions.html#func-bytes) | [`float()`](https://python-all.ru/3.9/library/functions.html#float) | [`iter()`](https://python-all.ru/3.9/library/functions.html#iter) | [`print()`](https://python-all.ru/3.9/library/functions.html#print) | [`tuple()`](https://python-all.ru/3.9/library/functions.html#func-tuple) |22| [`callable()`](https://python-all.ru/3.9/library/functions.html#callable) | [`format()`](https://python-all.ru/3.9/library/functions.html#format) | [`len()`](https://python-all.ru/3.9/library/functions.html#len) | [`property()`](https://python-all.ru/3.9/library/functions.html#property) | [`type()`](https://python-all.ru/3.9/library/functions.html#type) |23| [`chr()`](https://python-all.ru/3.9/library/functions.html#chr) | [`frozenset()`](https://python-all.ru/3.9/library/functions.html#func-frozenset) | [`list()`](https://python-all.ru/3.9/library/functions.html#func-list) | [`range()`](https://python-all.ru/3.9/library/functions.html#func-range) | [`vars()`](https://python-all.ru/3.9/library/functions.html#vars) |24| [`classmethod()`](https://python-all.ru/3.9/library/functions.html#classmethod) | [`getattr()`](https://python-all.ru/3.9/library/functions.html#getattr) | [`locals()`](https://python-all.ru/3.9/library/functions.html#locals) | [`repr()`](https://python-all.ru/3.9/library/functions.html#repr) | [`zip()`](https://python-all.ru/3.9/library/functions.html#zip) |25| [`compile()`](https://python-all.ru/3.9/library/functions.html#compile) | [`globals()`](https://python-all.ru/3.9/library/functions.html#globals) | [`map()`](https://python-all.ru/3.9/library/functions.html#map) | [`reversed()`](https://python-all.ru/3.9/library/functions.html#reversed) | [`__import__()`](https://python-all.ru/3.9/library/functions.html#__import__) |26| [`complex()`](https://python-all.ru/3.9/library/functions.html#complex) | [`hasattr()`](https://python-all.ru/3.9/library/functions.html#hasattr) | [`max()`](https://python-all.ru/3.9/library/functions.html#max) | [`round()`](https://python-all.ru/3.9/library/functions.html#round) |  |2728#### `abs(x)`2930Возвращает абсолютное значение числа. Аргументом может быть целое число, число с плавающей запятой или объект, реализующий [`__abs__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__abs__). Если аргумент – комплексное число, возвращается его модуль.3132#### `all(iterable)`3334Возвращает `True`, если все элементы *iterable* истинны (или если iterable пуст). Эквивалентно:3536```python37def all(iterable):38    for element in iterable:39        if not element:40            return False41    return True42```4344#### `any(iterable)`4546Возвращает `True`, если хотя бы один элемент *iterable* истинен. Если iterable пуст, возвращает `False`. Эквивалентно:4748```python49def any(iterable):50    for element in iterable:51        if element:52            return True53    return False54```5556#### `ascii(object)`5758Как и [`repr()`](https://python-all.ru/3.9/library/functions.html#repr), возвращает строку, содержащую печатное представление объекта, но экранирует не-ASCII символы в строке, возвращаемой [`repr()`](https://python-all.ru/3.9/library/functions.html#repr), с помощью управляющих последовательностей `\x`, `\u` или `\U`. Это генерирует строку, похожую на возвращаемую [`repr()`](https://python-all.ru/3.9/library/functions.html#repr) в Python 2.5960#### `bin(x)`6162Преобразует целое число в двоичную строку с префиксом «0b». Результат является корректным выражением Python. Если *x* не является объектом Python [`int`](https://python-all.ru/3.9/library/functions.html#int), он должен определять метод [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), возвращающий целое число. Несколько примеров:6364```python65>>> bin(3)66'0b11'67>>> bin(-10)68'-0b1010'69```7071Если префикс «0b» желателен или нет, можно использовать любой из следующих способов.7273```python74>>> format(14, '#b'), format(14, 'b')75('0b1110', '1110')76>>> f'{14:#b}', f'{14:b}'77('0b1110', '1110')78```7980См. также [`format()`](https://python-all.ru/3.9/library/functions.html#format) для получения дополнительной информации.8182#### `class bool([x])`8384Возвращает логическое значение, то есть одно из `True` или `False`. *x* преобразуется с использованием стандартной [процедуры проверки истинности](https://python-all.ru/3.9/library/stdtypes.html#truth). Если *x* равно false или опущено, возвращается `False`; в противном случае возвращается `True`. Класс [`bool`](https://python-all.ru/3.9/library/functions.html#bool) является подклассом [`int`](https://python-all.ru/3.9/library/functions.html#int) (см. [Числовые типы – int, float, complex](https://python-all.ru/3.9/library/stdtypes.html#typesnumeric)). Он не может быть унаследован далее. Его единственными экземплярами являются `False` и `True` (см. [Логические значения](https://python-all.ru/3.9/library/stdtypes.html#bltin-boolean-values)).8586Изменено в версии 3.7: *x* теперь является параметром только для позиционной передачи.8788#### `breakpoint(*args, **kws)`8990Эта функция погружает вас в отладчик в точке вызова. А именно, она вызывает [`sys.breakpointhook()`](https://python-all.ru/3.9/library/sys.html#sys.breakpointhook), передавая `args` и `kws` напрямую. По умолчанию `sys.breakpointhook()` вызывает [`pdb.set_trace()`](https://python-all.ru/3.9/library/pdb.html#pdb.set_trace) без аргументов. В этом случае это просто удобная функция, чтобы не нужно было явно импортировать [`pdb`](https://python-all.ru/3.9/library/pdb.html#module-pdb) или писать много кода для входа в отладчик. Однако [`sys.breakpointhook()`](https://python-all.ru/3.9/library/sys.html#sys.breakpointhook) может быть установлена в другую функцию, и [`breakpoint()`](https://python-all.ru/3.9/library/functions.html#breakpoint) автоматически вызовет её, позволяя войти в отладчик по выбору.9192Вызывает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `builtins.breakpoint` с аргументом `breakpointhook`.9394Добавлено в версии 3.7.9596#### `class bytearray([source[, encoding[, errors]]])`9798Возвращает новый массив байтов. Класс [`bytearray`](https://python-all.ru/3.9/library/stdtypes.html#bytearray) представляет собой изменяемую последовательность целых чисел в диапазоне 0 \<= x \< 256. Он поддерживает большинство обычных методов изменяемых последовательностей, описанных в разделе [Изменяемые типы последовательностей](https://python-all.ru/3.9/library/stdtypes.html#typesseq-mutable), а также большинство методов, которые есть у типа [`bytes`](https://python-all.ru/3.9/library/stdtypes.html#bytes) (см. [Операции с байтами и bytearray](https://python-all.ru/3.9/library/stdtypes.html#bytes-methods)).99100Необязательный параметр *source* можно использовать для инициализации массива несколькими разными способами:101102- Если это *строка*, необходимо также указать параметры *кодировка* (и, опционально, *ошибки*); затем [`bytearray()`](https://python-all.ru/3.9/library/stdtypes.html#bytearray) преобразует строку в байты с помощью [`str.encode()`](https://python-all.ru/3.9/library/stdtypes.html#str.encode).103- Если это *целое число*, массив будет иметь указанный размер и будет инициализирован нулевыми байтами.104- Если это объект, соответствующий [буферному интерфейсу](https://python-all.ru/3.9/c-api/buffer.html#bufferobjects), для инициализации массива байтов будет использоваться буфер только для чтения этого объекта.105- Если это *итерируемый объект*, он должен быть итерируемым объектом, содержащим целые числа в диапазоне `0 <= x < 256`, которые используются в качестве начального содержимого массива.106107Без аргументов создаётся массив размера 0.108109См. также [Типы бинарных последовательностей – bytes, bytearray, memoryview](https://python-all.ru/3.9/library/stdtypes.html#binaryseq) и [Объекты bytearray](https://python-all.ru/3.9/library/stdtypes.html#typebytearray).110111#### `class bytes([source[, encoding[, errors]]])`112113Возвращает новый объект «bytes», который является неизменяемой последовательностью целых чисел в диапазоне `0 <= x < 256`. [`bytes`](https://python-all.ru/3.9/library/stdtypes.html#bytes) – это неизменяемая версия [`bytearray`](https://python-all.ru/3.9/library/stdtypes.html#bytearray) – он имеет те же неизменяющие методы и то же поведение при индексации и срезах.114115Соответственно, аргументы конструктора интерпретируются так же, как для [`bytearray()`](https://python-all.ru/3.9/library/stdtypes.html#bytearray).116117Объекты bytes также можно создавать с помощью литералов, см. [Литералы строк и bytes](https://python-all.ru/3.9/reference/lexical_analysis.html#strings).118119См. также [Типы бинарных последовательностей – bytes, bytearray, memoryview](https://python-all.ru/3.9/library/stdtypes.html#binaryseq), [Объекты bytes](https://python-all.ru/3.9/library/stdtypes.html#typebytes) и [Операции с байтами и bytearray](https://python-all.ru/3.9/library/stdtypes.html#bytes-methods).120121#### `callable(object)`122123Возвращает [`True`](https://python-all.ru/3.9/library/constants.html#True), если аргумент *object* является вызываемым, и [`False`](https://python-all.ru/3.9/library/constants.html#False) в противном случае. Если эта функция возвращает `True`, вызов всё ещё может завершиться ошибкой, но если возвращается `False`, вызвать *object* никогда не удастся. Обратите внимание, что классы вызываемы (вызов класса возвращает новый экземпляр); экземпляры вызываемы, если их класс имеет метод [`__call__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__call__).124125Новое в версии 3.2: Эта функция была сначала удалена в Python 3.0, а затем снова добавлена в Python 3.2.126127#### `chr(i)`128129Возвращает строку, представляющую символ, кодовая точка Unicode которого равна целому числу *i*. Например, `chr(97)` возвращает строку `'a'`, а `chr(8364)` возвращает `'€'`. Это обратная операция к [`ord()`](https://python-all.ru/3.9/library/functions.html#ord).130131Допустимый диапазон аргумента – от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе). [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError) будет возбуждено, если *i* выходит за этот диапазон.132133#### `@classmethod`134135Преобразует метод в метод класса.136137Метод класса получает класс в качестве неявного первого аргумента, точно так же, как метод экземпляра получает экземпляр. Чтобы объявить метод класса, используйте эту идиому:138139```python140class C:141    @classmethod142    def f(cls, arg1, arg2): ...143```144145Форма `@classmethod` является функцией [декоратора](https://python-all.ru/3.9/glossary.html#term-decorator) – подробнее см. в [Function definitions](https://python-all.ru/3.9/reference/compound_stmts.html#function).146147Метод класса можно вызывать как через класс (например, `C.f()`), так и через экземпляр (например, `C().f()`). Экземпляр при этом игнорируется, учитывается только его класс. Если метод класса вызывается для производного класса, в качестве подразумеваемого первого аргумента передаётся объект производного класса.148149Методы классов отличаются от статических методов C++ или Java. Если нужны именно статические методы, см. [`staticmethod()`](https://python-all.ru/3.9/library/functions.html#staticmethod) в этом разделе. Дополнительную информацию о методах классов можно найти в разделе [Стандартная иерархия типов](https://python-all.ru/3.9/reference/datamodel.html#types).150151Изменено в версии 3.9: Теперь методы классов могут оборачивать другие [дескрипторы](https://python-all.ru/3.9/glossary.html#term-descriptor), например [`property()`](https://python-all.ru/3.9/library/functions.html#property).152153#### `compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`154155Компилирует *source* в объект кода или AST. Объекты кода могут выполняться с помощью [`exec()`](https://python-all.ru/3.9/library/functions.html#exec) или [`eval()`](https://python-all.ru/3.9/library/functions.html#eval). *source* может быть обычной строкой, строкой байтов или объектом AST. Обратитесь к документации модуля [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast) за информацией о работе с объектами AST.156157Аргумент *filename* должен указывать файл, из которого был прочитан код; если код был прочитан не из файла, следует передать какое-либо узнаваемое значение (обычно используется `'<string>'`).158159Аргумент *mode* определяет, какой код следует компилировать; он может быть равен `'exec'`, если *source* состоит из последовательности инструкций, `'eval'`, если из одного выражения, или `'single'`, если из одной интерактивной инструкции (в последнем случае будут выведены выражения, которые вычисляются в значение, отличное от `None`).160161Необязательные аргументы *flags* и *dont\_inherit* управляют тем, какие [параметры компилятора](https://python-all.ru/3.9/library/ast.html#ast-compiler-flags) следует активировать, а какие [будущие возможности](https://python-all.ru/3.9/reference/simple_stmts.html#future) разрешить. Если ни один из них не указан (или оба равны нулю), код компилируется с теми же флагами, что и код, вызывающий [`compile()`](https://python-all.ru/3.9/library/functions.html#compile). Если аргумент *flags* передан, а *dont\_inherit* – нет (или равен нулю), то параметры компилятора и будущие инструкции, заданные аргументом *flags*, используются в дополнение к тем, которые использовались бы в любом случае. Если *dont\_inherit* – ненулевое целое, то аргументом *flags* являются сами флаги – флаги (будущие возможности и параметры компилятора) в окружающем коде игнорируются.162163Параметры компилятора и будущие инструкции задаются битами, которые можно объединять побитовым ИЛИ, чтобы указать несколько параметров. Битовое поле, необходимое для указания конкретной будущей возможности, можно найти как атрибут `compiler_flag` у экземпляра `_Feature` в модуле [`__future__`](https://python-all.ru/3.9/library/__future__.html#module-__future__). [Флаги компилятора](https://python-all.ru/3.9/library/ast.html#ast-compiler-flags) можно найти в модуле [`ast`](https://python-all.ru/3.9/library/ast.html#module-ast), с префиксом `PyCF_`.164165Аргумент *optimize* задаёт уровень оптимизации компилятора; значение по умолчанию `-1` выбирает уровень оптимизации интерпретатора, заданный опциями [`-O`](https://python-all.ru/3.9/using/cmdline.html#cmdoption-o). Явные уровни: `0` (без оптимизации; `__debug__` истинно), `1` (утверждения удалены, `__debug__` ложно) или `2` (строки документации также удалены).166167Эта функция возбуждает [`SyntaxError`](https://python-all.ru/3.9/library/exceptions.html#SyntaxError), если скомпилированный исходный код некорректен, и [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError), если исходный код содержит нулевые байты.168169Если требуется разобрать код Python в его AST-представление, см. [`ast.parse()`](https://python-all.ru/3.9/library/ast.html#ast.parse).170171Возбуждает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `compile` с аргументами `source` и `filename`. Это событие также может быть возбуждено при неявной компиляции.172173> **Примечание**174>175> При компиляции строки с многострочным кодом в режиме `'single'` или `'eval'` входные данные должны завершаться как минимум одним символом новой строки. Это необходимо для облегчения определения незавершённых и завершённых инструкций в модуле [`code`](https://python-all.ru/3.9/library/code.html#module-code).176177> **Предупреждение**178>179> Можно привести к аварийному завершению интерпретатора Python с помощью достаточно длинной/сложной строки при компиляции в объект AST из-за ограничений глубины стека в компиляторе AST Python.180181Изменено в версии 3.2: Разрешено использование символов новой строки Windows и Mac. Также ввод в режиме `'exec'` больше не должен заканчиваться символом новой строки. Добавлен параметр *optimize*.182183Изменено в версии 3.5: Ранее возбуждалось исключение [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError), когда в *source* встречались нулевые байты.184185Новое в версии 3.8: Теперь `ast.PyCF_ALLOW_TOP_LEVEL_AWAIT` может передаваться в flags для включения поддержки `await`, `async for` и `async with` верхнего уровня.186187#### `class complex([real[, imag]])`188189Возвращает комплексное число со значением *real* + *imag*\*1j или преобразует строку или число в комплексное число. Если первый параметр – строка, она интерпретируется как комплексное число, и функция должна вызываться без второго параметра. Второй параметр не может быть строкой. Каждый аргумент может иметь любой числовой тип (включая комплексный). Если *imag* опущен, по умолчанию он равен нулю, и конструктор работает как числовое преобразование, аналогично [`int`](https://python-all.ru/3.9/library/functions.html#int) и [`float`](https://python-all.ru/3.9/library/functions.html#float). Если оба аргумента опущены, возвращается `0j`.190191Для обычного объекта Python `x` метод `complex(x)` делегирует вызов `x.__complex__()`. Если `__complex__()` не определён, то используется [`__float__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__float__). Если `__float__()` не определён, то используется [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__).192193> **Примечание**194>195> При преобразовании из строки вокруг центрального оператора `+` или `-` не должно быть пробелов. Например, `complex('1+2j')` корректно, а `complex('1 + 2j')` вызывает [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError).196197Тип complex описан в разделе [Числовые типы – int, float, complex](https://python-all.ru/3.9/library/stdtypes.html#typesnumeric).198199Изменено в версии 3.6: Разрешена группировка цифр с помощью подчёркиваний, как в литералах кода.200201Изменено в версии 3.8: Используется [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), если [`__complex__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__complex__) и [`__float__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__float__) не определены.202203#### `delattr(object, name)`204205Это родственная функция для [`setattr()`](https://python-all.ru/3.9/library/functions.html#setattr). Аргументами являются объект и строка. Строка должна быть именем одного из атрибутов объекта. Функция удаляет указанный атрибут, если объект это позволяет. Например, `delattr(x, 'foobar')` эквивалентно `del x.foobar`.206207#### `class dict(**kwarg)`208209#### `class dict(mapping, **kwarg)`210211#### `class dict(iterable, **kwarg)`212213Создаёт новый словарь. Объект [`dict`](https://python-all.ru/3.9/library/stdtypes.html#dict) – это класс словаря. Документацию по этому классу см. в [`dict`](https://python-all.ru/3.9/library/stdtypes.html#dict) и [Типы отображений – dict](https://python-all.ru/3.9/library/stdtypes.html#typesmapping).214215О других контейнерах см. встроенные классы [`list`](https://python-all.ru/3.9/library/stdtypes.html#list), [`set`](https://python-all.ru/3.9/library/stdtypes.html#set) и [`tuple`](https://python-all.ru/3.9/library/stdtypes.html#tuple), а также модуль [`collections`](https://python-all.ru/3.9/library/collections.html#module-collections).216217#### `dir([object])`218219Без аргументов возвращает список имён в текущей локальной области видимости. Если передан аргумент, пытается вернуть список допустимых атрибутов этого объекта.220221Если у объекта есть метод с именем [`__dir__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__dir__), этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, реализующим собственную функцию [`__getattr__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getattr__) или [`__getattribute__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getattribute__), настраивать способ, которым [`dir()`](https://python-all.ru/3.9/library/functions.html#dir) сообщает их атрибуты.222223Если объект не предоставляет [`__dir__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__dir__), функция старается собрать информацию из атрибута [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__) объекта, если он определён, и из объекта его типа. Полученный список не обязательно полный и может быть неточным, если объект имеет пользовательский [`__getattr__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getattr__).224225Механизм [`dir()`](https://python-all.ru/3.9/library/functions.html#dir) по умолчанию ведёт себя по-разному для разных типов объектов, поскольку он пытается выдать наиболее релевантную, а не полную информацию:226227- Если объект является модулем, список содержит имена атрибутов этого модуля.228- Если объект является типом или классом, список содержит имена его атрибутов, а также (рекурсивно) атрибутов его базовых классов.229- В остальных случаях список содержит имена атрибутов объекта, имена атрибутов его класса и (рекурсивно) атрибутов базовых классов его класса.230231Полученный список сортируется по алфавиту. Например:232233```python234>>> import struct235>>> dir()   # показать имена в пространстве имён модуля  236['__builtins__', '__name__', 'struct']237>>> dir(struct)   # показать имена в модуле struct 238['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',239 '__initializing__', '__loader__', '__name__', '__package__',240 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',241 'unpack', 'unpack_from']242>>> class Shape:243...     def __dir__(self):244...         return ['area', 'perimeter', 'location']245>>> s = Shape()246>>> dir(s)247['area', 'location', 'perimeter']248```249250> **Примечание**251>252> Поскольку [`dir()`](https://python-all.ru/3.9/library/functions.html#dir) предоставляется в первую очередь для удобства использования в интерактивной оболочке, он старается выдать интересный набор имён скорее, чем строго или последовательно определённый, и его детальное поведение может меняться от версии к версии. Например, атрибуты метакласса не входят в результирующий список, когда аргументом является класс.253254#### `divmod(a, b)`255256Принимает два (не комплексных) числа в качестве аргументов и возвращает пару чисел, состоящую из их частного и остатка при целочисленном делении. Для смешанных типов операндов применяются правила бинарных арифметических операторов. Для целых чисел результат такой же, как `(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)`.257258#### `enumerate(iterable, start=0)`259260Возвращает объект enumerate. *iterable* должен быть последовательностью, [итератором](https://python-all.ru/3.9/glossary.html#term-iterator) или другим объектом, поддерживающим итерацию. Метод [`__next__()`](https://python-all.ru/3.9/library/stdtypes.html#iterator.__next__) итератора, возвращаемого[`enumerate()`](https://python-all.ru/3.9/library/functions.html#enumerate), возвращает кортеж, содержащий счётчик (начиная с *start*, который по умолчанию равен 0) и значения, полученные при итерации по *iterable*.261262```python263>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']264>>> list(enumerate(seasons))265[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]266>>> list(enumerate(seasons, start=1))267[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]268```269270Эквивалентно следующему:271272```python273def enumerate(sequence, start=0):274    n = start275    for elem in sequence:276        yield n, elem277        n += 1278```279280#### `eval(expression[, globals[, locals]])`281282Аргументами являются строка и необязательные globals и locals. Если они указаны, *globals* должен быть словарём. Если указаны, *locals* может быть любым отображением (mapping).283284Аргумент *expression* разбирается и вычисляется как выражение Python (технически говоря, список условий) с использованием словарей *globals* и *locals* в качестве глобального и локального пространства имён. Если словарь *globals* присутствует и не содержит значения для ключа `__builtins__`, то под этим ключом перед разбором *expression* вставляется ссылка на словарь встроенного модуля [`builtins`](https://python-all.ru/3.9/library/builtins.html#module-builtins). Это означает, что *expression* обычно имеет полный доступ к стандартному модулю [`builtins`](https://python-all.ru/3.9/library/builtins.html#module-builtins), а ограниченные окружения распространяются. Если словарь *locals* опущен, он по умолчанию равен словарю *globals*. Если оба словаря опущены, выражение выполняется с *globals* и *locals* из окружения, где вызвана [`eval()`](https://python-all.ru/3.9/library/functions.html#eval). Обратите внимание, *eval()* не имеет доступа к [вложенным областям видимости](https://python-all.ru/3.9/glossary.html#term-nested-scope) (non-locals) в окружающем окружении.285286Возвращаемое значение – результат вычисленного выражения. Синтаксические ошибки сообщаются как исключения. Пример:287288```python289>>> x = 1290>>> eval('x+1')2912292```293294Эту функцию также можно использовать для выполнения произвольных объектов кода (например, созданных с помощью [`compile()`](https://python-all.ru/3.9/library/functions.html#compile)). В этом случае вместо строки передаётся объект кода. Если объект кода был скомпилирован с `'exec'` в качестве аргумента *mode*, то возвращаемое значение [`eval()`](https://python-all.ru/3.9/library/functions.html#eval) будет `None`.295296Подсказки: динамическое выполнение инструкций поддерживается функцией [`exec()`](https://python-all.ru/3.9/library/functions.html#exec). Функции [`globals()`](https://python-all.ru/3.9/library/functions.html#globals) и [`locals()`](https://python-all.ru/3.9/library/functions.html#locals) возвращают текущий глобальный и локальный словари соответственно, что может быть полезно для передачи в [`eval()`](https://python-all.ru/3.9/library/functions.html#eval) или [`exec()`](https://python-all.ru/3.9/library/functions.html#exec).297298См. [`ast.literal_eval()`](https://python-all.ru/3.9/library/ast.html#ast.literal_eval): функция, которая может безопасно вычислять строки с выражениями, содержащими только литералы.299300Вызывает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `exec` с объектом кода в качестве аргумента. Также могут возникать события компиляции кода.301302#### `exec(object[, globals[, locals]])`303304Эта функция поддерживает динамическое выполнение кода Python. *object* должен быть строкой или объектом кода. Если это строка, она разбирается как набор инструкций Python, который затем выполняется (если не возникает синтаксическая ошибка). [1](https://python-all.ru/3.9/library/functions.html#id2) Если это объект кода, он просто выполняется. В любом случае выполняемый код должен быть корректным как файловый ввод (см. раздел [Файловый ввод](https://python-all.ru/3.9/reference/toplevel_components.html#file-input) в справочном руководстве). Имейте в виду, что инструкции [`nonlocal`](https://python-all.ru/3.9/reference/simple_stmts.html#nonlocal), [`yield`](https://python-all.ru/3.9/reference/simple_stmts.html#yield) и [`return`](https://python-all.ru/3.9/reference/simple_stmts.html#return) не могут использоваться вне определений функций, даже в контексте кода, переданного функции [`exec()`](https://python-all.ru/3.9/library/functions.html#exec). Возвращаемое значение – `None`.305306Во всех случаях, если необязательные части опущены, код выполняется в текущей области видимости. Если указан только *globals*, он должен быть словарём (и не подклассом словаря), который будет использоваться как для глобальных, так и для локальных переменных. Если указаны *globals* и *locals*, они используются для глобальных и локальных переменных соответственно. Если указан, *locals* может быть любым отображающим объектом (mapping object). Помните, что на уровне модуля globals и locals – это один и тот же словарь. Если exec получает два отдельных объекта в качестве *globals* и *locals*, код будет выполняться так, как если бы он был встроен в определение класса.307308Если словарь *globals* не содержит значение для ключа `__builtins__`, под этот ключ вставляется ссылка на словарь встроенного модуля [`builtins`](https://python-all.ru/3.9/library/builtins.html#module-builtins). Таким образом можно контролировать, какие встроенные объекты доступны выполняемому коду, вставив собственный словарь `__builtins__` в *globals* перед передачей его в [`exec()`](https://python-all.ru/3.9/library/functions.html#exec).309310Вызывает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `exec` с объектом кода в качестве аргумента. Также могут возникать события компиляции кода.311312> **Примечание**313>314> Встроенные функции [`globals()`](https://python-all.ru/3.9/library/functions.html#globals) и [`locals()`](https://python-all.ru/3.9/library/functions.html#locals) возвращают текущий глобальный и локальный словарь соответственно, что может быть полезно для передачи в качестве второго и третьего аргумента в [`exec()`](https://python-all.ru/3.9/library/functions.html#exec).315316> **Примечание**317>318> Словарь *locals* по умолчанию действует так, как описано для функции [`locals()`](https://python-all.ru/3.9/library/functions.html#locals) ниже: не следует пытаться изменять словарь *locals* по умолчанию. Передайте явный словарь *locals*, если нужно увидеть влияние кода на *locals* после возврата из функции [`exec()`](https://python-all.ru/3.9/library/functions.html#exec).319320#### `filter(function, iterable)`321322Создает итератор из тех элементов *итерируемого объекта*, для которых *функция* возвращает истину. *Итерируемый объект* может быть последовательностью, контейнером, поддерживающим итерацию, или итератором. Если *функция* равна `None`, подразумевается тождественная функция, то есть удаляются все элементы *итерируемого объекта*, которые являются ложными.323324Обратите внимание: `filter(function, iterable)` эквивалентно генераторному выражению `(item for item in iterable if function(item))`, если function не равна `None`, и `(item for item in iterable if item)`, если function равна `None`.325326См. [`itertools.filterfalse()`](https://python-all.ru/3.9/library/itertools.html#itertools.filterfalse) для дополнительной функции, которая возвращает элементы *итерируемого объекта*, для которых *функция* возвращает ложь.327328#### `class float([x])`329330Возвращает число с плавающей запятой, построенное из числа или строки *x*.331332Если аргумент является строкой, она должна содержать десятичное число, которое может предваряться знаком и может быть окружено пробелами. Необязательный знак может быть `'+'` или `'-'`; знак `'+'` не влияет на результирующее значение. Аргумент также может быть строкой, представляющей NaN (не число), или положительную или отрицательную бесконечность. Более точно, входная строка должна соответствовать следующей грамматике после удаления начальных и конечных пробельных символов:333334```335336sign           ::=  "+" | "-"337infinity       ::=  "Infinity" | "inf"338nan            ::=  "nan"339numeric_value  ::=  floatnumber | infinity | nan340numeric_string ::=  [sign] numeric_value341```342343Здесь `floatnumber` – это форма литерала с плавающей точкой Python, описанная в [Литералы с плавающей точкой](https://python-all.ru/3.9/reference/lexical_analysis.html#floating). Регистр не имеет значения, так что, например, «inf», «Inf», «INFINITY» и «iNfINity» – все допустимые варианты написания положительной бесконечности.344345В противном случае, если аргумент – целое число или число с плавающей запятой, возвращается число с плавающей запятой с тем же значением (в пределах точности чисел с плавающей запятой Python). Если аргумент выходит за диапазон числа float в Python, будет возбуждено исключение [`OverflowError`](https://python-all.ru/3.9/library/exceptions.html#OverflowError).346347Для произвольного объекта Python `x` функция `float(x)` делегирует выполнение `x.__float__()`. Если `__float__()` не определён, используется [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__).348349Если аргумент не указан, возвращается `0.0`.350351Примеры:352353```python354>>> float('+1.23')3551.23356>>> float('   -12345\n')357-12345.0358>>> float('1e-003')3590.001360>>> float('+1E6')3611000000.0362>>> float('-Infinity')363-inf364```365366Тип float описан в разделе [Числовые типы – int, float, complex](https://python-all.ru/3.9/library/stdtypes.html#typesnumeric).367368Изменено в версии 3.6: Разрешена группировка цифр с помощью подчёркиваний, как в литералах кода.369370Изменено в версии 3.7: *x* теперь является параметром только для позиционной передачи.371372Изменено в версии 3.8: Использует [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), если [`__float__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__float__) не определён.373374#### `format(value[, format_spec])`375376Преобразует *значение* в «форматированное» представление, управляемое *спецификацией формата*. Интерпретация *спецификации формата* зависит от типа аргумента *значение*, однако существует стандартный синтаксис форматирования, используемый большинством встроенных типов: [Мини-язык спецификации формата](https://python-all.ru/3.9/library/string.html#formatspec).377378Значение *format\_spec* по умолчанию – пустая строка, что обычно даёт тот же эффект, что и вызов [`str(value)`](https://python-all.ru/3.9/library/stdtypes.html#str).379380Вызов `format(value, format_spec)` преобразуется в `type(value).__format__(value, format_spec)`, который обходит словарь экземпляра при поиске метода [`__format__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__format__) значения. Исключение [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError) возникает, если поиск метода доходит до [`object`](https://python-all.ru/3.9/library/functions.html#object) и *format\_spec* не пуста, или если *format\_spec* или возвращаемое значение не являются строками.381382Изменено в версии 3.4: `object().__format__(format_spec)` вызывает [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError), если *format\_spec* не является пустой строкой.383384#### `class frozenset([iterable])`385386Возвращает новый объект [`frozenset`](https://python-all.ru/3.9/library/stdtypes.html#frozenset), опционально с элементами, взятыми из *итерируемого объекта*. `frozenset` – это встроенный класс. См. [`frozenset`](https://python-all.ru/3.9/library/stdtypes.html#frozenset) и [Типы множеств – set, frozenset](https://python-all.ru/3.9/library/stdtypes.html#types-set) для документации об этом классе.387388Для других контейнеров см. встроенные классы [`set`](https://python-all.ru/3.9/library/stdtypes.html#set), [`list`](https://python-all.ru/3.9/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.9/library/stdtypes.html#tuple) и [`dict`](https://python-all.ru/3.9/library/stdtypes.html#dict), а также модуль [`collections`](https://python-all.ru/3.9/library/collections.html#module-collections).389390#### `getattr(object, name[, default])`391392Возвращает значение именованного атрибута объекта *object*. *name* должен быть строкой. Если эта строка является именем одного из атрибутов объекта, результатом будет значение этого атрибута. Например, `getattr(x, 'foobar')` эквивалентно `x.foobar`. Если именованный атрибут не существует, возвращается *значение по умолчанию*, если оно предоставлено, в противном случае возбуждается [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError).393394> **Примечание**395>396> Поскольку [искажение имени закрытых атрибутов](https://python-all.ru/3.9/reference/expressions.html#private-name-mangling) происходит во время компиляции, необходимо вручную исказить имя закрытого атрибута (атрибуты с двумя подчеркиваниями в начале), чтобы получить его с помощью [`getattr()`](https://python-all.ru/3.9/library/functions.html#getattr).397398#### `globals()`399400Возвращает словарь, реализующий пространство имен текущего модуля. Для кода внутри функций он устанавливается при определении функции и остается неизменным независимо от того, откуда функция вызывается.401402#### `hasattr(object, name)`403404Аргументами являются объект и строка. Результат равен `True`, если строка является именем одного из атрибутов объекта, и `False` в противном случае. (Реализовано вызовом `getattr(object, name)` и проверкой, вызывает ли он исключение [`AttributeError`](https://python-all.ru/3.9/library/exceptions.html#AttributeError) или нет.)405406#### `hash(object)`407408Возвращает хеш-значение объекта (если оно есть). Хеш-значения – целые числа. Они используются для быстрого сравнения ключей словаря при поиске. Числовые значения, равные при сравнении, имеют одинаковое хеш-значение (даже если они разных типов, как в случае 1 и 1.0).409410> **Примечание**411>412> Для объектов с пользовательскими методами [`__hash__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__hash__), обратите внимание, что [`hash()`](https://python-all.ru/3.9/library/functions.html#hash) усекает возвращаемое значение на основе разрядности хост-машины. См. [`__hash__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__hash__) для подробностей.413414#### `help([object])`415416Запускает встроенную справочную систему. (Эта функция предназначена для интерактивного использования.) Если аргумент не указан, интерактивная справочная система запускается на консоли интерпретатора. Если аргумент – строка, то она ищется как имя модуля, функции, класса, метода, ключевого слова или темы документации, и на консоль выводится страница справки. Если аргумент – объект любого другого типа, генерируется страница справки по этому объекту.417418Обратите внимание: если в списке параметров функции встречается косая черта (/), то при вызове [`help()`](https://python-all.ru/3.9/library/functions.html#help) это означает, что параметры до косой черты являются только позиционными. Подробнее см. [статью в FAQ о только позиционных параметрах](https://python-all.ru/3.9/faq/programming.html#faq-positional-only-arguments).419420Эта функция добавляется во встроенное пространство имен модулем [`site`](https://python-all.ru/3.9/library/site.html#module-site).421422Изменено в версии 3.4: Изменения в [`pydoc`](https://python-all.ru/3.9/library/pydoc.html#module-pydoc) и [`inspect`](https://python-all.ru/3.9/library/inspect.html#module-inspect) привели к тому, что сообщаемые сигнатуры для вызываемых объектов стали более полными и согласованными.423424#### `hex(x)`425426Преобразует целое число в шестнадцатеричную строку в нижнем регистре с префиксом «0x». Если *x* не является объектом Python [`int`](https://python-all.ru/3.9/library/functions.html#int), он должен определять метод [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), который возвращает целое число. Некоторые примеры:427428```python429>>> hex(255)430'0xff'431>>> hex(-42)432'-0x2a'433```434435Если вы хотите преобразовать целое число в шестнадцатеричную строку в верхнем или нижнем регистре, с префиксом или без, можно использовать любой из следующих способов:436437```python438>>> '%#x' % 255, '%x' % 255, '%X' % 255439('0xff', 'ff', 'FF')440>>> format(255, '#x'), format(255, 'x'), format(255, 'X')441('0xff', 'ff', 'FF')442>>> f'{255:#x}', f'{255:x}', f'{255:X}'443('0xff', 'ff', 'FF')444```445446См. также [`format()`](https://python-all.ru/3.9/library/functions.html#format) для получения дополнительной информации.447448См. также [`int()`](https://python-all.ru/3.9/library/functions.html#int) для преобразования шестнадцатеричной строки в целое число с основанием 16.449450> **Примечание**451>452> Чтобы получить шестнадцатеричное строковое представление числа с плавающей точкой, используйте метод [`float.hex()`](https://python-all.ru/3.9/library/stdtypes.html#float.hex).453454#### `id(object)`455456Возвращает «идентификатор» объекта. Это целое число, которое гарантированно будет уникальным и постоянным для данного объекта на протяжении его времени жизни. Два объекта с непересекающимся временем жизни могут иметь одинаковое значение [`id()`](https://python-all.ru/3.9/library/functions.html#id).457458**Особенность реализации CPython:** Это адрес объекта в памяти.459460Вызывает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `builtins.id` с аргументом `id`.461462#### `input([prompt])`463464Если аргумент *prompt* присутствует, он выводится в стандартный вывод без символа новой строки. Затем функция читает строку из ввода, преобразует её в строку (удаляя конечный символ новой строки) и возвращает её. Когда достигнут конец файла, возбуждается [`EOFError`](https://python-all.ru/3.9/library/exceptions.html#EOFError). Пример:465466```python467>>> s = input('--> ')  468--> Monty Python's Flying Circus469>>> s  470"Monty Python's Flying Circus"471```472473Если модуль [`readline`](https://python-all.ru/3.9/library/readline.html#module-readline) был загружен, то [`input()`](https://python-all.ru/3.9/library/functions.html#input) будет использовать его для предоставления расширенных возможностей редактирования строки и истории команд.474475Возбуждает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `builtins.input` с аргументом `prompt` перед чтением ввода476477Возбуждает событие аудита `builtins.input/result` с результатом после успешного чтения ввода.478479#### `class int([x])`480481#### `class int(x, base=10)`482483Возвращает целочисленный объект, созданный из числа или строки *x*, или возвращает `0`, если аргументы не переданы. Если *x* определяет [`__int__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__int__), `int(x)` возвращает `x.__int__()`. Если *x* определяет [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), возвращается `x.__index__()`. Если *x* определяет [`__trunc__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__trunc__), возвращается `x.__trunc__()`. Для чисел с плавающей точкой происходит усечение в сторону нуля.484485Если *x* не является числом или если задан *base*, то *x* должен быть строкой, [`bytes`](https://python-all.ru/3.9/library/stdtypes.html#bytes) или экземпляром [`bytearray`](https://python-all.ru/3.9/library/stdtypes.html#bytearray), представляющим [целочисленный литерал](https://python-all.ru/3.9/reference/lexical_analysis.html#integers) в системе счисления *base*. При необходимости литерал может предваряться `+` или `-` (без пробела) и быть окружен пробелами. Литерал в системе счисления n состоит из цифр от 0 до n-1, где `a` до `z` (или `A` до `Z`) имеют значения от 10 до 35. Значение по умолчанию *base* равно 10. Допустимые значения: 0 и 2–36. Литералы с основанием 2, 8 и 16 могут опционально начинаться с `0b`/`0B`, `0o`/`0O` или `0x`/`0X`, как и целочисленные литералы в коде. Основание 0 означает точную интерпретацию как литерала в коде, так что фактическое основание может быть 2, 8, 10 или 16, и поэтому `int('010', 0)` недопустимо, тогда как `int('010')` допустимо, равно как и `int('010', 8)`.486487Целочисленный тип описан в разделе [Числовые типы – int, float, complex](https://python-all.ru/3.9/library/stdtypes.html#typesnumeric).488489Изменено в версии 3.4: Если *base* не является экземпляром [`int`](https://python-all.ru/3.9/library/functions.html#int) и объект *base* имеет метод [`base.__index__`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), то вызывается этот метод для получения целого числа для основания. В предыдущих версиях использовался [`base.__int__`](https://python-all.ru/3.9/reference/datamodel.html#object.__int__) вместо [`base.__index__`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__).490491Изменено в версии 3.6: Разрешена группировка цифр с помощью подчёркиваний, как в литералах кода.492493Изменено в версии 3.7: *x* теперь является параметром только для позиционной передачи.494495Изменено в версии 3.8: Использует [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), если [`__int__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__int__) не определён.496497Изменено в версии 3.9.14: [`int`](https://python-all.ru/3.9/library/functions.html#int) строковые входные данные и строковые представления могут быть ограничены для предотвращения атак типа «отказ в обслуживании». [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError) возбуждается, когда превышается лимит при преобразовании строки *x* в [`int`](https://python-all.ru/3.9/library/functions.html#int) или когда преобразование [`int`](https://python-all.ru/3.9/library/functions.html#int) в строку превысило бы лимит. См. документацию [ограничения длины преобразования целых чисел в строки](https://python-all.ru/3.9/library/stdtypes.html#int-max-str-digits).498499#### `isinstance(object, classinfo)`500501Возвращает `True`, если аргумент *object* является экземпляром аргумента *classinfo*, или его (прямого, косвенного или [виртуального](https://python-all.ru/3.9/glossary.html#term-abstract-base-class)) подкласса. Если *object* не является объектом указанного типа, функция всегда возвращает `False`. Если *classinfo* является кортежем объектов-типов (или рекурсивно других таких кортежей), возвращает `True`, если *object* является экземпляром любого из типов. Если *classinfo* не является типом, кортежем типов или таких кортежей, возбуждается исключение [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError).502503#### `issubclass(class, classinfo)`504505Возвращает `True`, если *class* является подклассом (прямым, косвенным или [виртуальным](https://python-all.ru/3.9/glossary.html#term-abstract-base-class)) *classinfo*. Класс считается подклассом самого себя. *classinfo* может быть кортежем объектов-классов (или рекурсивно других таких кортежей), в этом случае возвращается `True`, если *class* является подклассом любого элемента из *classinfo*. В любом другом случае возбуждается исключение [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError).506507#### `iter(object[, sentinel])`508509Возвращает объект [итератор](https://python-all.ru/3.9/glossary.html#term-iterator). Первый аргумент интерпретируется совершенно по-разному в зависимости от наличия второго аргумента. Без второго аргумента *object* должен быть объектом коллекции, поддерживающим протокол итерации (метод [`__iter__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__iter__)) или протокол последовательности (метод [`__getitem__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getitem__) с целочисленными аргументами, начиная с `0`). Если он не поддерживает ни один из этих протоколов, возбуждается [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError). Если задан второй аргумент, *страж*, то *object* должен быть вызываемым объектом. Созданный в этом случае итератор будет вызывать *object* без аргументов при каждом вызове своего метода [`__next__()`](https://python-all.ru/3.9/library/stdtypes.html#iterator.__next__); если возвращённое значение равно *страж*, возбуждается [`StopIteration`](https://python-all.ru/3.9/library/exceptions.html#StopIteration), в противном случае значение возвращается.510511См. также [Типы итераторов](https://python-all.ru/3.9/library/stdtypes.html#typeiter).512513Одно из полезных применений второй формы [`iter()`](https://python-all.ru/3.9/library/functions.html#iter) – создание построчного (блочного) читателя. Например, чтение блоков фиксированной ширины из двоичного файла базы данных до достижения конца файла:514515```python516from functools import partial517with open('mydata.db', 'rb') as f:518    for block in iter(partial(f.read, 64), b''):519        process_block(block)520```521522#### `len(s)`523524Возвращает длину (количество элементов) объекта. Аргументом может быть последовательность (например, строка, байты, кортеж, список или диапазон) или коллекция (например, словарь, множество или замороженное множество).525526**Особенность реализации CPython:** `len` возбуждает [`OverflowError`](https://python-all.ru/3.9/library/exceptions.html#OverflowError) для длин, превышающих [`sys.maxsize`](https://python-all.ru/3.9/library/sys.html#sys.maxsize), например [`range(2 ** 100)`](https://python-all.ru/3.9/library/stdtypes.html#range).527528#### `class list([iterable])`529530Вместо того чтобы быть функцией, [`list`](https://python-all.ru/3.9/library/stdtypes.html#list) на самом деле является изменяемым типом последовательности, как описано в [Списки](https://python-all.ru/3.9/library/stdtypes.html#typesseq-list) и [Типы последовательностей – list, tuple, range](https://python-all.ru/3.9/library/stdtypes.html#typesseq).531532#### `locals()`533534Обновляет и возвращает словарь, представляющий текущую таблицу локальных символов. Свободные переменные возвращаются [`locals()`](https://python-all.ru/3.9/library/functions.html#locals) при вызове в блоках функций, но не в блоках классов. Обратите внимание, что на уровне модуля [`locals()`](https://python-all.ru/3.9/library/functions.html#locals) и [`globals()`](https://python-all.ru/3.9/library/functions.html#globals) являются одним и тем же словарём.535536> **Примечание**537>538> Содержимое этого словаря не следует изменять; изменения могут не повлиять на значения локальных и свободных переменных, используемых интерпретатором.539540#### `map(function, iterable, ...)`541542Возвращает итератор, который применяет *function* к каждому элементу *iterable* и возвращает результаты. Если переданы дополнительные аргументы *iterable*, *function* должна принимать столько же аргументов и применяется к элементам из всех итерируемых параллельно. При нескольких итерируемых итератор останавливается, когда завершается самый короткий. Для случаев, когда входные данные функции уже упакованы в кортежи аргументов, см. [`itertools.starmap()`](https://python-all.ru/3.9/library/itertools.html#itertools.starmap).543544#### `max(iterable, *[, key, default])`545546#### `max(arg1, arg2, *args[, key])`547548Возвращает наибольший элемент итерируемого объекта или наибольший из двух или более аргументов.549550Если указан один позиционный аргумент, он должен быть [итерируемым объектом](https://python-all.ru/3.9/glossary.html#term-iterable). Возвращается наибольший элемент итерируемого объекта. Если указано два или более позиционных аргумента, возвращается наибольший из них.551552Есть два необязательных аргумента, передаваемых только по ключу. Аргумент *key* задаёт функцию упорядочения с одним аргументом, подобно тому, как это делается для [`list.sort()`](https://python-all.ru/3.9/library/stdtypes.html#list.sort). Аргумент *default* задаёт объект, возвращаемый, если переданный итерируемый объект пуст. Если итерация пуста и *default* не указан, возбуждается [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError).553554Если несколько элементов являются максимальными, функция возвращает первый встреченный. Это согласуется с другими инструментами, сохраняющими стабильность сортировки, такими как `sorted(iterable, key=keyfunc, reverse=True)[0]` и `heapq.nlargest(1, iterable, key=keyfunc)`.555556Новое в версии 3.4: Аргумент *default*, указываемый только по ключевому слову.557558Изменено в версии 3.8: Аргумент *key* может быть `None`.559560#### `class memoryview(object)`561562Возвращает объект «представление памяти» (memory view), созданный из переданного аргумента. Дополнительную информацию см. в [Memory Views](https://python-all.ru/3.9/library/stdtypes.html#typememoryview).563564#### `min(iterable, *[, key, default])`565566#### `min(arg1, arg2, *args[, key])`567568Возвращает наименьший элемент итерируемого объекта или наименьший из двух или более аргументов.569570Если указан один позиционный аргумент, он должен быть [итерируемым объектом](https://python-all.ru/3.9/glossary.html#term-iterable). Возвращается наименьший элемент итерируемого объекта. Если указано два или более позиционных аргумента, возвращается наименьший из них.571572Есть два необязательных аргумента, передаваемых только по ключу. Аргумент *key* задаёт функцию упорядочения с одним аргументом, подобно тому, как это делается для [`list.sort()`](https://python-all.ru/3.9/library/stdtypes.html#list.sort). Аргумент *default* задаёт объект, возвращаемый, если переданный итерируемый объект пуст. Если итерация пуста и *default* не указан, возбуждается [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError).573574Если несколько элементов являются минимальными, функция возвращает первый из них. Это согласуется с другими инструментами, сохраняющими устойчивость сортировки, такими как `sorted(iterable, key=keyfunc)[0]` и `heapq.nsmallest(1, iterable, key=keyfunc)`.575576Новое в версии 3.4: Аргумент *default*, указываемый только по ключевому слову.577578Изменено в версии 3.8: Аргумент *key* может быть `None`.579580#### `next(iterator[, default])`581582Извлекает следующий элемент из *итератора*, вызывая его метод [`__next__()`](https://python-all.ru/3.9/library/stdtypes.html#iterator.__next__). Если указан *default*, он возвращается, когда итератор исчерпан, в противном случае возбуждается [`StopIteration`](https://python-all.ru/3.9/library/exceptions.html#StopIteration).583584#### `class object`585586Возвращает новый пустой объект. [`object`](https://python-all.ru/3.9/library/functions.html#object) – базовый класс для всех классов. Он содержит методы, общие для всех экземпляров классов Python. Эта функция не принимает аргументов.587588> **Примечание**589>590> [`object`](https://python-all.ru/3.9/library/functions.html#object) *не* имеет [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__), поэтому нельзя присваивать произвольные атрибуты экземпляру класса [`object`](https://python-all.ru/3.9/library/functions.html#object).591592#### `oct(x)`593594Преобразует целое число в восьмеричную строку с префиксом «0o». Результат является допустимым выражением Python. Если *x* не является объектом Python [`int`](https://python-all.ru/3.9/library/functions.html#int), он должен определять метод [`__index__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__index__), который возвращает целое число. Например:595596```python597>>> oct(8)598'0o10'599>>> oct(-56)600'-0o70'601```602603Если нужно преобразовать целое число в восьмеричную строку с префиксом «0o» или без него, можно воспользоваться одним из следующих способов.604605```python606>>> '%#o' % 10, '%o' % 10607('0o12', '12')608>>> format(10, '#o'), format(10, 'o')609('0o12', '12')610>>> f'{10:#o}', f'{10:o}'611('0o12', '12')612```613614См. также [`format()`](https://python-all.ru/3.9/library/functions.html#format) для получения дополнительной информации.615616>617618#### `open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`619620Открывает *file* и возвращает соответствующий [файловый объект](https://python-all.ru/3.9/glossary.html#term-file-object). Если файл не может быть открыт, возбуждается [`OSError`](https://python-all.ru/3.9/library/exceptions.html#OSError). См. [Чтение и запись файлов](https://python-all.ru/3.9/tutorial/inputoutput.html#tut-files) для дополнительных примеров использования этой функции.621622*file* – это [path-like object](https://python-all.ru/3.9/glossary.html#term-path-like-object), задающий путь (абсолютный или относительный текущего рабочего каталога) к открываемому файлу или целочисленный файловый дескриптор оборачиваемого файла. (Если передан файловый дескриптор, он закрывается при закрытии возвращаемого объекта I/O, если только *closefd* не установлен в `False`.)623624*mode* – необязательная строка, задающая режим открытия файла. По умолчанию используется `'r'`, что означает открытие для чтения в текстовом режиме. Другие распространённые значения: `'w'` для записи (с усечением файла, если он уже существует), `'x'` для исключительного создания и `'a'` для дозаписи (что в *некоторых* Unix-системах означает, что *все* операции записи добавляются в конец файла независимо от текущей позиции указателя). В текстовом режиме, если *encoding* не указан, используется кодировка, зависящая от платформы: `locale.getpreferredencoding(False)` вызывается для получения текущей кодировки локали. (Для чтения и записи сырых байтов используйте двоичный режим и оставьте *encoding* неопределённым.) Доступные режимы:625626| Символ | Значение |627| --- | --- |628| `'r'` | открытие для чтения (по умолчанию) |629| `'w'` | открытие для записи, с предварительным усечением файла |630| `'x'` | открытие для эксклюзивного создания, завершается ошибкой, если файл уже существует |631| `'a'` | открытие для записи, дозапись в конец файла, если он существует |632| `'b'` | двоичный режим |633| `'t'` | текстовый режим (по умолчанию) |634| `'+'` | открытие для обновления (чтения и записи) |635636Режим по умолчанию – `'r'` (открытие для чтения текста, синоним `'rt'`). Режимы `'w+'` и `'w+b'` открывают и усекают файл. Режимы `'r+'` и `'r+b'` открывают файл без усечения.637638Как упоминалось в [Обзоре](https://python-all.ru/3.9/library/io.html#io-overview), Python различает двоичный и текстовый ввод-вывод. Файлы, открытые в двоичном режиме (включая `'b'` в аргументе *mode*), возвращают содержимое в виде объектов [`bytes`](https://python-all.ru/3.9/library/stdtypes.html#bytes) без какого-либо декодирования. В текстовом режиме (по умолчанию или когда `'t'` включён в аргумент *mode*) содержимое файла возвращается как [`str`](https://python-all.ru/3.9/library/stdtypes.html#str), при этом байты предварительно декодируются с использованием кодировки, зависящей от платформы, или указанной *encoding*, если она задана.639640Разрешён дополнительный символ режима, `'U'`, который больше не оказывает никакого эффекта и считается устаревшим. Ранее он включал [универсальные символы новой строки](https://python-all.ru/3.9/glossary.html#term-universal-newlines) в текстовом режиме, что стало поведением по умолчанию в Python 3.0. Обратитесь к документации параметра [newline](https://python-all.ru/3.9/library/functions.html#open-newline-parameter) для получения дополнительных сведений.641642> **Примечание**643>644> Python не зависит от представления текстовых файлов в базовой операционной системе; вся обработка выполняется самим Python и, следовательно, не зависит от платформы.645646*buffering* – необязательное целое число для установки политики буферизации. Передайте 0 для отключения буферизации (допускается только в двоичном режиме), 1 для построчной буферизации (только в текстовом режиме) и целое число \> 1 для указания размера блока фиксированного размера в байтах. Обратите внимание, что указание размера буфера таким образом применяется к двоичному буферизованному вводу-выводу, но `TextIOWrapper` (т.е. файлы, открытые с `mode='r+'`) будут иметь другую буферизацию. Чтобы отключить буферизацию в `TextIOWrapper`, рассмотрите использование флага `write_through` для [`io.TextIOWrapper.reconfigure()`](https://python-all.ru/3.9/library/io.html#io.TextIOWrapper.reconfigure). Если аргумент *buffering* не указан, политика буферизации по умолчанию работает следующим образом:647648- Двоичные файлы буферизируются блоками фиксированного размера; размер буфера выбирается эвристически, пытаясь определить «размер блока» нижележащего устройства, и при неудаче используется [`io.DEFAULT_BUFFER_SIZE`](https://python-all.ru/3.9/library/io.html#io.DEFAULT_BUFFER_SIZE). Во многих системах размер буфера обычно составляет 4096 или 8192 байта.649- «Интерактивные» текстовые файлы (файлы, для которых [`isatty()`](https://python-all.ru/3.9/library/io.html#io.IOBase.isatty) возвращает `True`) используют построчную буферизацию. Остальные текстовые файлы используют политику, описанную выше для двоичных файлов.650651*encoding* – имя кодировки, используемой для декодирования или кодирования файла. Это следует использовать только в текстовом режиме. Кодировка по умолчанию зависит от платформы (то, что возвращает [`locale.getpreferredencoding()`](https://python-all.ru/3.9/library/locale.html#locale.getpreferredencoding)), но может использоваться любая [текстовая кодировка](https://python-all.ru/3.9/glossary.html#term-text-encoding), поддерживаемая Python. См. модуль [`codecs`](https://python-all.ru/3.9/library/codecs.html#module-codecs) для списка поддерживаемых кодировок.652653*errors* – необязательная строка, определяющая, как обрабатывать ошибки кодирования и декодирования; этот параметр нельзя использовать в двоичном режиме. Доступны различные стандартные обработчики ошибок (перечислены в разделе [Обработчики ошибок](https://python-all.ru/3.9/library/codecs.html#error-handlers)), однако также подходит любое имя обработчика, зарегистрированное с помощью [`codecs.register_error()`](https://python-all.ru/3.9/library/codecs.html#codecs.register_error). Стандартные имена включают:654655- `'strict'` – возбуждать исключение [`ValueError`](https://python-all.ru/3.9/library/exceptions.html#ValueError) при ошибке кодирования. Значение по умолчанию `None` имеет тот же эффект.656- `'ignore'` – игнорировать ошибки. Учтите, что игнорирование ошибок кодирования может привести к потере данных.657- `'replace'` – вставляет заменяющий символ (например, `'?'`) в местах повреждённых данных.658- `'surrogateescape'` – представляет некорректные байты как суррогатные кодовые единицы в диапазоне U+DC80–U+DCFF. При записи данных эти суррогатные единицы снова преобразуются в исходные байты при использовании обработчика ошибок `surrogateescape`. Это удобно для обработки файлов с неизвестной кодировкой.659- `'xmlcharrefreplace'` поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей XML-ссылкой на символ `&#nnn;`.660- `'backslashreplace'` заменяет повреждённые данные escape-последовательностями Python с обратной косой чертой.661- `'namereplace'` (также поддерживается только при записи) заменяет неподдерживаемые символы escape-последовательностями `\N{...}`.662663*newline* управляет работой режима [универсальных символов новой строки](https://python-all.ru/3.9/glossary.html#term-universal-newlines) (действует только в текстовом режиме). Может принимать значения `None`, `''`, `'\n'`, `'\r'` и `'\r\n'`. Работает следующим образом:664665- При чтении из потока, если *newline* равен `None`, включается универсальный режим новых строк. Строки во входных данных могут заканчиваться на `'\n'`, `'\r'` или `'\r\n'`; перед возвратом вызывающему коду они преобразуются в `'\n'`. Если равен `''`, универсальный режим новых строк включён, но концы строк возвращаются как есть, без преобразования. Если задано любое другое допустимое значение, строки на входе завершаются только заданной строкой, и конец строки возвращается вызывающему коду без изменений.666- При записи в поток, если *newline* равен `None`, все символы `'\n'` преобразуются в системный разделитель строк по умолчанию [`os.linesep`](https://python-all.ru/3.9/library/os.html#os.linesep). Если *newline* равен `''` или `'\n'`, преобразование не выполняется. Если *newline* равен любому другому допустимому значению, все символы `'\n'` преобразуются в заданную строку.667668Если *closefd* равен `False` и был передан файловый дескриптор, а не имя файла, базовый файловый дескриптор останется открытым при закрытии файла. Если передано имя файла, *closefd* должно быть `True` (значение по умолчанию), иначе будет возбуждена ошибка.669670Можно задать собственный «открыватель», передав вызываемый объект как *opener*. Базовый файловый дескриптор для файлового объекта получается вызовом *opener* с аргументами (*file*, *flags*). *opener* должен вернуть открытый файловый дескриптор (передача [`os.open`](https://python-all.ru/3.9/library/os.html#os.open) в качестве *opener* даёт результат, аналогичный передаче `None`).671672Созданный файл является [ненаследуемым](https://python-all.ru/3.9/library/os.html#fd-inheritance).673674В следующем примере используется параметр [dir\_fd](https://python-all.ru/3.9/library/os.html#dir-fd) функции [`os.open()`](https://python-all.ru/3.9/library/os.html#os.open) для открытия файла относительно заданного каталога:675676```python677>>> import os678>>> dir_fd = os.open('somedir', os.O_RDONLY)679>>> def opener(path, flags):680...     return os.open(path, flags, dir_fd=dir_fd)681...682>>> with open('spamspam.txt', 'w', opener=opener) as f:683...     print('This will be written to somedir/spamspam.txt', file=f)684...685>>> os.close(dir_fd)  # не допустить утечки файлового дескриптора686```687688Тип [файлового объекта](https://python-all.ru/3.9/glossary.html#term-file-object), возвращаемого функцией [`open()`](https://python-all.ru/3.9/library/functions.html#open), зависит от режима. При использовании [`open()`](https://python-all.ru/3.9/library/functions.html#open) для открытия файла в текстовом режиме (`'w'`, `'r'`, `'wt'`, `'rt'` и т.д.) возвращается подкласс [`io.TextIOBase`](https://python-all.ru/3.9/library/io.html#io.TextIOBase) (а именно [`io.TextIOWrapper`](https://python-all.ru/3.9/library/io.html#io.TextIOWrapper)). При открытии файла в двоичном режиме с буферизацией возвращаемый класс является подклассом [`io.BufferedIOBase`](https://python-all.ru/3.9/library/io.html#io.BufferedIOBase). Конкретный класс различается: в режиме чтения в двоичном виде возвращается [`io.BufferedReader`](https://python-all.ru/3.9/library/io.html#io.BufferedReader); в режимах записи и добавления в двоичном виде – [`io.BufferedWriter`](https://python-all.ru/3.9/library/io.html#io.BufferedWriter), а в режиме чтения/записи – [`io.BufferedRandom`](https://python-all.ru/3.9/library/io.html#io.BufferedRandom). Если буферизация отключена, возвращается необработанный поток – подкласс [`io.RawIOBase`](https://python-all.ru/3.9/library/io.html#io.RawIOBase), [`io.FileIO`](https://python-all.ru/3.9/library/io.html#io.FileIO).689690См. также модули для работы с файлами: [`fileinput`](https://python-all.ru/3.9/library/fileinput.html#module-fileinput), [`io`](https://python-all.ru/3.9/library/io.html#module-io) (где объявлен [`open()`](https://python-all.ru/3.9/library/functions.html#open)), [`os`](https://python-all.ru/3.9/library/os.html#module-os), [`os.path`](https://python-all.ru/3.9/library/os.path.html#module-os.path), [`tempfile`](https://python-all.ru/3.9/library/tempfile.html#module-tempfile) и [`shutil`](https://python-all.ru/3.9/library/shutil.html#module-shutil).691692Вызывает [событие аудита](https://python-all.ru/3.9/library/sys.html#auditing) `open` с аргументами `file`, `mode`, `flags`.693694Аргументы `mode` и `flags` могли быть изменены или определены на основе исходного вызова.695696> Изменено в версии 3.3:697>698> - Добавлен параметр *opener*.699> - Добавлен режим `'x'`.700> - [`IOError`](https://python-all.ru/3.9/library/exceptions.html#IOError) ранее возбуждался, теперь это псевдоним [`OSError`](https://python-all.ru/3.9/library/exceptions.html#OSError).701> - Теперь возбуждается [`FileExistsError`](https://python-all.ru/3.9/library/exceptions.html#FileExistsError), если файл, открываемый в эксклюзивном режиме создания (`'x'`), уже существует.702703> Изменено в версии 3.4:704>705> - Файл теперь является ненаследуемым.706707Устарело с версии 3.4, будет удалено в версии 3.10: Режим `'U'`.708709> Изменено в версии 3.5:710>711> - Если системный вызов был прерван и обработчик сигнала не возбудил исключение, функция теперь повторяет системный вызов вместо возбуждения исключения [`InterruptedError`](https://python-all.ru/3.9/library/exceptions.html#InterruptedError) (см. [**PEP 475**](https://python-all.ru/3.9/library/functions.html) для обоснования).712> - Добавлен обработчик ошибок `'namereplace'`.713714> Изменено в версии 3.6:715>716> - Добавлена поддержка объектов, реализующих [`os.PathLike`](https://python-all.ru/3.9/library/os.html#os.PathLike).717> - В Windows открытие консольного буфера может вернуть подкласс [`io.RawIOBase`](https://python-all.ru/3.9/library/io.html#io.RawIOBase), отличный от [`io.FileIO`](https://python-all.ru/3.9/library/io.html#io.FileIO).718719#### `ord(c)`720721Принимает строку, представляющую один символ Unicode, и возвращает целое число – кодовую точку Unicode этого символа. Например, `ord('a')` возвращает целое число `97`, а `ord('€')` (знак евро) возвращает `8364`. Это функция, обратная [`chr()`](https://python-all.ru/3.9/library/functions.html#chr).722723#### `pow(base, exp[, mod])`724725Возвращает *base* в степени *exp*; если указан *mod*, возвращает *base* в степени *exp* по модулю *mod* (вычисляется эффективнее, чем `pow(base, exp) % mod`). Двухаргументная форма `pow(base, exp)` эквивалентна использованию оператора возведения в степень: `base**exp`.726727Аргументы должны иметь числовые типы. При смешанных типах операндов применяются правила приведения для бинарных арифметических операторов. Для [`int`](https://python-all.ru/3.9/library/functions.html#int) операндов результат имеет тот же тип, что и операнды (после приведения), если только второй аргумент не отрицательный; в этом случае все аргументы преобразуются в float и возвращается результат типа float. Например, `pow(10, 2)` возвращает `100`, но `pow(10, -2)` возвращает `0.01`. Для отрицательного основания типа [`int`](https://python-all.ru/3.9/library/functions.html#int) или [`float`](https://python-all.ru/3.9/library/functions.html#float) и нецелого показателя степени возвращается комплексный результат. Например, `pow(-9, 0.5)` возвращает значение, близкое к `3j`.728729Для операндов [`int`](https://python-all.ru/3.9/library/functions.html#int) *base* и *exp*, если указан *mod*, *mod* также должен быть целого типа, и *mod* должен быть ненулевым. Если *mod* указан и *exp* отрицателен, *base* должен быть взаимно прост с *mod*. В этом случае возвращается `pow(inv_base, -exp, mod)`, где *inv\_base* – обратный элемент к *base* по модулю *mod*.730731Вот пример вычисления обратного элемента для `38` по модулю `97`:732733```python734>>> pow(38, -1, mod=97)73523736>>> 23 * 38 % 97 == 1737True738```739740Изменено в версии 3.8: Для операндов [`int`](https://python-all.ru/3.9/library/functions.html#int) трёхаргументная форма `pow` теперь допускает отрицательный второй аргумент, что позволяет вычислять обратные элементы по модулю.741742Изменено в версии 3.8: Разрешены именованные аргументы. Ранее поддерживались только позиционные аргументы.743744#### `print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)`745746Выводит *objects* в текстовый поток *file*, разделяя их *sep* и завершая *end*. *sep*, *end*, *file* и *flush*, если присутствуют, должны передаваться как именованные аргументы.747748Все неименованные аргументы преобразуются в строки, как [`str()`](https://python-all.ru/3.9/library/stdtypes.html#str), и записываются в поток, разделённые *sep* и завершаемые *end*. Оба *sep* и *end* должны быть строками; они также могут быть `None`, что означает использование значений по умолчанию. Если *objects* не указаны, [`print()`](https://python-all.ru/3.9/library/functions.html#print) просто запишет *end*.749750Аргумент *file* должен быть объектом с методом `write(string)`; если он не указан или равен `None`, будет использоваться [`sys.stdout`](https://python-all.ru/3.9/library/sys.html#sys.stdout). Так как выводимые аргументы преобразуются в текстовые строки, [`print()`](https://python-all.ru/3.9/library/functions.html#print) нельзя использовать с файловыми объектами в бинарном режиме. Для них используйте `file.write(...)`.751752Обычно буферизация вывода определяется параметром *file*, но если именованный аргумент *flush* равен True, поток принудительно сбрасывается.753754Изменено в версии 3.3: Добавлен именованный аргумент *flush*.755756#### `class property(fget=None, fset=None, fdel=None, doc=None)`757758Возвращает атрибут property.759760*fget* – функция для получения значения атрибута. *fset* – функция для установки значения атрибута. *fdel* – функция для удаления значения атрибута. А *doc* создаёт строку документации для атрибута.761762Типичное использование – определить управляемый атрибут `x`:763764```python765class C:766    def __init__(self):767        self._x = None768769    def getx(self):770        return self._x771772    def setx(self, value):773        self._x = value774775    def delx(self):776        del self._x777778    x = property(getx, setx, delx, "I'm the 'x' property.")779```780781Если *c* – экземпляр *C*, то `c.x` вызовет геттер, `c.x = value` вызовет сеттер, а `del c.x` – делитер.782783Если указан, *doc* будет строкой документации атрибута property. В противном случае property скопирует строку документации *fget* (если она существует). Это позволяет легко создавать свойства только для чтения, используя [`property()`](https://python-all.ru/3.9/library/functions.html#property) в качестве [декоратора](https://python-all.ru/3.9/glossary.html#term-decorator):784785```python786class Parrot:787    def __init__(self):788        self._voltage = 100000789790    @property791    def voltage(self):792        """Получить текущее напряжение."""793        return self._voltage794```795796Декоратор `@property` превращает метод `voltage()` в «геттер» для атрибута только для чтения с тем же именем и устанавливает строку документации для *voltage* в «Get the current voltage.»797798Объект property имеет методы `getter`, `setter` и `deleter`, которые можно использовать как декораторы; они создают копию свойства с соответствующей функцией доступа, установленной в декорированную функцию. Лучше всего это объяснить на примере:799800```python801class C:802    def __init__(self):803        self._x = None804805    @property806    def x(self):807        """Я – свойство 'x'."""808        return self._x809810    @x.setter811    def x(self, value):812        self._x = value813814    @x.deleter815    def x(self):816        del self._x817```818819Этот код полностью эквивалентен первому примеру. Убедитесь, что дополнительные функции имеют то же имя, что и исходное свойство (`x` в данном случае.)820821Возвращаемый объект property также имеет атрибуты `fget`, `fset` и `fdel`, соответствующие аргументам конструктора.822823Изменено в версии 3.5: Строки документации объектов property теперь доступны для записи.824825#### `class range(stop)`826827#### `class range(start, stop[, step])`828829[`range`](https://python-all.ru/3.9/library/stdtypes.html#range) – не функция, а неизменяемый тип последовательности, как описано в [Ranges](https://python-all.ru/3.9/library/stdtypes.html#typesseq-range) и [Sequence Types – list, tuple, range](https://python-all.ru/3.9/library/stdtypes.html#typesseq).830831#### `repr(object)`832833Возвращает строку, содержащую печатное представление объекта. Для многих типов эта функция пытается вернуть строку, при передаче которой в [`eval()`](https://python-all.ru/3.9/library/functions.html#eval) будет получен объект с тем же значением, в противном случае представление представляет собой строку в угловых скобках, содержащую имя типа объекта и дополнительную информацию, часто включающую имя и адрес объекта. Класс может управлять тем, что возвращает эта функция для своих экземпляров, определив метод [`__repr__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__repr__).834835#### `reversed(seq)`836837Возвращает обратный [итератор](https://python-all.ru/3.9/glossary.html#term-iterator). *seq* должен быть объектом с методом [`__reversed__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__reversed__) или поддерживающим протокол последовательности (методы [`__len__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__len__) и [`__getitem__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getitem__) с целочисленными аргументами, начиная с `0`).838839#### `round(number[, ndigits])`840841Возвращает *number*, округлённое до *ndigits* знаков после запятой. Если *ndigits* опущено или равно `None`, возвращается ближайшее целое к входному значению.842843Для встроенных типов, поддерживающих [`round()`](https://python-all.ru/3.9/library/functions.html#round), значения округляются до ближайшего кратного 10 в степени минус *ndigits*; если два ближайших значения одинаково близки, округление производится к чётному выбору (например, и `round(0.5)`, и `round(-0.5)` округляются до `0`, а `round(1.5)` – до `2`). Любое целое значение может быть использовано для *ndigits* (положительное, ноль или отрицательное). Возвращаемое значение – целое число, если *ndigits* опущен или равен `None`. В противном случае возвращаемое значение имеет тот же тип, что и *number*.844845Для произвольного объекта Python `number` функция `round` делегирует выполнение `number.__round__`.846847> **Примечание**848>849> Поведение [`round()`](https://python-all.ru/3.9/library/functions.html#round) для чисел с плавающей точкой может быть неожиданным: например, `round(2.675, 2)` даёт `2.67` вместо ожидаемого `2.68`. Это не ошибка: это результат того, что большинство десятичных дробей невозможно точно представить в виде числа с плавающей точкой. Подробнее см. [Арифметика с плавающей точкой: проблемы и ограничения](https://python-all.ru/3.9/tutorial/floatingpoint.html#tut-fp-issues).850851#### `class set([iterable])`852853Возвращает новый объект [`set`](https://python-all.ru/3.9/library/stdtypes.html#set), опционально с элементами, взятыми из *итерируемого объекта*. `set` – это встроенный класс. См. [`set`](https://python-all.ru/3.9/library/stdtypes.html#set) и [Типы множеств – set, frozenset](https://python-all.ru/3.9/library/stdtypes.html#types-set) для документации об этом классе.854855Для других контейнеров см. встроенные классы [`frozenset`](https://python-all.ru/3.9/library/stdtypes.html#frozenset), [`list`](https://python-all.ru/3.9/library/stdtypes.html#list), [`tuple`](https://python-all.ru/3.9/library/stdtypes.html#tuple) и [`dict`](https://python-all.ru/3.9/library/stdtypes.html#dict), а также модуль [`collections`](https://python-all.ru/3.9/library/collections.html#module-collections).856857#### `setattr(object, name, value)`858859Это аналог [`getattr()`](https://python-all.ru/3.9/library/functions.html#getattr). Аргументами являются объект, строка и произвольное значение. Строка может задавать существующий или новый атрибут. Функция присваивает значение атрибуту, если объект это позволяет. Например, `setattr(x, 'foobar', 123)` эквивалентно `x.foobar = 123`.860861> **Примечание**862>863> Поскольку [private name mangling](https://python-all.ru/3.9/reference/expressions.html#private-name-mangling) происходит на этапе компиляции, необходимо вручную исказить имя закрытого атрибута (атрибуты с двумя ведущими подчёркиваниями), чтобы задать его с помощью [`setattr()`](https://python-all.ru/3.9/library/functions.html#setattr).864865#### `class slice(stop)`866867#### `class slice(start, stop[, step])`868869Возвращает объект [slice](https://python-all.ru/3.9/glossary.html#term-slice), представляющий набор индексов, заданных `range(start, stop, step)`. Аргументы *start* и *step* по умолчанию равны `None`. Объекты slice имеют атрибуты только для чтения `start`, `stop` и `step`, которые просто возвращают значения соответствующих аргументов (или значения по умолчанию). Они не имеют другого явного функционала, но используются в NumPy и других сторонних пакетах. Объекты slice также создаются при использовании расширенного синтаксиса индексации. Например: `a[start:stop:step]` или `a[start:stop, i]`. См. [`itertools.islice()`](https://python-all.ru/3.9/library/itertools.html#itertools.islice) для альтернативной версии, возвращающей итератор.870871#### `sorted(iterable, /, *, key=None, reverse=False)`872873Возвращает новый отсортированный список из элементов *итерируемого объекта*.874875Имеет два необязательных аргумента, которые должны быть указаны как именованные.876877*key* задаёт функцию одного аргумента, которая извлекает ключ сравнения из каждого элемента *итерируемого объекта* (например, `key=str.lower`). Значение по умолчанию – `None` (сравнивает элементы напрямую).878879*reverse* – логическое значение. Если указано `True`, то элементы списка сортируются так, как если бы каждое сравнение было обратным.880881Используйте [`functools.cmp_to_key()`](https://python-all.ru/3.9/library/functools.html#functools.cmp_to_key) для преобразования устаревшей функции *cmp* в функцию *key*.882883Встроенная функция [`sorted()`](https://python-all.ru/3.9/library/functions.html#sorted) гарантированно устойчива. Сортировка называется устойчивой, если она не меняет относительный порядок элементов, которые сравниваются как равные. Это удобно при многоуровневой сортировке (например, сначала по отделу, затем по зарплатной категории).884885Алгоритм сортировки использует только сравнения `<` между элементами. Хотя для сортировки достаточно определить метод [`__lt__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__lt__), [**PEP 8**](https://python-all.ru/3.9/library/functions.html) рекомендует реализовать все шесть [расширенных сравнений](https://python-all.ru/3.9/reference/expressions.html#comparisons). Это поможет избежать ошибок при использовании тех же данных с другими средствами упорядочивания, такими как [`max()`](https://python-all.ru/3.9/library/functions.html#max), которые полагаются на другой базовый метод. Реализация всех шести сравнений также помогает избежать путаницы при сравнениях смешанных типов, которые могут вызывать отражённый метод [`__gt__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__gt__).886887Примеры сортировки и краткое руководство см. в [Sorting HOW TO](https://python-all.ru/3.9/howto/sorting.html#sortinghowto).888889#### `@staticmethod`890891Преобразует метод в статический метод.892893Статический метод не получает неявный первый аргумент. Чтобы объявить статический метод, используйте такую идиому:894895```python896class C:897    @staticmethod898    def f(arg1, arg2, ...): ...899```900901Форма `@staticmethod` является функцией [декоратора](https://python-all.ru/3.9/glossary.html#term-decorator) – подробнее см. в [Function definitions](https://python-all.ru/3.9/reference/compound_stmts.html#function).902903Статический метод можно вызвать как от класса (например, `C.f()`), так и от экземпляра (например, `C().f()`).904905Статические методы в Python похожи на аналоги из Java или C++. Также смотрите [`classmethod()`](https://python-all.ru/3.9/library/functions.html#classmethod) – вариант, полезный для создания альтернативных конструкторов класса.906907Как и все декораторы, `staticmethod` можно вызвать как обычную функцию и что-то сделать с её результатом. Это необходимо в тех случаях, когда нужна ссылка на функцию из тела класса и требуется избежать автоматического преобразования в метод экземпляра. Для таких случаев используйте следующую идиому:908909```python910class C:911    builtin_open = staticmethod(open)912```913914Дополнительную информацию о статических методах см. в [The standard type hierarchy](https://python-all.ru/3.9/reference/datamodel.html#types).915916#### `class str(object='')`917918#### `class str(object=b'', encoding='utf-8', errors='strict')`919920Возвращает [`str`](https://python-all.ru/3.9/library/stdtypes.html#str)-версию *объекта*. Подробнее см. [`str()`](https://python-all.ru/3.9/library/stdtypes.html#str).921922`str` – это встроенный строковый [класс](https://python-all.ru/3.9/glossary.html#term-class). Общую информацию о строках см. в [Text Sequence Type – str](https://python-all.ru/3.9/library/stdtypes.html#textseq).923924#### `sum(iterable, /, start=0)`925926Суммирует *start* и элементы *итерируемого объекта* слева направо и возвращает общую сумму. Элементы *итерируемого объекта* обычно являются числами, а начальное значение не может быть строкой.927928Для некоторых случаев существуют хорошие альтернативы [`sum()`](https://python-all.ru/3.9/library/functions.html#sum). Предпочтительный и быстрый способ конкатенации последовательности строк – вызов `''.join(sequence)`. Для сложения чисел с плавающей точкой с повышенной точностью см. [`math.fsum()`](https://python-all.ru/3.9/library/math.html#math.fsum). Для конкатенации последовательности итерируемых объектов рассмотрите [`itertools.chain()`](https://python-all.ru/3.9/library/itertools.html#itertools.chain).929930Изменено в версии 3.8: Параметр *start* теперь можно указывать как именованный аргумент.931932#### `super([type[, object-or-type]])`933934Возвращает объект-посредник, который делегирует вызовы методов родительскому или родственному классу *type*. Это полезно для доступа к унаследованным методам, которые были переопределены в классе.935936Параметр *object-or-type* определяет [порядок разрешения методов](https://python-all.ru/3.9/glossary.html#term-method-resolution-order), по которому будет производиться поиск. Поиск начинается с класса, следующего сразу за *type*.937938Например, если [`__mro__`](https://python-all.ru/3.9/library/stdtypes.html#class.__mro__) для *object-or-type* равно `D -> B -> C -> A -> object`, а значение *type* – `B`, то [`super()`](https://python-all.ru/3.9/library/functions.html#super) выполняет поиск по `C -> A -> object`.939940Атрибут [`__mro__`](https://python-all.ru/3.9/library/stdtypes.html#class.__mro__) объекта *object-or-type* содержит перечень порядка разрешения методов, используемого как [`getattr()`](https://python-all.ru/3.9/library/functions.html#getattr), так и [`super()`](https://python-all.ru/3.9/library/functions.html#super). Этот атрибут динамический и может изменяться при обновлении иерархии наследования.941942Если второй аргумент опущен, возвращается несвязанный объект super. Если второй аргумент является объектом, `isinstance(obj, type)` должно быть истинно. Если второй аргумент является типом, `issubclass(type2, type)` должно быть истинно (это полезно для методов класса).943944Существует два типичных варианта использования *super*. В иерархии классов с одиночным наследованием *super* можно использовать для ссылки на родительские классы без явного указания их имен, что делает код более поддерживаемым. Это использование тесно параллельно использованию *super* в других языках программирования.945946Второй вариант использования – поддержка кооперативного множественного наследования в динамической среде выполнения. Этот случай уникален для Python и не встречается в статически компилируемых языках или языках, поддерживающих только одиночное наследование. Это позволяет реализовать «ромбовидные диаграммы», где несколько базовых классов реализуют один и тот же метод. Хорошее проектирование требует, чтобы такие реализации имели одинаковую сигнатуру вызова во всех случаях (поскольку порядок вызовов определяется во время выполнения, поскольку этот порядок адаптируется к изменениям в иерархии классов и может включать родственные классы, неизвестные до выполнения).947948Для обоих вариантов использования типичный вызов родительского класса выглядит так:949950```python951class C(B):952    def method(self, arg):953        super().method(arg)    # Делает то же самое, что и:954                               # super(C, self).method(arg)955```956957В дополнение к поиску методов, [`super()`](https://python-all.ru/3.9/library/functions.html#super) также работает для поиска атрибутов. Один из возможных вариантов использования – вызов [дескрипторов](https://python-all.ru/3.9/glossary.html#term-descriptor) в родительском или родственном классе.958959Обратите внимание, что [`super()`](https://python-all.ru/3.9/library/functions.html#super) реализован как часть процесса связывания для явных точечных обращений к атрибутам, таких как `super().__getitem__(name)`. Это делается путём реализации собственного метода [`__getattribute__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__getattribute__) для поиска классов в предсказуемом порядке, поддерживающем кооперативное множественное наследование. Соответственно, [`super()`](https://python-all.ru/3.9/library/functions.html#super) не определён для неявных обращений с использованием инструкций или операторов, таких как `super()[name]`.960961Также обратите внимание, что, за исключением формы без аргументов, [`super()`](https://python-all.ru/3.9/library/functions.html#super) не ограничен использованием внутри методов. Форма с двумя аргументами точно задает аргументы и создает соответствующие ссылки. Форма без аргументов работает только внутри определения класса, так как компилятор заполняет необходимые детали для правильного извлечения определяемого класса, а также для доступа к текущему экземпляру в обычных методах.962963Практические рекомендации по проектированию кооперативных классов с использованием [`super()`](https://python-all.ru/3.9/library/functions.html#super) см. в [руководстве по использованию super()](https://python-all.ru/3.9/library/functions.html).964965#### `class tuple([iterable])`966967[`tuple`](https://python-all.ru/3.9/library/stdtypes.html#tuple) на самом деле не функция, а неизменяемый тип последовательности, как описано в [Кортежи](https://python-all.ru/3.9/library/stdtypes.html#typesseq-tuple) и [Типы последовательностей – list, tuple, range](https://python-all.ru/3.9/library/stdtypes.html#typesseq).968969#### `class type(object)`970971#### `class type(name, bases, dict, **kwds)`972973С одним аргументом возвращает тип объекта *object*. Возвращаемое значение – объект типа, как правило, тот же объект, что и возвращаемый [`object.__class__`](https://python-all.ru/3.9/library/stdtypes.html#instance.__class__).974975Встроенная функция [`isinstance()`](https://python-all.ru/3.9/library/functions.html#isinstance) рекомендуется для проверки типа объекта, поскольку она учитывает подклассы.976977С тремя аргументами возвращает новый объект типа. По сути, это динамическая форма оператора [`class`](https://python-all.ru/3.9/reference/compound_stmts.html#class). Строка *name* – это имя класса, она становится атрибутом [`__name__`](https://python-all.ru/3.9/library/stdtypes.html#definition.__name__). Кортеж *bases* содержит базовые классы и становится атрибутом [`__bases__`](https://python-all.ru/3.9/library/stdtypes.html#class.__bases__); если он пуст, добавляется [`object`](https://python-all.ru/3.9/library/functions.html#object) – конечный базовый класс всех классов. Словарь *dict* содержит определения атрибутов и методов тела класса; он может быть скопирован или обёрнут перед тем, как стать атрибутом [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__). Следующие два оператора создают идентичные объекты [`type`](https://python-all.ru/3.9/library/functions.html#type):978979```python980>>> class X:981...     a = 1982...983>>> X = type('X', (), dict(a=1))984```985986См. также [Type Objects](https://python-all.ru/3.9/library/stdtypes.html#bltin-type-objects).987988Именованные аргументы, переданные форме с тремя аргументами, передаются соответствующему механизму метакласса (обычно [`__init_subclass__()`](https://python-all.ru/3.9/reference/datamodel.html#object.__init_subclass__)) так же, как и ключевые слова в определении класса (кроме *metaclass*).989990См. также [Настройка создания классов](https://python-all.ru/3.9/reference/datamodel.html#class-customization).991992Изменено в версии 3.6: Подклассы [`type`](https://python-all.ru/3.9/library/functions.html#type), не переопределяющие `type.__new__`, больше не могут использовать форму с одним аргументом для получения типа объекта.993994#### `vars([object])`995996Возвращает атрибут [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__) для модуля, класса, экземпляра или любого другого объекта с атрибутом [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__).997998Такие объекты, как модули и экземпляры, имеют обновляемый атрибут [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__); однако другие объекты могут иметь ограничения на запись своих атрибутов [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__) (например, классы используют [`types.MappingProxyType`](https://python-all.ru/3.9/library/types.html#types.MappingProxyType) для предотвращения прямых изменений словаря).9991000Без аргумента [`vars()`](https://python-all.ru/3.9/library/functions.html#vars) ведёт себя как [`locals()`](https://python-all.ru/3.9/library/functions.html#locals). Примечание: словарь locals полезен только для чтения, так как обновления словаря locals игнорируются.10011002Исключение [`TypeError`](https://python-all.ru/3.9/library/exceptions.html#TypeError) возбуждается, если указан объект, но у него нет атрибута [`__dict__`](https://python-all.ru/3.9/library/stdtypes.html#object.__dict__) (например, если его класс определяет атрибут [`__slots__`](https://python-all.ru/3.9/reference/datamodel.html#object.__slots__)).10031004#### `zip(*iterables)`10051006Создаёт итератор, который объединяет элементы из каждой из переданных итерируемых последовательностей.10071008Возвращает итератор кортежей, где *i*-й кортеж содержит *i*-й элемент из каждой последовательности аргументов или итерируемого объекта. Итератор останавливается, когда исчерпывается самая короткая входная последовательность. С одним аргументом-итератором возвращает итератор кортежей из одного элемента. Без аргументов возвращает пустой итератор. Эквивалентно:10091010```python1011def zip(*iterables):1012    # zip('ABCD', 'xy') --> Ax By1013    sentinel = object()1014    iterators = [iter(it) for it in iterables]1015    while iterators:1016        result = []1017        for it in iterators:1018            elem = next(it, sentinel)1019            if elem is sentinel:1020                return1021            result.append(elem)1022        yield tuple(result)1023```10241025Гарантируется порядок вычисления слева направо. Это позволяет реализовать идиому для группировки данных в группы длины n с помощью `zip(*[iter(s)]*n)`. При этом *тот же самый* итератор повторяется `n` раз, так что каждый выходной кортеж содержит результат `n` вызовов итератора. Это приводит к разбиению входных данных на блоки длины n.10261027[`zip()`](https://python-all.ru/3.9/library/functions.html#zip) следует использовать только с последовательностями разной длины, если не важны несовпавшие хвостовые значения из более длинных последовательностей. Если эти значения важны, используйте [`itertools.zip_longest()`](https://python-all.ru/3.9/library/itertools.html#itertools.zip_longest).10281029[`zip()`](https://python-all.ru/3.9/library/functions.html#zip) в сочетании с оператором `*` можно использовать для распаковки списка:10301031```python1032>>> x = [1, 2, 3]1033>>> y = [4, 5, 6]1034>>> zipped = zip(x, y)1035>>> list(zipped)1036[(1, 4), (2, 5), (3, 6)]1037>>> x2, y2 = zip(*zip(x, y))1038>>> x == list(x2) and y == list(y2)1039True1040```10411042#### `__import__(name, globals=None, locals=None, fromlist=(), level=0)`10431044> **Примечание**1045>1046> Это продвинутая функция, которая не требуется в повседневном программировании на Python, в отличие от [`importlib.import_module()`](https://python-all.ru/3.9/library/importlib.html#importlib.import_module).10471048Эта функция вызывается оператором [`import`](https://python-all.ru/3.9/reference/simple_stmts.html#import). Её можно заменить (импортировав модуль [`builtins`](https://python-all.ru/3.9/library/builtins.html#module-builtins) и присвоив `builtins.__import__`), чтобы изменить семантику оператора `import`, но делать это **настоятельно** не рекомендуется, так как обычно проще использовать перехватчики импорта (см. [**PEP 302**](https://python-all.ru/3.9/library/functions.html)) для достижения тех же целей, и это не вызывает проблем с кодом, предполагающим использование реализации импорта по умолчанию. Прямое использование [`__import__()`](https://python-all.ru/3.9/library/functions.html#__import__) также не рекомендуется, вместо него следует использовать [`importlib.import_module()`](https://python-all.ru/3.9/library/importlib.html#importlib.import_module).10491050Функция импортирует модуль *name*, потенциально используя переданные *globals* и *locals* для определения того, как интерпретировать имя в контексте пакета. *fromlist* задаёт имена объектов или подмодулей, которые должны быть импортированы из модуля, указанного в *name*. Стандартная реализация вообще не использует свой аргумент *locals*, а *globals* использует только для определения контекста пакета для оператора [`import`](https://python-all.ru/3.9/reference/simple_stmts.html#import).10511052*level* указывает, использовать ли абсолютный или относительный импорт. `0` (по умолчанию) означает только абсолютный импорт. Положительные значения *level* указывают количество родительских каталогов для поиска относительно каталога модуля, вызывающего [`__import__()`](https://python-all.ru/3.9/library/functions.html#__import__) (подробнее см. [**PEP 328**](https://python-all.ru/3.9/library/functions.html)).10531054Когда переменная *name* имеет вид `package.module`, обычно возвращается пакет верхнего уровня (имя до первой точки), а *не* модуль, названный *name*. Однако, если передан непустой аргумент *fromlist*, возвращается модуль, названный *name*.10551056Например, оператор `import spam` приводит к байт-коду, напоминающему следующий код:10571058```python1059spam = __import__('spam', globals(), locals(), [], 0)1060```10611062Оператор `import spam.ham` приводит к следующему вызову:10631064```python1065spam = __import__('spam.ham', globals(), locals(), [], 0)1066```10671068Обратите внимание, как [`__import__()`](https://python-all.ru/3.9/library/functions.html#__import__) возвращает модуль верхнего уровня, потому что это объект, который привязывается к имени оператором [`import`](https://python-all.ru/3.9/reference/simple_stmts.html#import).10691070С другой стороны, оператор `from spam.ham import eggs, sausage as saus` приводит к10711072```python1073_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)1074eggs = _temp.eggs1075saus = _temp.sausage1076```10771078Здесь модуль `spam.ham` возвращается из [`__import__()`](https://python-all.ru/3.9/library/functions.html#__import__). Из этого объекта извлекаются имена для импорта и присваиваются соответствующим именам.10791080Если требуется просто импортировать модуль (возможно, внутри пакета) по имени, используйте [`importlib.import_module()`](https://python-all.ru/3.9/library/importlib.html#importlib.import_module).10811082Изменено в версии 3.3: Отрицательные значения *level* больше не поддерживаются (это также меняет значение по умолчанию на 0).10831084Изменено в версии 3.9: При использовании параметров командной строки [`-E`](https://python-all.ru/3.9/using/cmdline.html#cmdoption-e) или [`-I`](https://python-all.ru/3.9/using/cmdline.html#id2) переменная окружения [`PYTHONCASEOK`](https://python-all.ru/3.9/using/cmdline.html#envvar-PYTHONCASEOK) теперь игнорируется.10851086Сноски10871088**[1](https://python-all.ru/3.9/library/functions.html#id1)**10891090Обратите внимание, что анализатор принимает только соглашение о концах строк в стиле Unix. Если вы читаете код из файла, убедитесь, что используете режим преобразования символов новой строки для преобразования концов строк в стиле Windows или Mac.1091