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

Интерпретатор 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)¶

Возвращает асинхронный итератор для асинхронного итерируемого объекта. Эквивалентно вызову 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[, default])¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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 в шестнадцатеричной системе). ValueError будет возбуждено, если i выходит за этот диапазон.

@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__.

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

class complex([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.

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

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])¶

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

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

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

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

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

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

>>> import struct
>>> dir()   # показать имена в пространстве имён модуля  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Примечание

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

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

enumerate(iterable, start=0)¶

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

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

Эквивалентно следующему:

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

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

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

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

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

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

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

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

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

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

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

exec(object[, globals[, 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().

Примечание

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

Примечание

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

filter(function, iterable)¶

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

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

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

class float([x])¶

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

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

sign        ::=  "+" | "-"
infinity    ::=  "Infinity" | "inf"
nan         ::=  "nan"
digitpart   ::=  digit (["_"] digit)*
number      ::=  [digitpart] "." digitpart | digitpart ["."]
exponent    ::=  ("e" | "E") ["+" | "-"] digitpart
floatnumber ::=  number [exponent]
floatvalue  ::=  [sign] (floatnumber | infinity | nan)

Здесь digit – это десятичная цифра Unicode (символ из общей категории Unicode Nd). Регистр не имеет значения, поэтому, например, «inf», «Inf», «INFINITY» и «iNfINity» – все допустимые варианты написания положительной бесконечности.

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

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

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

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

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

class frozenset([iterable])

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

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

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() усекает возвращаемое значение на основе разрядности хост-машины. См. __hash__() для подробностей.

help([object])¶

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

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

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

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

hex(x)¶

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

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

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

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

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

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

Примечание

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

id(object)¶

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

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

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

input([prompt])¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

iter(object[, sentinel])¶

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

Есть два необязательных аргумента, передаваемых только по ключу. Аргумент 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 view), созданный из переданного аргумента. Дополнительную информацию см. в Memory Views.

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

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

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

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

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

Новое в версии 3.4: Аргумент default, указываемый только по ключевому слову.

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

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

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

Примечание

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

oct(x)¶

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

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

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

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

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

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

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

file – это path-like object, задающий путь (абсолютный или относительный относительно текущей рабочей директории) к открываемому файлу или целый файловый дескриптор оборачиваемого файла. (Если задан файловый дескриптор, он закрывается при закрытии возвращаемого объекта I/O, если только 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', который больше не имеет никакого эффекта и считается устаревшим. Ранее он включал универсальные символы новой строки в текстовом режиме, что стало поведением по умолчанию в 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()), но может использоваться любая текстовая кодировка, поддерживаемая Python. См. модуль codecs для списка поддерживаемых кодировок.

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

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

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

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

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

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

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

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

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('This will be written to somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # не допустить утечки файлового дескриптора

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

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

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

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

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

Добавлен параметр opener.

Добавлен режим 'x'.

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

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

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

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

Устарело с версии 3.4, удалено в версии 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=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 равен true, поток принудительно сбрасывается.

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

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

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

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 вызовет геттер, c.x = value вызовет сеттер, а del c.x – делитер.

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

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

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

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

Объект property имеет методы 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 в данном случае.)

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

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

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

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

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

round(number[, ndigits])¶

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

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

Для произвольного объекта Python number функция round делегирует выполнение number.__round__.

Примечание

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

class set([iterable])

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

Для других контейнеров см. встроенные классы 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() и т.д.

Примечание

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

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

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

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

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

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

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

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

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

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

Примеры сортировки и краткое руководство см. в Sorting HOW TO.

@staticmethod¶

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

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

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

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

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Дополнительную информацию о статических методах см. в The standard type hierarchy.

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

class str(object='')

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

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

str – это встроенный строковый класс. Общую информацию о строках см. в Text Sequence Type – str.

sum(iterable, /, start=0)¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class tuple([iterable]): tuple на самом деле не функция, а неизменяемый тип последовательности, как описано в Кортежи и Типы последовательностей – 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))

См. также Type Objects.

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

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

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

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

Крайние случаи: с одним аргументом-итерируемым объектом zip() возвращает итератор из 1-кортежей. Без аргументов возвращает пустой итератор.

Советы и хитрости:

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

Оператор import spam.ham приводит к следующему вызову:

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

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

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

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

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

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

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

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

Сноски

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