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

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

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

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

aiter(async_iterable)

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

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

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

all(iterable)

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

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

awaitable anext(async_iterator)

awaitable anext(async_iterator, default)

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

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

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

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

any(iterable)

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

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

ascii(object): Как и repr(), возвращает строку, содержащую удобочитаемое представление объекта, но экранирует не-ASCII-символы в строке, возвращаемой repr(), используя escapes \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(object=False, /): Возвращает логическое значение, т. е. одно из True или False. Аргумент преобразуется с помощью стандартной процедуры проверки истинности. Если аргумент ложный или опущен, возвращается False; в противном случае возвращается True. Класс bool является подклассом int (см. Числовые типы — int, float, complex). Его нельзя подклассировать дальше. Его единственными экземплярами являются False и True (см. Булевый тип - bool).

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

breakpoint(*args, **kws)

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

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

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

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

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

END_OF_DOCUMENT_MARKER

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

класс bytearray(source, encoding)

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

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

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

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

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

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

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

класс bytes(source, encoding)

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

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

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

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

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

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

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

chr(i)

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

Допустимый диапазон аргумента — от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе). ValueError будет вызван, если i выходит за этот диапазон.

@classmethod

Преобразует метод в метод класса.

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

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

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

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

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

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

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

Устарело начиная с версии 3.11, удалено в версии 3.13: Методы класса больше не могут оборачивать другие дескрипторы, такие как 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 это оно — флаги (функции будущих версий и опции компилятора) в окружающем коде игнорируются.

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

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

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

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

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

Примечание

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

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

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

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

Изменено в версии 3.5: Ранее, TypeError генерировался при встрече нулевых байтов в source.

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

class complex(number=0, /)

class complex(string, /)

class complex(real=0, imag=0)

Преобразует строку или число в комплексное число, или создает комплексное число из действительной и мнимой частей.

Примеры:

>>> complex('+1.23')
(1.23+0j)
>>> complex('-4.5j')
-4.5j
>>> complex('-1.23+4.5j')
(-1.23+4.5j)
>>> complex('\t( -1.23+4.5J )\n')
(-1.23+4.5j)
>>> complex('-Infinity+NaNj')
(-inf+nanj)
>>> complex(1.23)
(1.23+0j)
>>> complex(imag=-4.5)
-4.5j
>>> complex(-1.23, 4.5)
(-1.23+4.5j)

Если аргумент — строка, она должна содержать либо действительную часть (в формате, аналогичном float()), либо мнимую часть (в том же формате, но с 'j' или 'J' суффиксом), или и действительную, и мнимую части (знак мнимой части в этом случае обязателен). Строка может быть необязательно окружена пробелами и круглыми скобками '(' и ')', которые игнорируются. Строка не должна содержать пробелов между '+', '-', 'j' или 'J' суффиксом и десятичным числом. Например, complex('1+2j') допустимо, но complex('1 + 2j') генерирует ValueError. Более точно, вход должен соответствовать правилу complexvalue в следующей грамматике, после удаления скобок и начальных и конечных пробелов:

complexvalue ::=  floatvalue |
                  floatvalue ("j" | "J") |
                  floatvalue sign absfloatvalue ("j" | "J")

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

Если указаны два аргумента или используются ключевые аргументы, каждый аргумент может быть любого числового типа (включая комплексный). Если оба аргумента — действительные числа, возвращается комплексное число с действительной частью real и мнимой частью imag. Если оба аргумента — комплексные числа, возвращается комплексное число с действительной частью real.real-imag.imag и мнимой частью real.imag+imag.real. Если один из аргументов — действительное число, в вышеуказанных выражениях используется только его действительная часть.

Если все аргументы опущены, возвращается 0j.

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

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir()

dir(object)

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

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

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

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

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

Результирующий список отсортирован по алфавиту. Например:

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

Примечание

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

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

enumerate(iterable, start=0)

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

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

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

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

eval(source, /, globals=None, locals=None)

Параметры:

source (str | объект кода) – Выражение на Python.
globals (dict | None) – Глобальное пространство имён (по умолчанию: None).
locals (отображение | None) – Локальное пространство имён (по умолчанию: None).

Возвращает:

Результат вычисленного выражения.

Возбуждает:

Синтаксические ошибки сообщаются как исключения.

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

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

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

Пример:

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

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

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

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

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

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

Изменено в версии 3.13: Аргументы globals и locals теперь могут передаваться как ключевые слова.

Изменено в версии 3.13: Семантика локального пространства имён по умолчанию была скорректирована, как описано для встроенной функции locals().

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

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

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

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

Примечание

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

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

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

Примечание

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

Примечание

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

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

Изменено в версии 3.13: Аргументы globals и locals теперь могут передаваться как ключевые слова.

filter(function, iterable)

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

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

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

class float(number=0.0, /)

class float(string, /)

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

Примеры:

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

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

sign          ::=  "+" | "-"
infinity      ::=  "Infinity" | "inf"
nan           ::=  "nan"
digit         ::=  <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart     ::=  digit (["_"] digit)*
number        ::=  [digitpart] "." digitpart | digitpart ["."]
exponent      ::=  ("e" | "E") [sign] digitpart
floatnumber   ::=  number [exponent]
absfloatvalue ::=  floatnumber | infinity | nan
floatvalue    ::=  [sign] absfloatvalue

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

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

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

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

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

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

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

Изменено в версии 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__() значения. Исключение TypeError генерируется, если поиск метода достигает object, а format_spec не пустая строка, или если format_spec или возвращаемое значение не являются строками.

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

class frozenset(iterable=set())

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

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

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

Примечание

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

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

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

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

Примечание

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

help()

help(request)

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

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

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

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

END_OF_DOCUMENT_MARKER

hex(x)

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

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

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

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

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

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

Примечание

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

id(object)

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

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

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

input()

input(prompt)

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

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

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

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

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

class int(number=0, /)

class int(string, /, base=10)

Возвращает целое число, созданное из числа или строки, или возвращает 0 при отсутствии аргументов.

Примеры:

>>> int(123.45)
123
>>> int('123')
123
>>> int('   -12_345\n')
-12345
>>> int('FACE', 16)
64206
>>> int('0xface', 0)
64206
>>> int('01110011', base=2)
115

Если аргумент определяет __int__(), то int(x) возвращает x.__int__(). Если аргумент определяет __index__(), он возвращает x.__index__(). Если аргумент определяет __trunc__(), он возвращает x.__trunc__(). Для чисел с плавающей точкой это обрезание к нулю.

Если аргумент не является числом или если задан base, то он должен быть строкой, экземпляром 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: Первый параметр теперь только позиционный.

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

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

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

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

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

END_OF_DOCUMENT_MARKER

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

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

iter(object)

iter(object, sentinel)

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

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

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

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

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

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

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

locals()

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

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

В пространстве класса она возвращает пространство имен, которое будет передано конструктору метакласса.

При использовании exec() или eval() с отдельными аргументами local и global, она возвращает локальное пространство имен, переданное в вызов функции.

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

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

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

Вызов locals() в рамках генераторного выражения эквивалентен вызову его в вложенной функции-генераторе.

Изменено в версии 3.12: Поведение locals() в генераторе было обновлено, как описано в PEP 709.

Изменено в версии 3.13: В соответствии с PEP 667, семантика изменения объектов отображения, возвращённых этой функцией, теперь определена. Поведение в оптимизированных пространствах имен теперь такое, как описано выше. Помимо того, что оно определено, поведение в других пространствах имен остаётся неизменным по сравнению с предыдущими версиями.

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

max(iterable, *, key=None)

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

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

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

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

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

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

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

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

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

min(iterable, *, key=None)

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

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

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

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

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

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

Изменено в версии 3.4: Добавлен ключевой параметр default.

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

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

class object: Это базовый класс всех других классов. Он содержит методы, общие для всех экземпляров классов 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. См. Чтение и запись файлов для получения дополнительных примеров использования этой функции.

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pow(base, exp, mod=None)

Возвращает основание в степени показатель; если модуль присутствует, возвращает основание в степени показатель по модулю модуль (вычисляется более эффективно, чем 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 или float с целым показателем, возвращается значение типа float. Например, pow(-9, 2.0) возвращает 81.0.

Для операндов 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)

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

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

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

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

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

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

@getter

@setter

@deleter

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

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

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

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

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

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

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

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

__name__: Атрибут, хранящий имя свойства. Имя свойства можно изменить во время выполнения.

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

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

repr(object)

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

Этот класс имеет настраиваемое представление, которое может быть вычислено:

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

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

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

round(number, ndigits=None)

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

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

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

Примечание

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

class set

class set(iterable)

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

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

setattr(object, name, value)

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

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

Примечание

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

class slice(stop)

класс slice(start, stop, step=None)

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

start

stop

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

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

Изменено в версии 3.12: Объекты слайсов теперь хешируемые (при условии, что start, stop, и step хешируемые).

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

Примеры сортировки и краткое руководство по сортировке см. в разделе Методы сортировки.

@staticmethod

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

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

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

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

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

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

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

класс str(object='')

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

Изменено в версии 3.12: Суммирование чисел с плавающей точкой переключено на алгоритм, обеспечивающий более высокую точность и лучшую коммутативность на большинстве сборок.

END_OF_DOCUMENT_MARKER

class super

класс super(тип, объект_или_тип=None)

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

объект_или_тип определяет порядок разрешения методов для поиска. Поиск начинается с класса, расположенного сразу после тип.

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

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

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

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

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

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

class type(object)

класс type(имя, базы, словарь, **kwds)

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

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

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

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

См. также:

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

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

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

vars()

vars(объект)

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

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

Без аргумента, vars() работает как locals().

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

Изменено в версии 3.13: Результат вызова этой функции без аргумента был обновлён, как описано для встроенной функции locals().

END_OF_DOCUMENT_MARKER ```

zip(*iterables, strict=False)

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

Пример:

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

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