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

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

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

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

aiter(async_iterable)

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

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

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

all(iterable)

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

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

awaitable anext(async_iterator)

awaitable anext(async_iterator, default)

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

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

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

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

any(iterable)

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

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

ascii(object): Как и repr(), возвращает строку, содержащую удобочитаемое представление объекта, но экранирует не-ASCII-символы в строке, возвращаемой repr(), используя escapes \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. Аргумент преобразуется с помощью стандартной процедуры проверки истинности. Если аргумент ложный или опущен, возвращается 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.

END_OF_DOCUMENT_MARKER

класс bytearray(source=b'')

класс bytearray(source, encoding)

класс bytearray(source, encoding, errors)

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

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

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

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

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

класс bytes(source=b'')

класс bytes(source, encoding)

класс bytes(source, encoding, errors)

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

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

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

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

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

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

chr(i)

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

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

@classmethod

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

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

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

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

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

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

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

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

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

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

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

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

Аргумент mode определяет тип компилируемого кода; он может быть 'exec' если исходный код состоит из последовательности инструкций, '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 (удаляются утверждения, __debug__ ложно) или 2 (удаляются также строковые документации).

Эта функция генерирует 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 теперь может быть передан в flags для включения поддержки глобальных 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__() не определены.

delattr(object, name): Это аналог setattr(). Аргументы — объект и строка. Строка должна быть именем одного из атрибутов объекта. Функция удаляет атрибут с указанным именем, если это разрешено объектом. Например, delattr(x, 'foobar') эквивалентно del x.foobar. name не обязательно должно быть идентификатором 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)

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

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

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

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

eval(expression, globals=None, locals=None)

Параметры:

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

Возвращает:

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

Возбуждает:

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

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

Пример:

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

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

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

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

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

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

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

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

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

Примечание

Большинству пользователей достаточно передать аргумент globals и никогда не использовать locals. Если exec получает два отдельных объекта как globals и locals, код будет выполняться так, как если бы он был встроен в определение класса.

Если словарь globals не содержит значения для ключа __builtins__, ссылка на словарь встроенного модуля builtins вставляется под этим ключом. Таким образом, вы можете управлять доступными встроенными функциями для выполняемого кода, поместив свой собственный __builtins__ словарь в globals перед передачей его функции exec().

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

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

Примечание

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

Примечание

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

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

filter(function, iterable)

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

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

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

class float(number=0.0, /)

class float(string, /)

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

Примеры:

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

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

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

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

В противном случае, если аргумент является целым числом или числом с плавающей точкой, возвращается число с плавающей точкой с тем же значением (в пределах точности чисел с плавающей точкой Python). Если аргумент выходит за пределы диапазона Python float, будет поднято исключение 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='')

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

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

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

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

class frozenset(iterable=set())

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

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

END_OF_DOCUMENT_MARKER

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

Примечание

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

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

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

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

Примечание

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

help()

help(request)

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

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

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

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

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

id(object)

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

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

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

input()

input(prompt)

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

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

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

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

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

class int(number=0, /)

class int(string, /, base=10)

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

Примеры:

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

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

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

Целая строка в системе счисления n содержит цифры, каждая из которых представляет значение от 0 до n-1. Значения 0–9 могут быть представлены любыми десятичными цифрами Unicode. Значения 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, float, complex.

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

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

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

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

Изменено в версии 3.11: Делегирование __trunc__() устарело.

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

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

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

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

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

iter(object)

iter(object, sentinel)

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

END_OF_DOCUMENT_MARKER

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

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

Примечание

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

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

max(iterable, *, key=None)

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

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

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

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

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

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

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

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

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

END_OF_DOCUMENT_MARKER

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Добавлен параметр opener.
Добавлен режим 'x'.
IOError раньше использовался, теперь он является псевдонимом OSError.
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)

Возвращает основание в степени показатель; если модуль присутствует, возвращает основание в степени показатель по модулю модуль (вычисляется более эффективно, чем 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:

>>> 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:

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 будет строкой документации атрибута свойства. В противном случае, свойство скопирует строку документации fget (если она существует). Это позволяет легко создавать только для чтения свойства, используя property() в качестве декоратора:

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

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

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

round(number, ndigits=None)

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

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

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

Примечание

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

class set

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() и т. д..

Примечание

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

END_OF_DOCUMENT_MARKER

class slice(stop)

class slice(start, stop, step=None)

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

start

stop

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

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

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

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

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

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

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

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Более подробную информацию о статических методах см. в Стандартная иерархия типов.

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

class str(object='')

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

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

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

sum(iterable, /, start=0)

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

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

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

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

class super

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

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

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

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

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

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

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

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

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

class type(object)

класс 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(). Обратите внимание, что словарь locals полезен только для чтения, поскольку обновления словаря locals игнорируются.

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

END_OF_DOCUMENT_MARKER ```

zip(*iterables, strict=False)

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

Пример:

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

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

Другой способ понять zip() — это превращение строк в столбцы, а столбцов — в строки. Это аналогично транспонированию матрицы.

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

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

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

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

Примечания

© 2001–2024 Python Software Foundation
Licensed under the PSF License.
https://docs.python.org/3.12/library/functions.html