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

class dict(**kwargs)

class dict(mapping, /, **kwargs)

class dict(iterable, /, **kwargs)

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

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

dir()

dir(object, /)

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

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

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

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

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

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

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

Примечание

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

divmod(a, b, /)

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

enumerate(iterable, start=0)

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

Примечание

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

Примечание

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

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

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

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

filter(function, iterable, /)

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

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

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

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, возникает исключение OverflowError.

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

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

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

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

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

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

format(value, format_spec='', /)

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

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

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

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

class frozenset(iterable=(), /)

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

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

getattr(object, name, /)

getattr(object, name, default, /)

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

Примечание

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

globals()

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

hasattr(object, name, /)

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

hash(object, /)

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

Примечание

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

help()

help(request)

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

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

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

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

hex(integer, /)

Преобразует целое число в строку в нижнем регистре с шестнадцатеричным представлением и префиксом «0x». Если integer не является объектом 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().

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

Примечание

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

id(object, /)

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

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

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

input()

input(prompt, /)

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

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

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

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

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

class int(number=0, /)

класс 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. Строки в двоичной, восьмеричной и шестнадцатеричной системах счисления могут иметь префиксы 0b/0B, 0o/0O или 0x/0X, как и целочисленные литералы в коде. При основании 0 строка интерпретируется подобно целочисленному литералу в коде: фактическое основание — 2, 8, 10 или 16 — определяется префиксом. При основании 0 также запрещены начальные нули: int('010', 0) недопустимо, тогда как int('010') и int('010', 8) допустимы.

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

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

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

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

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

Изменено в версии 3.11: Использование __trunc__() объявлено устаревшим.

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

isinstance(object, classinfo, /)

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

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

issubclass(class, classinfo, /)

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

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

iter(iterable, /)

iter(callable, sentinel, /)

Возвращает объект итератора. Первый аргумент интерпретируется совершенно по-разному в зависимости от наличия второго аргумента. Если второй аргумент отсутствует, единственный аргумент должен быть объектом коллекции, который поддерживает протокол итерируемого объекта (метод __iter__()) либо протокол последовательности (метод __getitem__() с целочисленными аргументами, начиная с 0). Если объект не поддерживает ни один из этих протоколов, вызывается исключение TypeError. Если задан второй аргумент, sentinel, первый аргумент должен быть вызываемым объектом. Созданный в этом случае итератор при каждом вызове метода __next__() вызывает callable без аргументов; если возвращённое значение равно 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(object, /)

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

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

класс list(iterable=(), /)

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

locals()

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

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

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

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

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

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

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

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

Изменено в версии 3.12: Поведение locals() во включениях изменено, как описано в PEP 709.

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

map(function, iterable, *iterables)

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

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

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

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

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

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

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

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

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

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

класс 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(integer, /)

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

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

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

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

Дополнительные сведения см. также в описании format().

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

• 'strict' — вызывает исключение ValueError при ошибке кодирования. Значение None по умолчанию действует так же.
• 'ignore' — игнорирует ошибки. Обратите внимание: игнорирование ошибок кодирования может привести к потере данных.
• 'replace' — вставляет маркер замены (например, '?') в место некорректных данных.
• 'surrogateescape' — представляет каждый некорректный байт в виде младшего суррогатного кодового элемента в диапазоне от U+DC80 до U+DCFF. При записи данных с обработчиком ошибок surrogateescape эти суррогатные кодовые элементы преобразуются обратно в те же байты. Это полезно для обработки файлов с неизвестной кодировкой.
• 'xmlcharrefreplace' поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей символьной ссылкой XML &#nnn;.
• 'backslashreplace' заменяет некорректные данные экранированными обратной косой чертой последовательностями Python.
• 'namereplace' (также поддерживается только при записи) заменяет неподдерживаемые символы последовательностями escape-кодов \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(character, /)

Возвращает порядковое значение символа.

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

Если аргумент — объект bytes или bytearray длины 1, возвращает значение единственного байта. Например, ord(b'a') возвращает целое число 97.

pow(base, exp, mod=None)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

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

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

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

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

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

@getter

@setter

@deleter

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

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

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

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

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

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

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

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

__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(object, /)

Возвращает обратный итератор. Аргументом должен быть объект, у которого есть метод __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(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() и т. д.

Примечание

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

class slice(stop, /)

class slice(start, stop, step=None, /)

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

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

start

stop

step

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

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

@staticmethod

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

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

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

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

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

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

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

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

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

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

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

class str(object)

class str(object, encoding, errors='strict')

class str(object, *, errors)

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

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

sum(iterable, /, start=0)

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

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

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

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

class super

class super(type, object_or_type=None, /)

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

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

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

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

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

При непосредственном вызове внутри обычного метода класса оба аргумента можно опустить («super() без аргументов»). В этом случае type будет охватывающим классом, а obj — первым аргументом непосредственно охватывающей функции (обычно 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().

class tuple(iterable=(), /)

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

class type(object, /)

class type(name, bases, dict, /, **kwargs)

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

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

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

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

См. также:

• Документация по атрибутам и методам классов.
• Объекты типов

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

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

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

vars()

vars(object, /)

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

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

Без аргумента vars() действует как locals().

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

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

zip(*iterables, strict=False)

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

Пример:

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

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

Можно также думать о zip() как об операции, преобразующей строки в столбцы, а столбцы — в строки. Это похоже на транспонирование матрицы.

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

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

• По умолчанию zip() останавливается, когда исчерпан самый короткий итерируемый объект. Остальные элементы более длинных объектов игнорируются, а результат обрезается до длины самого короткого объекта:

  >>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
  [(0, 'fee'), (1, 'fi'), (2, 'fo')]
  

• zip() часто используется в случаях, когда предполагается, что итерируемые объекты имеют одинаковую длину. В таких случаях рекомендуется использовать параметр strict=True. Результат будет таким же, как у обычного zip():

  >>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
  [('a', 1), ('b', 2), ('c', 3)]
  

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

  >>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):
  ...     print(item)
  ...
  (0, 'fee')
  (1, 'fi')
  (2, 'fo')
  Traceback (most recent call last):
    ...
  ValueError: zip() argument 2 is longer than argument 1
  

  Без аргумента strict=True любая ошибка, приводящая к разной длине итерируемых объектов, останется незамеченной и может проявиться как трудно обнаруживаемая ошибка в другой части программы.

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

Инструкция import spam.ham приводит к следующему вызову:

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

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

С другой стороны, инструкция from spam.ham import eggs, sausage as saus приводит к следующему:

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

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

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

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

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

Сноски