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

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

aiter(async_iterable)¶

Возвращает asynchronous iterator для asynchronous iterable. Эквивалентно вызову x.__aiter__().

Примечание: В отличие от iter(), у aiter() нет 2-аргументного варианта.

Added in version 3.10.

all(iterable)¶

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

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

awaitable anext(async_iterator)¶

awaitable anext(async_iterator, default)

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

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

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

Added in version 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(x)¶

Преобразуйте целое число в двоичную строку с префиксом «0b». Результатом является допустимое выражение Python. Если x не является объектом 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')

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

class bool(object=False, /)¶: Возвращает булево значение, т.е. одно из True или False. Аргумент преобразуется с помощью стандартного truth testing procedure. Если аргумент равен 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() был заменен.

Поднимает auditing event builtins.breakpoint с аргументом breakpointhook.

Added in version 3.7.

class bytearray(source=b'')

class bytearray(source, encoding)

class bytearray(source, encoding, errors)

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

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

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

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

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

class bytes(source=b'')

class bytes(source, encoding)

class bytes(source, encoding, errors)

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

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

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

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

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

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

chr(i)¶

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

Диапазон допустимых значений аргумента - от 0 до 1 114 111 (0x10FFFF в базе 16). Если i находится за пределами этого диапазона, то значение ValueError будет поднято.

@classmethod¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поднимает auditing event compile с аргументами source, filename.

Примечание

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

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

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

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

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

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

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

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

Примеры:

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

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

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

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

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

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

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

Изменено в версии 3.6: Группировка цифр с подчеркиванием, как в кодовых литералах, разрешена.

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Создайте новый словарь. Объект dict - это класс словаря. Документацию по этому классу смотрите в 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)¶

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

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

Эквивалент:

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

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

Параметры:

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

Результат:

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

поднимает:

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

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

Пример:

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

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

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

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

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

Поднимает auditing event exec с аргументом code_object.

Изменено в версии 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__ в globals перед передачей его в exec().

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

Поднимает auditing event exec с аргументом code_object.

Примечание

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

Примечание

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

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

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

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

filter(function, iterable)¶

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

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

Дополнительную функцию, возвращающую элементы iterable, для которых функция равна false, см. в 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__().

Если аргумент не указан, возвращается 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__() значения. Если поиск метода достигнет object, а формат_спецификации будет непустым, или если формат_спецификации или возвращаемое значение не являются строками, то возникнет исключение TypeError.

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

class frozenset(iterable=set())

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

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

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

Примечание

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

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

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

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

Примечание

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

help()¶

help(request)

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

Обратите внимание, что если при вызове help() в списке параметров функции появляется косая черта (/), это означает, что параметры до косой черты являются только позиционными. Подробнее об этом см. в разделе the FAQ entry on positional-only parameters.

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

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

hex(x)¶

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

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

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

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

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

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

Примечание

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

id(object)¶

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

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

Поднимает auditing event builtins.id с аргументом id.

input()¶

input(prompt)

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

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

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

Поднимает auditing event builtins.input с аргументом prompt.

Поднимает auditing event builtins.input/result с аргументом 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. По желанию, строка может иметь перед собой + или - (без пробела между ними), иметь ведущие нули, быть окруженной пробелами и иметь одиночные подчеркивания между цифрами.

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

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

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

Изменено в версии 3.6: Группировка цифр с подчеркиванием, как в кодовых литералах, разрешена.

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

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

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

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

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

Изменено в версии 3.10: classinfo может быть значением Тип союза.

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

Изменено в версии 3.10: classinfo может быть значением Тип союза.

iter(object)¶

iter(object, sentinel)

Возвращает объект iterator. Первый аргумент интерпретируется по-разному в зависимости от наличия второго аргумента. Без второго аргумента object должен быть объектом коллекции, поддерживающим протокол iterable (метод __iter__()) или протокол последовательности (метод __getitem__() с целочисленными аргументами, начиная с 0). Если он не поддерживает ни один из этих протоколов, возникает сообщение TypeError. Если указан второй аргумент, sentinel, то object должен быть вызываемым объектом. Созданный в этом случае итератор будет вызывать object без аргументов для каждого вызова его метода __next__(); если возвращаемое значение равно 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(s)¶: Возвращает длину (количество элементов) объекта. Аргументом может быть последовательность (например, строка, байт, кортеж, список или диапазон) или коллекция (например, словарь, набор или замороженный набор).

Детали реализации CPython: len повышает OverflowError на длинах, превышающих sys.maxsize, например range(2 ** 100).

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

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

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

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

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

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

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

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

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

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

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

map(function, iterable, *iterables)¶: Возвращает итератор, который применяет функцию к каждому элементу iterable, выдавая результат. Если переданы дополнительные аргументы iterables, функция должна принимать столько же аргументов и применяется к элементам всех итераторов параллельно. При использовании нескольких итераций итератор останавливается, когда исчерпывается самая короткая итерация. Для случаев, когда входы функции уже организованы в кортежи аргументов, смотрите itertools.starmap().

max(iterable, *, key=None)¶

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

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

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

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

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

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

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

Изменено в версии 3.8: Клавиша * может быть None.

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

min(iterable, *, key=None)¶

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

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

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

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

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

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

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

Изменено в версии 3.8: Клавиша * может быть None.

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

class object¶: Возвращает новый объект без функций. object является базой для всех классов. У него есть методы, общие для всех экземпляров классов Python. Эта функция не принимает никаких аргументов.

Примечание

У object нет __dict__, поэтому вы не можете присвоить произвольные атрибуты экземпляру класса object.

oct(x)¶

Преобразуйте целое число в восьмеричную строку с префиксом «0o». Результатом будет правильное выражение Python. Если x не является объектом 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 object. Если файл не может быть открыт, выдается сообщение OSError. Дополнительные примеры использования этой функции см. в разделе Чтение и запись файлов.

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

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

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

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

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

Примечание

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

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

Двоичные файлы буферизуются кусками фиксированного размера; размер буфера выбирается с помощью эвристики, пытающейся определить «размер блока» базового устройства и отталкивающейся от io.DEFAULT_BUFFER_SIZE. Во многих системах буфер обычно имеет длину 4096 или 8192 байта.
«Интерактивные» текстовые файлы (файлы, для которых isatty() возвращает True) используют буферизацию строк. Для остальных текстовых файлов используется политика, описанная выше для бинарных файлов.

encoding - это имя кодировки, используемой для декодирования или кодирования файла. Это значение следует использовать только в текстовом режиме. Кодировка по умолчанию зависит от платформы (то, что возвращает locale.getencoding()), но можно использовать любую text encoding, поддерживаемую 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', перевод не выполняется. Если newline имеет любое из других допустимых значений, все записанные символы '\n' переводятся в заданную строку.

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

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

Вновь созданный файл имеет номер non-inheritable.

В следующем примере используется параметр 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

Тип file object, возвращаемого функцией 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.

Поднимает auditing event open с аргументами file, mode, flags.

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

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

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

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

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

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

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

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

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

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

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

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 base и exp, если присутствует mod, mod также должен быть целочисленного типа и 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)¶

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

Все аргументы, не являющиеся ключевыми словами, преобразуются в строки, как это делает str(), и записываются в поток, разделенные sep и сопровождаемые end. И sep, и end должны быть строками; они также могут быть None, что означает использование значений по умолчанию. Если не заданы объекты, 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 вызовет getter, c.x = value - setter, а del c.x - deleter.

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

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

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

Декоратор @property превращает метод voltage() в «геттер» для одноименного атрибута, доступного только для чтения, и устанавливает docstring для 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: Документация объектов свойств теперь доступна для записи.

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

round(number, ndigits=None)¶

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

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

Для общего объекта Python number, round делегирует number.__round__.

Примечание

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

class set

class set(iterable)

Возвращает новый объект set, опционально с элементами, взятыми из iterable. set - это встроенный класс. Документацию по этому классу смотрите в 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() и т. д.

Примечание

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

class slice(stop)¶

class slice(start, stop, step=None)

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

start¶

stop¶

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

Объекты Slice также генерируются при использовании синтаксиса расширенного индексирования. Например: a[start:stop:step] или a[start:stop, i]. Альтернативный вариант, возвращающий iterator, см. в разделе itertools.islice().

Изменено в версии 3.12: Объекты Slice теперь являются hashable (при условии, что 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 рекомендует реализовать все шесть rich comparisons. Это поможет избежать ошибок при использовании тех же данных с другими инструментами упорядочивания, такими как max(), которые полагаются на другой базовый метод. Реализация всех шести сравнений также поможет избежать путаницы при сравнении смешанных типов, которые могут вызывать отраженный метод __gt__().

Примеры сортировки и краткое руководство по сортировке смотрите в Техника сортировки.

@staticmethod¶

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

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

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

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

Статический метод может быть вызван как у класса (например, C.f()), так и у экземпляра (например, C().f()). Более того, статический метод descriptor также является вызываемым, поэтому его можно использовать в определении класса (например, 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(object='')

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

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

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

sum(iterable, /, start=0)¶

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

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

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

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

class super¶

class super(type, object_or_type=None)

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

Параметр object_or_type определяет method resolution order для поиска. Поиск начинается с класса, следующего сразу за type.

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

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

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

При вызове непосредственно внутри обычного метода класса оба аргумента могут быть опущены («zero-argument 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() также работает для поиска атрибутов. Один из возможных вариантов использования этого метода - вызов descriptors в родительском или дочернем классе.

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

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

Практические рекомендации по разработке совместных занятий с использованием super() см. в guide to using super().

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

class type(object)¶

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

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

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

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

vars()¶

vars(object)

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

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

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

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

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

zip(*iterables, strict=False)¶

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

Пример:

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

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

Другой способ представить zip() заключается в том, что он превращает строки в столбцы, а столбцы - в строки. Это аналогично transposing a matrix.

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() возвращает итератор из 1-кортежей. При отсутствии аргументов возвращается пустой итератор.

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

Порядок вычисления итераций слева направо гарантирован. Это позволяет использовать идиому для кластеризации серии данных на группы длиной 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 теперь игнорируется.

Сноски

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

Предыдущий раздел

Следующий раздел