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

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

aiter(async_iterable)¶

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

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

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

all(iterable)¶

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

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

awaitable anext(async_iterator)¶

awaitable anext(async_iterator, default)

When awaited, return the next item from the given asynchronous iterator, or default if given and the iterator is exhausted.

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

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

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

any(iterable)¶

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

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

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

bin(x)¶

Convert an integer number to a binary string prefixed with «0b». The result is a valid Python expression. If x is not a Python int object, it has to define an __index__() method that returns an integer. Some examples:

>>> 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 (см. Numeric Types — int, float, complex). От него нельзя создавать производные классы дальше. Его единственными экземплярами являются False и True (см. Boolean Type - bool).

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

breakpoint(*args, **kws)¶

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

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

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

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

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

class bytearray(source=b'')

class bytearray(source, encoding)

class bytearray(source, encoding, errors)

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

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

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

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

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

class bytes(source=b'')

class bytes(source, encoding)

class bytes(source, encoding, errors)

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

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

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

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

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

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

chr(i)¶

Return the string representing a character whose Unicode code point is the integer i. For example, chr(97) returns the string 'a', while chr(8364) returns the string '€'. This is the inverse of ord().

The valid range for the argument is from 0 through 1,114,111 (0x10FFFF in base 16). ValueError will be raised if i is outside that range.

@classmethod¶

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

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

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

Конутрукция @classmethod является формой вызова декоратора — см. Function definitions для подробностей.

Метод класса можно вызвать как на самом классе (например, 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)¶

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

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

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

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

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

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

This function raises SyntaxError if the compiled source is invalid, and ValueError if the source contains null bytes.

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

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

Примечание

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

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

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

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

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

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

class complex(number=0, /)¶

class complex(string, /)

class complex(real=0, imag=0)

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

Примеры:

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

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

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

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

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

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

Описание комплексного типа приведено в Numeric Types — 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)

Create a new dictionary. The dict object is the dictionary class. See dict and Mapping Types — dict for documentation about this class.

For other containers see the built-in list, set, and tuple classes, as well as the collections module.

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 должен быть последовательностью, итератором или другим объектом, поддерживающим итерацию. Метод __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 | code object) – Выражение Python.
globals (dict | None) – Глобальное пространство имён (по умолчанию: None).
locals (mapping | None) – Локальное пространство имён (по умолчанию: None).

Результат:

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

выбрасывает исключение:

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

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

This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.

The expression argument is parsed and evaluated as a Python expression (technically speaking, a condition list) using the globals and locals dictionaries as global and local namespace. If the globals dictionary is present and does not contain a value for the key __builtins__, a reference to the dictionary of the built-in module builtins is inserted under that key before expression is parsed. That way you can control what builtins are available to the executed code by inserting your own __builtins__ dictionary into globals before passing it to eval(). If the locals dictionary is omitted it defaults to the globals dictionary. If both dictionaries are omitted, the expression is executed with the globals and locals in the environment where eval() is called. Note, eval() does not have access to the nested scopes (non-locals) in the enclosing environment.

Пример:

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

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

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

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

See ast.literal_eval() for a function that can safely evaluate strings with expressions containing only literals.

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

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

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

This function executes arbitrary code. Calling it with user-supplied input may lead to security vulnerabilities.

This function supports dynamic execution of Python code. object must be either a string or a code object. If it is a string, the string is parsed as a suite of Python statements which is then executed (unless a syntax error occurs). [1] If it is a code object, it is simply executed. In all cases, the code that’s executed is expected to be valid as file input (see the section Файловый ввод in the Reference Manual). Be aware that the nonlocal, yield, and return statements may not be used outside of function definitions even within the context of code passed to the exec() function. The return value is None.

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

Примечание

Most users should just pass a globals argument and never locals. If exec gets two separate objects as globals and locals, the code will be executed as if it were embedded in a class definition.

If the globals dictionary does not contain a value for the key __builtins__, a reference to the dictionary of the built-in module builtins is inserted under that key. That way you can control what builtins are available to the executed code by inserting your own __builtins__ dictionary into globals before passing it to exec().

The closure argument specifies a closure–a tuple of cellvars. It’s only valid when the object is a code object containing free variables. The length of the tuple must exactly match the number of free variables referenced by the code object.

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

Примечание

The built-in functions globals() and locals() return the current global and local dictionary, respectively, which may be useful to pass around for use as the second and third argument to exec().

Примечание

The default locals act as described for function locals() below: modifications to the default locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the code on locals after function exec() returns.

Изменено в версии 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, будет выброшено исключение OverflowError.

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

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

Тип float описан в Numeric Types — int, float, complex.

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

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

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

format(value, format_spec='')¶

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

Значение по умолчанию для 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())

Return a new frozenset object, optionally with elements taken from iterable. frozenset is a built-in class. See frozenset and Set Types — set, frozenset for documentation about this class.

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

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

Примечание

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

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

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

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

Примечание

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

help()¶

help(request)

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

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

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

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

hex(x)¶

Convert an integer number to a lowercase hexadecimal string prefixed with «0x». If x is not a Python int object, it has to define an __index__() method that returns an integer. Some examples:

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

Это адрес объекта в памяти.

Возбуждает событие аудита 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

If the argument defines __int__(), int(x) returns x.__int__(). If the argument defines __index__(), it returns x.__index__(). If the argument defines __trunc__(), it returns x.__trunc__(). For floating-point numbers, this truncates towards zero.

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

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

Тип целого числа описан в Numeric Types — int, float, complex.

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

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

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

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

Изменено в версии 3.11: The delegation to __trunc__() is deprecated.

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

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

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

issubclass(class, classinfo)¶: Return True if class is a subclass (direct, indirect, or virtual) of classinfo. A class is considered a subclass of itself. classinfo may be a tuple of class objects (or recursively, other such tuples) or a Union Type, in which case return True if class is a subclass of any entry in classinfo. In any other case, a TypeError exception is raised.

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

iter(object)¶

iter(object, sentinel)

Return an iterator object. The first argument is interpreted very differently depending on the presence of the second argument. Without a second argument, object must be a collection object which supports the iterable protocol (the __iter__() method), or it must support the sequence protocol (the __getitem__() method with integer arguments starting at 0). If it does not support either of those protocols, TypeError is raised. If the second argument, sentinel, is given, then object must be a callable object. The iterator created in this case will call object with no arguments for each call to its __next__() method; if the value returned is equal to sentinel, StopIteration will be raised, otherwise the value will be returned.

См. также Iterator Types.

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

Функция len выбрасывает исключение OverflowError на длинах, превышающих sys.maxsize, таких как range(2 ** 100).

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

locals()¶: Update and return a dictionary representing the current local symbol table. Free variables are returned by locals() when it is called in function blocks, but not in class blocks. Note that at the module level, locals() and globals() are the same dictionary.

Примечание

The contents of this dictionary should not be modified; changes may not affect the values of local and free variables used by the interpreter.

map(function, iterable, *iterables)¶: Return an iterator that applies function to every item of iterable, yielding the results. If additional iterables arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. With multiple iterables, the iterator stops when the shortest iterable is exhausted. For cases where the function inputs are already arranged into argument tuples, see 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.

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

min(iterable, *, key=None)¶

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

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

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

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

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

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

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

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

next(iterator)¶
next(iterator, default): Retrieve the next item from the iterator by calling its __next__() method. If default is given, it is returned if the iterator is exhausted, otherwise StopIteration is raised.

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

Примечание

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

oct(x)¶

Convert an integer number to an octal string prefixed with «0o». The result is a valid Python expression. If x is not a Python int object, it has to define an __index__() method that returns an integer. For example:

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

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

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

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

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

Открывает file и возвращает соответствующий файловый объект. Если файл не удаётся открыть, возбуждается исключение OSError. См. Reading and Writing Files для получения дополнительных примеров использования этой функции.

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

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

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

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

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

Примечание

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

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

Binary files are buffered in fixed-size chunks; the size of the buffer is chosen using a heuristic trying to determine the underlying device’s «block size» and falling back on io.DEFAULT_BUFFER_SIZE. On many systems, the buffer will typically be 4096 or 8192 bytes long.
«Интерактивные» текстовые файлы (файлы, для которых isatty() возвращает True) используют построчную буферизацию. Остальные текстовые файлы используют ту же политику, что и бинарные файлы.

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

errors is an optional string that specifies how encoding and decoding errors are to be handled—this cannot be used in binary mode. A variety of standard error handlers are available (listed under Error Handlers), though any error handling name that has been registered with codecs.register_error() is also valid. The standard names include:

'strict' to raise a ValueError exception if there is an encoding error. The default value of None has the same effect.
'ignore' ignores errors. Note that ignoring encoding errors can lead to data loss.
'replace' causes a replacement marker (such as '?') to be inserted where there is malformed data.
'surrogateescape' will represent any incorrect bytes as low surrogate code units ranging from U+DC80 to U+DCFF. These surrogate code units will then be turned back into the same bytes when the surrogateescape error handler is used when writing data. This is useful for processing files in an unknown encoding.
'xmlcharrefreplace' is only supported when writing to a file. Characters not supported by the encoding are replaced with the appropriate XML character reference &#nnn;.
'backslashreplace' replaces malformed data by Python’s backslashed escape sequences.
'namereplace' (also only supported when writing) replaces unsupported characters with \N{...} escape sequences.

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

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

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

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

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

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

>>> 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('Это будет записано в somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # не допускаем утечки файлового дескриптора

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

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

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

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

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

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

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

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

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

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

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

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

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

ord(c)¶: Given a string representing one Unicode character, return an integer representing the Unicode code point of that character. For example, ord('a') returns the integer 97 and ord('€') (Euro sign) returns 8364. This is the inverse of chr().

pow(base, exp, mod=None)¶

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

The arguments must have numeric types. With mixed operand types, the coercion rules for binary arithmetic operators apply. For int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, pow(10, 2) returns 100, but pow(10, -2) returns 0.01. For a negative base of type int or float and a non-integral exponent, a complex result is delivered. For example, pow(-9, 0.5) returns a value close to 3j. Whereas, for a negative base of type int or float with an integral exponent, a float result is delivered. For example, pow(-9, 2.0) returns 81.0.

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

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

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

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

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

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

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

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

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

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

Изменено в версии 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, "Я — свойство 'x'.")

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

If given, doc will be the docstring of the property attribute. Otherwise, the property will copy fget’s docstring (if it exists). This makes it possible to create read-only properties easily using property() as a decorator:

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

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

Декоратор @property превращает метод voltage() в функцию для получения значения атрибута только для чтения с тем же именем, и устанавливает строку документации для voltage равной «Вернуть текущее напряжение.»

@getter¶

@setter¶

@deleter¶

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

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

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

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

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

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

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

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

class range(stop)
class range(start, stop, step=1): Вместо того чтобы быть функцией, range на самом деле является неизменяемым типом последовательности, как описано в Ranges и Sequence Types — 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)¶: Return a reverse iterator. seq must be an object which has a __reversed__() method or supports the sequence protocol (the __len__() method and the __getitem__() method with integer arguments starting at 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. Это не ошибка, это результат того факта, что большинство десятичных дробей не могут быть точно представлены в виде float. См. Арифметика с плавающей точкой: проблемы и ограничения для получения дополнительной информации.

class set

class set(iterable)

Return a new set object, optionally with elements taken from iterable. set is a built-in class. See set and Set Types — set, frozenset for documentation about this class.

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

setattr(object, name, value)¶

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

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

Примечание

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

class slice(stop)¶

class slice(start, stop, step=None)

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

start¶

stop¶

step¶: Slice objects have read-only data attributes start, stop, and step which merely return the argument values (or their default). They have no other explicit functionality; however, they are used by NumPy and other third-party packages.

Slice objects are also generated when extended indexing syntax is used. For example: a[start:stop:step] or a[start:stop, i]. See itertools.islice() for an alternate version that returns an iterator.

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

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

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

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

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

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

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

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

The sort algorithm uses only < comparisons between items. While defining an __lt__() method will suffice for sorting, PEP 8 recommends that all six rich comparisons be implemented. This will help avoid bugs when using the same data with other ordering tools such as max() that rely on a different underlying method. Implementing all six comparisons also helps avoid confusion for mixed type comparisons which can call reflected the __gt__() method.

Для примеров сортировки и краткого руководства по ней см. Sorting Techniques.

@staticmethod¶

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

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

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

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

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

Static methods in Python are similar to those found in Java or C++. Also, see classmethod() for a variant that is useful for creating alternate class constructors.

Как и все декораторы, 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 для object. См. str() для подробностей.

str — это встроенный класс строки. Для получения общей информации о строках см. Text Sequence Type — str.

sum(iterable, /, start=0)¶

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

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

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

Изменено в версии 3.12: Summation of floats switched to an algorithm that gives higher accuracy on most builds.

class super¶

class super(type, object_or_type=None)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class type(object)¶

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

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

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

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

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

См. также:

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

См. также Customizing class creation.

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

vars()¶

vars(object)

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

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

Without an argument, vars() acts like locals(). Note, the locals dictionary is only useful for reads since updates to the locals dictionary are ignored.

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

zip(*iterables, strict=False)¶

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

Пример:

>>> for item in zip([1, 2, 3], ['сахар', 'специи', 'всё хорошее']):
...     print(item)
...
(1, 'сахар')
(2, 'специи')
(3, 'всё хорошее')

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

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

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

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

By default, zip() stops when the shortest iterable is exhausted. It will ignore the remaining items in the longer iterables, cutting off the result to the length of the shortest iterable:
```
>>> list(zip(range(3), ['фу', 'фи', 'фа', 'фум']))
[(0, 'фу'), (1, 'фи'), (2, 'фа')]
```
zip() часто используется в случаях, когда предполагается, что итерируемые объекты имеют одинаковую длину. В такой ситуации рекомендуется использовать опцию strict=True. Вывод в таком случае не будет отличаться от обычного вызова zip():
```
>>> list(zip(('а', 'б', 'в'), (1, 2, 3), strict=True))
[('а', 1), ('б', 2), ('в', 3)]
```
Unlike the default behavior, it raises a ValueError if one iterable is exhausted before the others:
```
>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
```
Без аргумента strict=True, любая ошибка, приводящая к перебору объектов разной длины, будет подавлена, что может проявиться как труднонаходимая ошибка в другой части программы.
Более короткие итерируемые объекты можно дополнить постоянным значением, чтобы все объекты имели одинаковую длину. Это делается с помощью itertools.zip_longest().

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

Советы и приёмы:

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

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

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

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

Эта страница