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

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

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

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

aiter(async_iterable)¶

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

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

Добавлено в версии 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[, default])¶

При ожидании возвращает следующий элемент из заданного asynchronous iterator, или 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(), используя эскапады \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([x])¶: Возвращает булево значение, т.е. одно из True или False. x преобразуется с помощью стандартного truth testing procedure. Если x ложно или опущено, возвращается False; в противном случае возвращается True. Класс bool является подклассом класса int (см. Числовые типы — int, float, complex). Он не может быть подклассом в дальнейшем. Его единственными экземплярами являются False и True (см. Булевы значения).

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

breakpoint(*args, **kws)¶

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

Вызывает auditing event builtins.breakpoint с аргументом breakpointhook.

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

class bytearray([source[, encoding[, errors]]])

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

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

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

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

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

class bytes([source[, encoding[, errors]]])

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

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

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

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

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

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

chr(i)¶

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

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

@classmethod¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вызывает auditing event compile с аргументами source, filename.

Примечание

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

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

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

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

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

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

class complex([real[, imag]])¶

Возвращает комплексное число со значением real + imag*1j или преобразует строку или число в комплексное число. Если первым параметром является строка, она будет интерпретирована как комплексное число, и функция должна быть вызвана без второго параметра. Второй параметр никогда не может быть строкой. Каждый аргумент может быть любым числовым типом (включая комплексный). Если imag опущен, то по умолчанию он равен нулю, а конструктор служит для преобразования чисел, как int и float. Если оба аргумента опущены, возвращается 0j.

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

Примечание

При преобразовании из строки строка не должна содержать пробелов вокруг центрального оператора + или -. Например, complex('1+2j') - это нормально, но complex('1 + 2j') приводит к ValueError.

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

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])¶

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

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

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

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

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

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

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

Примечание

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

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

enumerate(iterable, start=0)¶

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

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

Эквивалент:

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

eval(expression[, globals[, locals]])¶

Аргументами являются строка и необязательные globals и locals. Если указано, globals должен быть словарем. Если указано, locals может быть любым объектом отображения.

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

Возвращаемое значение - это результат вычисленного выражения. Синтаксические ошибки сообщаются как исключения. Пример:

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

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

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

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

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

Вызывает auditing event exec с аргументом code_object.

exec(object[, globals[, locals]])¶

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

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

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

Вызывает auditing event exec с аргументом code_object.

Примечание

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

Примечание

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

filter(function, iterable)¶

Построить итератор из тех элементов iterable, для которых function возвращает true. 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 возвращает false.

class float([x])¶

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

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

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

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

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

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

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

Примеры:

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

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

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

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

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

format(value[, format_spec])¶

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

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

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

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

class frozenset([iterable])

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

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

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

Примечание

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

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

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

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

Примечание

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

help([object])¶

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

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

Эта функция добавляется во встроенное пространство имен модулем 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, используйте метод float.hex().

id(object)¶

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

CPython implementation detail: This is the address of the object in memory.

Вызывает auditing event builtins.id с аргументом id.

input([prompt])¶

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

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

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

Вызывает auditing event builtins.input с аргументом prompt.

Вызывает auditing event builtins.input/result с аргументом result.

class int([x])¶

class int(x, base=10)

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

Если x не является числом или если задано base, то x должно быть строкой, bytes или bytearray, представляющей integer literal в радиксе base. По желанию, перед литералом может стоять + или - (без пробела между ними) и окружен пробелами. Литерал base-n состоит из цифр от 0 до n-1, причем a - z (или A - Z) имеют значения от 10 до 35. По умолчанию база равна 10. Допустимыми значениями являются 0 и 2–36. Литералы Base-2, -8 и -16 могут иметь префикс 0b/0B, 0o/0O или 0x/0X, как и целочисленные литералы в коде. Основание 0 означает интерпретировать точно как литерал кода, так что фактическое основание равно 2, 8, 10 или 16, и поэтому 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: x теперь является только позиционным параметром.

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

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

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

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

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

iter(object[, sentinel])¶

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

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

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

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

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

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

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

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

Примечание

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

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

max(iterable, *[, key, default])¶

max(arg1, arg2, *args[, key])

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

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

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

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

Добавлено в версии 3.4: Аргумент по умолчанию только для ключевого слова.

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

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

min(iterable, *[, key, default])¶

min(arg1, arg2, *args[, key])

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

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

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

Добавлено в версии 3.4: Аргумент по умолчанию только для ключевого слова.

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

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

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

Примечание

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

oct(x)¶

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

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

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

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

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

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

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

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

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

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

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

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

Существует дополнительный разрешенный символ режима 'U', который больше не имеет никакого эффекта и считается устаревшим. Ранее он разрешал universal newlines в текстовом режиме, что стало поведением по умолчанию в Python 3.0. За более подробной информацией обратитесь к документации параметра newline.

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Вызывает auditing event open с аргументами file, mode, flags.

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

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

Был добавлен параметр opener.

Был добавлен режим 'x'.

IOError раньше поднимался, теперь это псевдоним OSError.

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

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

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

Deprecated since version 3.4, removed in version 3.10: Режим 'U'.

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

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

Добавлен обработчик ошибок 'namereplace'.

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

Добавлена поддержка приема объектов, реализующих os.PathLike.

В Windows открытие буфера консоли может вернуть подкласс io.RawIOBase, отличный от io.FileIO.

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

pow(base, exp[, mod])¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

Если c является экземпляром C, c.x вызовет getter, c.x = value вызовет setter, а del c.x - deleter.

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

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

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

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

Объект свойства имеет методы 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]): Вместо того, чтобы быть функцией, range на самом деле является неизменяемым типом последовательности, как документировано в Диапазоны и Типы последовательностей — list, tuple, range.

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

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

round(number[, ndigits])¶

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

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

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

Примечание

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

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.

Примечание

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

class slice(stop)¶
class slice(start, stop[, step]): Возвращает объект slice, представляющий набор индексов, указанных range(start, stop, step). Аргументы start и step по умолчанию равны None. Объекты Slice имеют атрибуты данных только для чтения start, stop и step, которые просто возвращают значения аргументов (или их значения по умолчанию). У них нет другой явной функциональности; однако они используются NumPy и другими сторонними пакетами. Объекты Slice также создаются при использовании расширенного синтаксиса индексирования. Например: a[start:stop:step] или a[start:stop, i]. Смотрите itertools.islice() для альтернативной версии, которая возвращает итератор.

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

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

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

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

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

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

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

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

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

@staticmethod¶

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

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

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

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

Статический метод может быть вызван либо на классе (например, 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 - это встроенная строка class. Для получения общей информации о строках см. раздел Тип текстовой последовательности — str.

sum(iterable, /, start=0)¶

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

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

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

class super([type[, object-or-type]])¶

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

Параметр объект или тип определяет method resolution order для поиска. Поиск начинается с класса, расположенного сразу после типа.

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

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

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

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

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

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

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

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

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

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

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

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

class type(object)¶

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

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

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

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

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

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

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

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

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

vars([object])¶

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

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

Без аргумента vars() действует как locals(). Обратите внимание, что словарь locals полезен только для чтения, так как обновления словаря locals игнорируются.

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

zip(*iterables, strict=False)¶

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

Пример:

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

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

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

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

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

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

Сноски

1: Обратите внимание, что синтаксический анализатор принимает только соглашение о конце строки в стиле Unix. Если вы читаете код из файла, убедитесь, что используете режим преобразования новых строк для преобразования новых строк в стиле Windows или Mac.

Введение

Встроенные константы

Вернуться на верх

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

Python 3.10

Содержание

Дополнительно

Вы здесь: