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

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

abs(x)

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

all(iterable)

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

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

any(iterable)

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

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

ascii(object)

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

bin(x)

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

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

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

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

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

class bool([x])

Возвращает булево значение, т.е. одно из True или False. x преобразуется с использованием стандартной процедуры проверки истинности. Если 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() автоматически вызовет её, позволяя вам зайти в отладчик по вашему выбору.

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

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

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

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

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

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

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

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

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

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

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

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

См. также Бинарные типы последовательностей — bytes, 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().

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[, imag]])

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

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

Примечание

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

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

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

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

delattr(object, name)

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])

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

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

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

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

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

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

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

Примечание

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

divmod(a, b)

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

enumerate(iterable, start=0)

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

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

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

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

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

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

Аргумент expression парсится и оценивается как выражение Python (точнее, список условий) с использованием словарей globals и locals в качестве глобального и локального пространства имён. Если словарь globals присутствует и не содержит значения для ключа __builtins__, ссылка на словарь встроенного модуля builtins вставляется под этим ключом перед парсингом expression. Это означает, что expression обычно имеет полный доступ к стандартному модулю 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[, locals]])

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

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

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

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

Примечание

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

Примечание

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

filter(function, iterable)

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

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

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

class float([x])

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

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

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

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

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

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

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

Примечание

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

globals()

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

hasattr(object, name)

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

hash(object)

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

Примечание

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

help([object])

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

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

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

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

hex(x)

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

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

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

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

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

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

Примечание

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

id(object)

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

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

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

input([prompt])

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

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 состоит из цифр от 0 до base-1, причём a до z (или A до Z) имеют значения от 10 до 35. По умолчанию base равен 10. Допустимые значения 0 и от 2 до 36. Литералы в системах счисления 2, 8 и 16 могут быть необязательно предваряемы 0b/0B, 0o/0O, или 0x/0X, как и целые литералы в коде. База 0 означает интерпретацию точно как литерал кода, поэтому фактическая база равна 2, 8, 10 или 16, и int('010', 0) некорректно, в то время как int('010') и int('010', 8) корректны.

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

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

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

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

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

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

isinstance(object, classinfo)

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

issubclass(class, classinfo)

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

iter(object[, sentinel])

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

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

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

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

len(s)

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

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

class list([iterable])

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

locals()

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

Примечание

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

map(function, iterable, ...)

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

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

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

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

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

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

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

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

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

class memoryview(object)

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

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

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

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

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

Существуют два необязательных ключевых аргумента. Аргумент 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[, 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.)

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

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

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

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

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

Примечание

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

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

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

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

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

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

newline управляет тем, как работает режим универсальных переводов строк (применяется только к текстовому режиму). Он может быть None, '\r', '\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 с (файл, флаги). 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.4, будет удалено в версии 3.10: Режим 'U'.

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

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

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

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

ord(c)

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

pow(base, exp[, mod])

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

Если c является экземпляром C, c.x вызовет геттер, 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, применимые как декораторы, которые создают копию свойства с соответствующей функцией доступа, установленной на декорированную функцию. Это лучше всего объясняется с помощью примера:

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

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

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

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

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

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

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

class range(stop)

class range(start, stop[, step])

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

repr(object)

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

reversed(seq)

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

round(number[, ndigits])

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

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

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

Примечание

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

class set([iterable])

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

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

setattr(object, name, value)

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

Примечание

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

class slice(stop)

class slice(start, stop[, step])

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

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

Возвращает новый отсортированный список из элементов в 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, ...): ...

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

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

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

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

class C:
    builtin_open = staticmethod(open)

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

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 может быть указан как ключевой аргумент.

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

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

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

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

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

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

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

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

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

class C(B):
    def method(self, arg):
        super().method(arg)    # 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([iterable])

Вместо функции tuple фактически является неизменяемым типом последовательности, как описано в Кортежи и Типы последовательностей — список, кортеж, диапазон.

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([object])

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

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

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

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

zip(*iterables)

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

Возвращает итератор кортежей, где i-й кортеж содержит i-й элемент из каждой из последовательностей или итерируемых объектов-аргументов. Итератор останавливается, когда самый короткий входной итерируемый объект исчерпан. С одним итерируемым аргументом он возвращает итератор 1-кортежей. Без аргументов он возвращает пустой итератор. Эквивалентно:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

1

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