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

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

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

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

aiter(async_iterable, /)

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

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

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

all(iterable, /)

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

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

awaitable anext(async_iterator, /)

ожидаемый объект anext(async_iterator, default, /)

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

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

Функция вызывает метод __anext__() объекта async_iterator и возвращает ожидаемый объект. Ожидание этого объекта возвращает следующее значение итератора. Если задано значение по умолчанию, оно возвращается, когда итератор исчерпан; в противном случае возбуждается исключение StopAsyncIteration.

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

any(iterable, /)

Возвращает True, если хотя бы один элемент итерируемого объекта истинен. Если итерируемый объект пуст, возвращает False. Эквивалентно:

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

ascii(object, /): Как и repr(), возвращает строку с печатаемым представлением объекта, но экранирует символы, не относящиеся к ASCII, в строке, возвращаемой repr(), с помощью экранирующих последовательностей \x, \u или \U. Это создает строку, похожую на возвращаемую repr() в Python 2.

bin(integer, /)

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

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

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

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

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

Дополнительные сведения см. также в разделе format().

class bool(object=False, /): Возвращает логическое значение, то есть одно из True или False. Аргумент преобразуется с помощью стандартной процедуры проверки истинности. Если аргумент ложен или отсутствует, возвращается False; в противном случае возвращается True. Класс bool является подклассом int (см. Числовые типы — int, float, complex). От него нельзя наследоваться. Его единственные экземпляры — False и True (см. Логический тип — bool).

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

breakpoint(*args, **kws)

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

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

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

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

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

class bytearray(source=b'')

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

Возвращает новый массив байтов. Класс bytearray представляет собой изменяемую последовательность целых чисел в диапазоне 0 <= x < 256. Он поддерживает большинство обычных методов изменяемых последовательностей, описанных в разделе Типы изменяемых последовательностей, а также большинство методов типа bytes; см. Операции с bytes и bytearray.

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

Если это строка, необходимо также указать параметры encoding (и, необязательно, errors); bytearray() преобразует строку в байты с помощью str.encode().
Если это целое число, массив будет иметь указанный размер и заполнится нулевыми байтами.
Если это объект, соответствующий буферному интерфейсу, для инициализации массива байтов будет использован доступный только для чтения буфер объекта.
Если это итерируемый объект, он должен состоять из целых чисел в диапазоне 0 <= x < 256, которые будут использованы в качестве начального содержимого массива.

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

См. также Типы двоичных последовательностей — bytes, bytearray, memoryview и Объекты bytearray.

class bytes(source=b'')

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

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

Таким образом, аргументы конструктора интерпретируются так же, как у bytearray().

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

См. также Типы двоичных последовательностей — bytes, bytearray, memoryview, Объекты bytes и Операции с bytes и bytearray.

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

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

chr(codepoint, /)

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

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

@classmethod

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

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

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

Форма @classmethod представляет собой функцию-декоратор; подробности см. в разделе Определения функций.

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

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

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

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

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

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

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

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

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

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

Параметры компилятора и инструкции future задаются битами, которые можно объединять побитовой операцией ИЛИ для указания нескольких параметров. Битовое поле, необходимое для указания конкретной будущей возможности, доступно в атрибуте compiler_flag экземпляра _Feature в модуле __future__. Флаги компилятора можно найти в модуле ast; они имеют префикс PyCF_.

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

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

Чтобы разобрать код Python и преобразовать его в представление AST, см. ast.parse().

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

Примечание

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

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

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

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

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

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

class complex(number=0, /)

class complex(string, /)

class complex(real=0, imag=0)

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

Примеры:

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

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

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

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

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

См. также complex.from_number(), которая принимает только один числовой аргумент.

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

Тип complex описан в разделе Числовые типы — int, float, complex.

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

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

Устарело начиная с версии 3.14: Передача комплексного числа в качестве аргумента real или imag теперь считается устаревшей; его следует передавать только как единственный позиционный аргумент.

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

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

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

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

dir()

dir(object, /)

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

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

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

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

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

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

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

Примечание

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

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

enumerate(iterable, start=0)

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

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

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

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

eval(source, /, globals=None, locals=None)

Параметры:

source (str | объект кода) – Выражение Python.
globals (dict | None) – Глобальное пространство имён (по умолчанию: None).
locals (отображение | None) – Локальное пространство имён (по умолчанию: None).

Возвращает:

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

Вызывает исключение:

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

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

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

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

Примечание

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

Примечание

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

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

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

filter(function, iterable, /)

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

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

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

class float(number=0.0, /)

class float(string, /)

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

Примеры:

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

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

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

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

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

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

См. также float.from_number(), которая принимает только числовой аргумент.

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

Тип float описан в разделе Числовые типы — int, float, complex.

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

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

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

format(value, format_spec='', /)

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

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

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

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

class frozenset(iterable=(), /)

Возвращает новый объект frozenset, при необходимости добавляя в него элементы из iterable. frozenset — встроенный класс. Документацию по этому классу см. также в разделе Типы множеств — set, frozenset.

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

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

Примечание

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

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

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

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

Примечание

Для объектов с пользовательскими методами __hash__() учтите, что hash() усекает возвращаемое значение в соответствии с разрядностью компьютера.

help()

help(request)

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

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

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

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

hex(integer, /)

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

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

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

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

Дополнительную информацию см. в описании format().

Информацию о преобразовании шестнадцатеричной строки в целое число с основанием 16 см. в описании int().

Примечание

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

id(object, /)

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

Особенность реализации CPython: Это адрес объекта в памяти.

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

input()

input(prompt, /)

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

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

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

Перед чтением входных данных вызывает событие аудита builtins.input с аргументом prompt

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

class int(number=0, /)

class int(string, /, base=10)

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

Примеры:

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

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

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

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

Тип целых чисел описан в разделе Числовые типы — int, float, complex.

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

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

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

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

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

Изменено в версии 3.14: int() больше не делегирует вызов методу __trunc__().

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

Изменено в версии 3.10: classinfo может быть объединением типов.

issubclass(class, classinfo, /): Возвращает True, если class является подклассом classinfo (прямым, косвенным или виртуальным). Класс считается подклассом самого себя. classinfo может быть кортежем объектов классов (или, рекурсивно, другими такими кортежами) либо объединением типов. В этом случае функция возвращает True, если class является подклассом любой записи в classinfo. Во всех остальных случаях вызывается исключение TypeError.

Изменено в версии 3.10: classinfo может быть объединением типов.

iter(iterable, /)

iter(callable, sentinel, /)

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

См. также Типы итераторов.

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

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

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

Особенность реализации CPython: len вызывает исключение OverflowError, если длина превышает sys.maxsize, например, у объекта range(2 ** 100).

class list(iterable=(), /): list — не функция, а изменяемый тип последовательности, описанный в разделах Списки и Типы последовательностей — list, tuple, range.

locals()

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

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

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

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

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

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

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

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

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

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

map(function, iterable, /, *iterables, strict=False): Возвращает итератор, который применяет function к каждому элементу iterable и выдаёт результаты. Если переданы дополнительные аргументы iterables, функция function должна принимать соответствующее количество аргументов и применяется параллельно к элементам всех итерируемых объектов. При нескольких итерируемых объектах итератор останавливается, когда заканчиваются элементы самого короткого из них. Если strict равен True и один из итерируемых объектов заканчивается раньше остальных, вызывается исключение ValueError. Если входные данные функции уже сгруппированы в кортежи аргументов, см. itertools.starmap().

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

max(iterable, /, *, key=None)

max(iterable, /, *, default, key=None)

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

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

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

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

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

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

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

class memoryview(object): Возвращает объект «представление памяти», созданный на основе переданного аргумента. Дополнительные сведения см. в разделе Представления памяти.

min(iterable, /, *, key=None)

min(iterable, /, *, default, key=None)

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

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

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

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

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

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

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

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

Примечание

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

oct(integer, /)

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

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

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

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

Дополнительные сведения см. также в разделе format().

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

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

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

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

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

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

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

Примечание

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

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

Двоичные файлы буферизуются блоками фиксированного размера; размер буфера равен max(min(blocksize, 8 MiB), DEFAULT_BUFFER_SIZE), если доступен размер блока устройства. В большинстве систем размер буфера обычно составляет 128 килобайт.
Для «интерактивных» текстовых файлов (файлов, для которых isatty() возвращает True) используется построчная буферизация. Для остальных текстовых файлов используется политика, описанная выше для двоичных файлов.

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

errors — необязательная строка, задающая способ обработки ошибок кодирования и декодирования; этот параметр нельзя использовать в двоичном режиме. Доступны различные стандартные обработчики ошибок (перечисленные в разделе Обработчики ошибок), однако допустимо также любое имя обработчика ошибок, зарегистрированное с помощью codecs.register_error(). Среди стандартных имён:

'strict' вызывает исключение ValueError при ошибке кодирования. Значение None по умолчанию действует так же.
'ignore' игнорирует ошибки. Обратите внимание: игнорирование ошибок кодирования может привести к потере данных.
'replace' вставляет маркер замены (например, '?') в место, где обнаружены некорректные данные.
'surrogateescape' представляет все некорректные байты в виде младших суррогатных кодовых единиц в диапазоне от U+DC80 до U+DCFF. При записи данных эти суррогатные кодовые единицы преобразуются обратно в те же байты, если используется обработчик ошибок surrogateescape. Это полезно для обработки файлов с неизвестной кодировкой.
'xmlcharrefreplace' поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей символьной ссылкой XML &#nnn;.
'backslashreplace' заменяет некорректные данные экранированными обратной косой чертой последовательностями Python.
'namereplace' (также поддерживается только при записи) заменяет неподдерживаемые символы экранированными последовательностями \N{...}.

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

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

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

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

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

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

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # don't leak a file descriptor

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

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

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

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

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

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

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

Файл теперь является ненаследуемым.

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

Если системный вызов прерван, а обработчик сигнала не вызывает исключение, функция теперь повторяет системный вызов вместо того, чтобы вызвать исключение InterruptedError (обоснование см. в PEP 475).
Добавлен обработчик ошибок 'namereplace'.

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

Добавлена поддержка объектов, реализующих os.PathLike.
В Windows открытие буфера консоли может возвращать подкласс io.RawIOBase, отличный от io.FileIO.

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

ord(character, /)

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

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

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

pow(base, exp, mod=None)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

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

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

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

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

Декоратор @property превращает метод voltage() в «геттер» атрибута только для чтения с тем же именем и задаёт для voltage строку документации “Get the current voltage.”

@getter

@setter

@deleter

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

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

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

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

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

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

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

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

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

class range(stop, /)
class range(start, stop, step=1, /): range — не функция, а неизменяемый тип последовательности, описанный в разделах Диапазоны и Типы последовательностей — list, tuple, range.

repr(object, /)

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

У этого класса есть пользовательское представление, которое можно вычислить:

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

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

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

round(number, ndigits=None)

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

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

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

Примечание

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

class set(iterable=(), /)

Возвращает новый объект set, при необходимости содержащий элементы из iterable. set — встроенный класс. Описание этого класса см. также в разделе Типы множеств — set, frozenset.

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

setattr(object, name, value, /)

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

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

Примечание

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

class slice(stop, /)

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

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

Объекты среза также создаются при использовании синтаксиса срезов. Например: a[start:stop:step] или a[start:stop, i].

См. itertools.islice() — альтернативный вариант, который возвращает итератор.

start
stop
step: Этим атрибутам только для чтения присваиваются значения аргументов (или их значения по умолчанию). У них нет других явных функций, однако они используются NumPy и другими сторонними пакетами.

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

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

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

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

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

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

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

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

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

Примеры сортировки и краткое руководство по сортировке см. в разделе Методы сортировки.

@staticmethod

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

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

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

Форма @staticmethod представляет собой функциональный декоратор — подробности см. в разделе Определения функций.

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Дополнительные сведения о статических методах см. в разделе Стандартная иерархия типов.

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

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

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

Возвращает представление str объекта object. Подробности см. в разделе str().

str — встроенный строковый класс. Общие сведения о строках см. в разделе Текстовые последовательности — str.

sum(iterable, /, start=0)

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

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

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

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

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

class super

class super(type, object_or_type=None, /)

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

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

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

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

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

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

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

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

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

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

Помимо поиска методов, super() работает и для поиска атрибутов. Например, его можно использовать для вызова дескрипторов родительского или соседнего класса.

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

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

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

Изменено в версии 3.14: Объекты super теперь можно pickleable и copyable.

class tuple(iterable=(), /): tuple на самом деле не функция, а неизменяемый тип последовательности, описанный в разделах Кортежи и Типы последовательностей — list, tuple, range.

class type(object, /)

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

С одним аргументом возвращает тип объекта object. Возвращаемое значение — объект типа, обычно тот же объект, который возвращает object.__class__.

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

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

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

См. также:

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

В отличие от инструкции class, форма с тремя аргументами не вызывает метод метакласса __prepare__ (см. раздел Подготовка пространства имён класса). Чтобы динамически создать класс с использованием соответствующего метакласса, используйте types.new_class().

См. также раздел Настройка создания классов.

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

vars()

vars(object, /)

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

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

Если аргумент не указан, vars() действует как locals().

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

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

zip(*iterables, strict=False)

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

Пример:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

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

Можно также представить, что zip() преобразует строки в столбцы, а столбцы — в строки. Это похоже на транспонирование матрицы.

zip() выполняется лениво: элементы обрабатываются только при переборе итерируемого объекта, например циклом for или после обёртывания в list.

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

По умолчанию zip() останавливается, когда заканчивается самый короткий итерируемый объект. Оставшиеся элементы более длинных объектов игнорируются, поэтому результат имеет длину самого короткого итерируемого объекта:
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() часто используется, когда предполагается, что итерируемые объекты имеют одинаковую длину. В таких случаях рекомендуется использовать параметр strict=True. Результат будет таким же, как у обычного zip():
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
В отличие от поведения по умолчанию, если один итерируемый объект закончится раньше остальных, будет вызвано исключение ValueError:
```
>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
```
Без аргумента strict=True любая ошибка, из-за которой итерируемые объекты имеют разную длину, останется незамеченной и может проявиться в виде трудно обнаруживаемой ошибки в другой части программы.
Чтобы уравнять длину всех итерируемых объектов, более короткие можно дополнить постоянным значением. Для этого используется itertools.zip_longest().

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

Советы и рекомендации:

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

Оператор import spam.ham приводит к следующему вызову:

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

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

С другой стороны, оператор from spam.ham import eggs, sausage as saus приводит к следующему:

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

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

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

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

Изменено в версии 3.9: При использовании параметров командной строки -E или -I переменная среды PYTHONCASEOK теперь игнорируется.

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

Сноски