Built-in FunctionsВстроенные функции

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

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

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

aiter(async_iterable, /)¶

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

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

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

all(iterable, /)¶

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

python

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

awaitable anext(async_iterator, /)¶

awaitable anext(async_iterator, default, /)

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

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

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

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

any(iterable, /)¶

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

python

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

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

bin(integer, /)¶

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

text

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

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

text

>>> 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. Он имеет большинство обычных методов изменяемых последовательностей, описанных в Mutable Sequence Types, а также большинство методов типа bytes, см. Bytes and Bytearray Operations.

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

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

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

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

class bytes(source=b'')

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

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

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

Объекты bytes также можно создавать с помощью литералов, см. String and Bytes literals.

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

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

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

chr(codepoint, /)¶

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

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

@classmethod¶

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

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

python

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

Форма @classmethod представляет собой декоратор – см. Function definitions для подробностей.

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

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

Изменено в версии 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, *, module=None)¶

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

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

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

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

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

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

Необязательный аргумент module задаёт имя модуля. Он нужен для однозначной фильтрации синтаксических предупреждений по имени модуля.

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

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

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

Примечание

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

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

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

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

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

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

Добавлено в версии 3.15: Добавлен параметр module.

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

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

Примеры:

python

>>> 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__().

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

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

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

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

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

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

Устарело с версии 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 и Типы отображений – dict, frozendict для документации об этом классе.

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

dir()¶

dir(object, /)

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

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

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

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

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

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

text

>>> import struct
>>> dir()   # показать имена в пространстве имён модуля
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct
['Struct', '__all__', '__builtins__', '__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.

text

>>> 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')]

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

python

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

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

Параметры:

source (str | code object) – выражение Python.
globals (dict | frozendict | None) – глобальное пространство имён (по умолчанию: None).
locals (mapping | None) – локальное пространство имён (по умолчанию: None).

Возвращает:

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

Возбуждает:

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

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

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

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

Пример:

text

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

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

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

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

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

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

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

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

Изменено в версии 3.15: globals теперь может быть frozendict.

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

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

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

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

Примечание

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

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

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

Примечание

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

Примечание

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

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

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

Изменено в версии 3.15: globals теперь может быть frozendict.

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.

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

class float(number=0.0, /)¶

class float(string, /)

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

Примеры:

python

>>> 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). Если аргумент выходит за диапазон значений float в 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: Использует __index__(), если __float__() не определён.

format(value, format_spec='', /)¶

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

Значение 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, необязательно с элементами, взятыми из итерируемого объекта. frozenset – встроенный класс. См. frozenset и Типы множеств – set, frozenset для документации об этом классе.

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

getattr(object, name, /)¶
getattr(object, name, default, /): Возвращает значение именованного атрибута объекта объекта. 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() встречается косая черта (/), это означает, что параметры до косой черты являются исключительно позиционными. Дополнительную информацию см. в статье FAQ о позиционных параметрах.

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

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

hex(integer, /)¶

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

text

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

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

text

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

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

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

Примечание

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

id(object, /)¶

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

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

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

input()¶

input(prompt, /)

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

python

>>> 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, если аргументы не переданы.

Примеры:

python

>>> 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. Строки с основанием 2, 8 и 16 могут опционально предваряться 0b/0B, 0o/0O или 0x/0X, как и целочисленные литералы в коде. Для основания 0 строка интерпретируется аналогично целочисленному литералу в коде: фактическое основание определяется префиксом и может быть 2, 8, 10 или 16. Основание 0 также запрещает ведущие нули: int('010', 0) недопустимо, тогда как int('010') и int('010', 8) допустимы.

Тип int описан в Числовые типы – int, float, complex.

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

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

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

Изменено в версии 3.8: Возвращается к __index__(), если __int__() не определён.

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

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

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

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

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

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

iter(iterable, /)¶

iter(callable, sentinel, /)

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

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

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

python

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, /)¶: Возвращает длину (количество элементов) объекта. Аргументом может быть последовательность (например, строка, байты, кортеж, список или диапазон) или коллекция (например, словарь, множество или замороженное множество).

Особенность реализации 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() в составе генератора списка (comprehension) внутри функции, генератора или корутины эквивалентен вызову в охватывающей области видимости, за исключением того, что будут включены инициализированные переменные итерации генератора списка. В других областях видимости он ведёт себя так, как если бы генератор списка выполнялся как вложенная функция.

Вызов 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 не является объектом int Python, он должен определять метод __index__(), возвращающий целое число. Например:

text

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

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

text

>>> '%#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 без декодирования. В текстовом режиме (по умолчанию или когда 't' присутствует в аргументе mode) содержимое файла возвращается как 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(), также подходит. Стандартные имена можно найти в Обработчиках ошибок.

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

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

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

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

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

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

python

>>> 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)  # не допускать утечки файлового дескриптора

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

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

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

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

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

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

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

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

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

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

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

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

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

ord(character, /)¶

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

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

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

pow(base, exp, mod=None)¶

Возвращает основание в степени степень; если задан модуль, возвращает основание в степени степень по модулю модуль (вычисляется эффективнее, чем 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 основание и степень, если задан модуль, то модуль также должен быть целочисленного типа, а модуль должен быть ненулевым. Если модуль задан и степень отрицательна, то основание должно быть взаимно простым с модуль. В этом случае возвращается pow(inv_base, -exp, mod), где inv_base является обратным к основание по модулю модуль.

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

python

>>> 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)¶

Выводит объекты в текстовый поток файл, разделённые sep и с end в конце. sep, end, файл и flush, если они заданы, должны передаваться как именованные аргументы.

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

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

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

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

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

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

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

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

python

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() в качестве декоратора:

python

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

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

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

@getter¶

@setter¶

@deleter¶

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

python

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

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

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

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

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

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

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

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

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

class range(stop, /)
class range(start, stop, step=1, /): На самом деле range – это не функция, а неизменяемый тип последовательности, как описано в Ranges и Sequence Types – list, tuple, range.

repr(object, /)¶

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

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

python

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

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

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. Это не ошибка: это связано с тем, что большинство десятичных дробей нельзя точно представить в виде числа с плавающей запятой. См. Floating-Point Arithmetic: Issues and Limitations для получения дополнительной информации.

class set(iterable=(), /)

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

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

setattr(object, name, value, /)¶

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

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

Примечание

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

class slice(stop, /)¶

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

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

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

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

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

Изменено в версии 3.12: Объекты slice теперь хешируемы (при условии, что 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¶

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

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

python

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

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

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

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

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

python

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)¶

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

В некоторых случаях существуют хорошие альтернативы 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 и не встречается в статически компилируемых языках или языках, поддерживающих только одиночное наследование. Это делает возможной реализацию «ромбовидных диаграмм», где несколько базовых классов реализуют один и тот же метод. Хороший дизайн требует, чтобы такие реализации имели одинаковую сигнатуру вызова в каждом случае (поскольку порядок вызовов определяется во время выполнения, поскольку этот порядок адаптируется к изменениям в иерархии классов и поскольку этот порядок может включать родственные классы, неизвестные до выполнения).

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

python

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

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

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

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

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

Изменено в версии 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:

text

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

Смотрите также:

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

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

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

Изменено в версии 3.15: dict теперь может быть frozendict.

vars()¶

vars(object, /)

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

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

Без аргумента vars() ведёт себя как locals().

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

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

zip(*iterables, strict=False)¶

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

Пример:

python

>>> 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() останавливается, когда самый короткий итерируемый объект исчерпан. Оставшиеся элементы в более длинных итерируемых объектах игнорируются, и результат обрезается до длины самого короткого:
python
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() часто используется в случаях, когда предполагается, что итерируемые объекты имеют одинаковую длину. В таких случаях рекомендуется использовать параметр strict=True. Его вывод такой же, как у обычного zip():
python
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
В отличие от поведения по умолчанию, он вызывает ValueError, если один итерируемый объект исчерпывается раньше других:
text
```
>>> 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() в сочетании с оператором * можно использовать для распаковки списка:

python

>>> 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 приводит к байт-коду, похожему на следующий код:

python

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

Инструкция import spam.ham приводит к следующему вызову:

python

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

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

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

python

_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 теперь игнорируется.

Сноски

Built-in FunctionsВстроенные функции​

Built-in FunctionsВстроенные функции