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

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

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

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

aiter(async_iterable)

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

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

Новое в версии 3.10.

all(iterable)

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

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

awaitable anext(async_iterator)

awaitable anext(async_iterator, default)

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

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

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

Новое в версии 3.10.

any(iterable)

Возвращает True если какой-либо элемент из итерируемой последовательности истинен. Если итерируемая последовательность пуста, возвращает False. Эквивалентно:

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

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

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

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

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

Новое в версии 3.7.

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

класс bytearray(source, encoding)

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

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

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

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

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

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

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

класс bytes(source, encoding)

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

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

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

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

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

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

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

chr(i)

Возвращает строку, представляющую символ, код 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 — это функция декоратор — см. Определения функций для получения подробностей.

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

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

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

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

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

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

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

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

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

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

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

Аргумент optimize задаёт уровень оптимизации компилятора; значение по умолчанию -1 выбирает уровень оптимизации интерпретатора, заданный параметрами -O. Явные уровни — 0 (без оптимизации; __debug__ равно true), 1 (удаляются утверждения, __debug__ равно false) или 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.

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

class complex(real=0, imag=0)

class complex(string)

Возвращает комплексное число со значением 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. name не обязательно должен быть идентификатором Python (см. setattr()).

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir()

dir(object)

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

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

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

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

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

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

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

Примечание

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

divmod(a, b)

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

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

enumerate(iterable, start=0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

Примечание

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

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

filter(function, iterable)

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

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

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

class float(x=0.0)

Возвращает число с плавающей точкой, созданное из числа или строки 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 — это десятичная цифра Юникода (символ в категории Юникода Nd). Регистр не важен, поэтому, например, «inf», «Inf», «INFINITY» и «iNfINity» — это допустимые способы записи положительной бесконечности.

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

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

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

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

Примечание

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

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

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

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

Примечание

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

help()

help(request)

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

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

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

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

hex(x)

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

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

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

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

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

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

Примечание

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

id(object)

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

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

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

input()

input(prompt)

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

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

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

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

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

class int(x=0)

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

Целочисленная строка в системе счисления 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, как и целочисленные литералы в коде. Для base 0 строка интерпретируется аналогично целочисленному литералу в коде, где фактическая система счисления определяется префиксом (2, 8, 10 или 16). Для base 0 также запрещены ведущие нули: int('010', 0) не является допустимым, в то время как int('010') и int('010', 8) — да.

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

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

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

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

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

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

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

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

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

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

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

iter(object)

iter(object, sentinel)

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

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

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

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

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

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

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

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

Примечание

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

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

max(iterable, *, key=None)

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

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

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

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

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

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

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

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

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

min(iterable, *, key=None)

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

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

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

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

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

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

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

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

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

Примечание

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

oct(x)

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pow(base, exp, mod=None)

Возвращает основание в степени показателя; если mod задан, возвращает основание в степени показателя по модулю 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 основания и показателя, если mod задан, mod также должен быть целого типа и mod должен быть не нулевым. Если mod задан и показатель отрицательный, основание должно быть взаимно простым с mod. В этом случае возвращается pow(inv_base, -exp, mod), где inv_base — обратное значение основания по модулю mod.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

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

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

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

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

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

@getter

@setter

@deleter

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

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

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

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

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

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

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

class range(stop)
class range(start, stop, step=1): Вместо того, чтобы быть функцией, range на самом деле является неизменяемым типом последовательности, как документировано в Диапазонах и Типы последовательностей — список, кортеж, диапазон.

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

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

round(number, ndigits=None)

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

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

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

Примечание

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

class set

class set(iterable)

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

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

setattr(object, name, value)

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

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

Примечание

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

class slice(stop)

class slice(start, stop, step=None)

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

start

stop

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

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

Примеры сортировки и краткий учебник по сортировке см. в Руководстве по сортировке.

@staticmethod

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

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

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

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

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Дополнительную информацию о статических методах см. в Стандартной иерархии типов.

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

class str(object='')

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

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

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

sum(iterable, /, start=0)

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

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

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

class super

класс super(type, object_or_type=None)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

class type(object)

класс type(name, bases, dict, **kwds)

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

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

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

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

См. также Объекты типа.

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

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

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

vars()

vars(object)

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

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

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

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

END_OF_DOCUMENT_MARKER

zip(*iterables, strict=False)

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

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

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