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

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

abs(x)

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

all(iterable)

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

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

any(iterable)

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

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

ascii(object)

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

bin(x)

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

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

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

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

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

class bool([x])

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

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

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

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

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

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

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

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

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

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

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

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

callable(object)

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

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

chr(i)

Возвращает строку, представляющую символ, чей код Юникода равен целому числу 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() в этом разделе.

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

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

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

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

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

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

Операторы future задаются битами, которые могут быть побитово объединены OR, чтобы указать несколько операторов. Битовая маска, необходимая для указания определённой функции, может быть найдена как атрибут compiler_flag в объекте _Feature в модуле __future__.

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

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

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

Примечание

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

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

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

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

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

class complex([real[, imag]])

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

Примечание

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

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

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

delattr(object, name)

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])

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

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

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

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

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

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

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

Примечание

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

divmod(a, b)

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

enumerate(iterable, start=0)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

Примечание

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

filter(function, iterable)

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

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

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

class float([x])

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

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

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

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

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

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

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

Примеры:

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

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

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

format(value[, format_spec])

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

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

globals()

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

hasattr(object, name)

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

hash(object)

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

Примечание

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

help([object])

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

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

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

hex(x)

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

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

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

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

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

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

Примечание

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

id(object)

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

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

input([prompt])

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

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

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

class int(x=0)

class int(x, base=10)

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

Если x не является числом или если задан base, то x должен быть строкой, экземпляром bytes или bytearray, представляющим целочисленную литерал в системе счисления base. Допускается наличие префикса + или - (без пробела между ними) и пробелов вокруг литерала. Литерал в системе счисления base состоит из цифр от 0 до base-1, с a по z (или A по Z) имеющими значения от 10 до 35. Значение по умолчанию для base — 10. Разрешенные значения — 0 и от 2 до 36. Литералы в системах счисления 2, 8 и 16 могут быть необязательно префиксрованы 0b/0B, 0o/0O, или 0x/0X, как и целочисленные литералы в коде. Основание 0 означает интерпретацию точно как литерал кода, так что фактическое основание — 2, 8, 10 или 16, и int('010', 0) не является допустимым, в то время как int('010') является допустимым, а также int('010', 8).

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

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

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

isinstance(object, classinfo)

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

issubclass(class, classinfo)

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

iter(object[, sentinel])

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

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

Одно полезное применение второй формы iter() — чтение строк из файла до тех пор, пока не будет достигнута определенная строка. Следующий пример считывает файл до тех пор, пока метод readline() не вернёт пустую строку:

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

len(s)

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

class list([iterable])

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

locals()

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

Примечание

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

map(function, iterable, ...)

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

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

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

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

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

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

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

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

memoryview(obj)

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

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

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

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

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

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

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

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

next(iterator[, default])

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

class object

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

Примечание

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

oct(x)

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

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

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

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

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

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

Открыть файл и вернуть соответствующий объект файла. Если файл нельзя открыть, возникает OSError.

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

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

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

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

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

Примечание

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

buffering — это необязательное целое число, используемое для задания политики буферизации. Передайте 0, чтобы отключить буферизацию (разрешено только в двоичном режиме), 1, чтобы выбрать строчную буферизацию (используется только в текстовом режиме), и целое число > 1, чтобы указать размер в байтах буфера фиксированного размера. Если аргумент buffering не задан, политика буферизации по умолчанию работает следующим образом:

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

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

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

• 'strict' для повышения ValueError исключения, если произошла ошибка кодирования. Значение по умолчанию None имеет тот же эффект.
• 'ignore' игнорирует ошибки. Обратите внимание, что игнорирование ошибок кодирования может привести к потере данных.
• 'replace' приводит к вставке маркера замены (например, '?') там, где имеются неправильные данные.
• 'surrogateescape' представляет любые неправильные байты в виде кодовых точек в области частного использования Unicode, начиная с 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.

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

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

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

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

Устарело начиная с версии 3.4, будет удалено в версии 4.0: Режим 'U'.

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

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

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

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

ord(c)

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

pow(x, y[, z])

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

Аргументы должны иметь числовые типы. При смешанных типах операндов применяются правила приведения для бинарных арифметических операторов. Для операндов типа int, результат имеет тот же тип, что и операнды (после приведения), если второй аргумент не отрицательный; в противном случае все аргументы преобразуются в float, и результат будет float. Например, 10**2 возвращает 100, но 10**-2 возвращает 0.01. Если второй аргумент отрицательный, третий аргумент должен быть опущен. Если z присутствует, x и y должны быть целых типов, а y — неотрицательным.

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

Если c является экземпляром C, c.x вызовет getter, c.x = value вызовет setter и del c.x вызовет deleter.

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

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

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

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

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

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

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

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

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

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

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

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

range(stop)

range(start, stop[, step])

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

repr(object)

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

reversed(seq)

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

round(number[, ndigits])

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

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

Для общего 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.

class slice(stop)

class slice(start, stop[, step])

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

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

Возвращает новый отсортированный список из элементов в iterable.

Имеет два необязательных аргумента, которые должны быть указаны как именованные аргументы.

key задаёт функцию одного аргумента, используемую для извлечения ключа сравнения из каждого элемента в iterable (например, key=str.lower). Значение по умолчанию — None (элементы сравниваются напрямую).

reverse — логическое значение. Если установлено в True, элементы списка сортируются как если бы каждое сравнение было обращено.

Используйте functools.cmp_to_key() для преобразования функции старого стиля cmp в функцию key.

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

Примеры сортировки и краткий учебник по сортировке см. в Сортировка HOW TO.

@staticmethod

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

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

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

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

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

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

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

class C:
    builtin_open = staticmethod(open)

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

class str(object='')

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

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

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

sum(iterable[, start])

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

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

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

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

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

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

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

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

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

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

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

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

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

tuple([iterable])

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

class type(object)

class type(name, bases, dict)

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

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

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

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

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

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

vars([object])

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

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

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

zip(*iterables)

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

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

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечания

1

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