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

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

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

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

aiter(async_iterable)

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

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

Введено в версии 3.10.

all(iterable)

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

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

awaitable anext(async_iterator[, default])

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

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

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

Введено в версии 3.10.

any(iterable)

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

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

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

bin(x)

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

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

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

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

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

class bool([x]): Возвращает логическое значение, т. е. одно из True или False. x преобразуется с помощью стандартной проверки истинности. Если x ложно или опущено, возвращается False; в противном случае, возвращается True. Класс bool является подклассом int (см. Числовые типы — int, float, complex). Он не может быть далее унаследован. Его единственные экземпляры — False и True (см. Булевы значения).

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

breakpoint(*args, **kws)

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

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

Введено в версии 3.7.

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

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

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

Если это строка, необходимо также указать параметры encoding (и необязательно errors); 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.

END_OF_DOCUMENT_MARKER

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

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

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

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

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

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

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

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

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

END_OF_DOCUMENT_MARKER

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])

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

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

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

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

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

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

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

Примечание

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

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

enumerate(iterable, start=0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

Примечание

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

filter(function, iterable)

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

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

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

class float([x])

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

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

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

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

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

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

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

Примеры:

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

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

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

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

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

format(value[, format_spec])

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

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

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

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

class frozenset([iterable])

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

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

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

Примечание

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

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

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

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

Примечание

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

help([object])

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

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

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

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

hex(x)

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

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

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

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

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

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

Примечание

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

id(object)

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

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

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

input([prompt])

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

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

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

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

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

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

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

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

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

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

END_OF_DOCUMENT_MARKER ```

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

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

iter(object[, sentinel])

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

oct(x)

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

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

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

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

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

END_OF_DOCUMENT_MARKER ```

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Устарело начиная с версии 3.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=None, flush=False)

Выводит объекты в текстовый поток файл, разделенные 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__(). Если sys.displayhook() недоступен, эта функция вызовет RuntimeError.

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

round(number[, ndigits])

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

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

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

Примечание

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

class set([iterable])

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

END_OF_DOCUMENT_MARKER

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()). Кроме того, их можно вызывать как обычные функции (например, f()).

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

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

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

class str(object='')

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

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

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

sum(iterable, /, start=0)

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

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

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

class super([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) должно быть истинным (это полезно для classmethods).

Существует два типичных случая использования 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 на самом деле является неизменяемым типом последовательности, как описано в Кортежах и Типы последовательностей — list, tuple, range.

END_OF_DOCUMENT_MARKER

class type(object)

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

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

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

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

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

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

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

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

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

vars([object])

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

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

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

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

zip(*iterables, strict=False)

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

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

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