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

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

ожидаемый объект anext(async_iterator, default)

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

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

Эта функция вызывает метод __anext__() объекта async_iterator, возвращая ожидаемый объект. При ожидании он возвращает следующее значение итератора. Если задан 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; см. Операции с bytes и bytearray.

Необязательный параметр 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 и Операции с 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 в шестнадцатеричной системе). Если i выходит за этот диапазон, возникает исключение ValueError.

@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)

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

class complex(real=0, imag=0)

класс 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.

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

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

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

delattr(object, name)

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

класс dict(**kwarg)

класс dict(mapping, **kwarg)

класс dict(iterable, **kwarg)

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

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

dir()

dir(object)

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

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

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

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

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

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

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

Примечание

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

divmod(a, b)

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

enumerate(iterable, start=0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

Примечание

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

Изменено в версии 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"
digit       ::=  <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart   ::=  digit (["_"] digit)*
number      ::=  [digitpart] "." digitpart | digitpart ["."]
exponent    ::=  ("e" | "E") ["+" | "-"] digitpart
floatnumber ::=  number [exponent]
floatvalue  ::=  [sign] (floatnumber | infinity | nan)

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

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

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

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

Примеры:

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

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

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

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

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

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)

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

Примечание

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

globals()

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

hasattr(object, name)

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

hash(object)

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

Примечание

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

help()

help(request)

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

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

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

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

hex(x)

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

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

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

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

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

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

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

Изменено в версии 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 должен быть вызываемым объектом. Созданный в этом случае итератор при каждом вызове своего метода __next__() вызывает object без аргументов; если возвращённое значение равно 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)

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

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

class list

class list(iterable)

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

locals()

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

Примечание

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

map(function, iterable, *iterables)

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

max(iterable, *, key=None)

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

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

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

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

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

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

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

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

class memoryview(object)

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

min(iterable, *, key=None)

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

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

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

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

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

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

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

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

next(iterator)

next(iterator, default)

Получает следующий элемент из итератора, вызывая его метод __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 — это объект, подобный пути, задающий имя файла (абсолютное или относительное к текущему рабочему каталогу), который нужно открыть, либо целочисленный файловый дескриптор файла, для которого нужно создать оболочку. (Если указан файловый дескриптор, он закрывается при закрытии возвращённого объекта ввода-вывода, если только для 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 без декодирования. В текстовом режиме (по умолчанию или если в аргументе mode указано 't') содержимое файла возвращается в виде объектов 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', преобразование не выполняется. При любом другом допустимом значении все записываемые символы '\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)

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

pow(base, exp, mod=None)

Возвращает 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.

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

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

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

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

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

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

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

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

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

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

repr(object)

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

Для этого класса задано пользовательское представление, которое можно вычислить:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(seq)

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

round(number, ndigits=None)

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

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

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

Примечание

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

class set

class set(iterable)

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

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

setattr(object, name, value)

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

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

Примечание

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

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')

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

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

sum(iterable, /, start=0)

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

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

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

class super

class super(type, object_or_type=None)

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

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

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

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

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

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

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

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

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

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

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

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

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

class tuple

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

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

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

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

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

vars()

vars(object)

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

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

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

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

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() возвращает итератор одноэлементных кортежей. Если аргументы не переданы, возвращается пустой итератор.

Советы и рекомендации:

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

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

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

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

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

Сноски