2. Встроенные функции¶Built-in Functions

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

		Встроенные функции
`abs()`	`dict()`	`help()`	`min()`	`setattr()`
`all()`	`dir()`	`hex()`	`next()`	`slice()`
`any()`	`divmod()`	`id()`	`object()`	`sorted()`
`ascii()`	`enumerate()`	`input()`	`oct()`	`staticmethod()`
`bin()`	`eval()`	`int()`	`open()`	`str()`
`bool()`	`exec()`	`isinstance()`	`ord()`	`sum()`
`bytearray()`	`filter()`	`issubclass()`	`pow()`	`super()`
`bytes()`	`float()`	`iter()`	`print()`	`tuple()`
`callable()`	`format()`	`len()`	`property()`	`type()`
`chr()`	`frozenset()`	`list()`	`range()`	`vars()`
`classmethod()`	`getattr()`	`locals()`	`repr()`	`zip()`
`compile()`	`globals()`	`map()`	`reversed()`	`__import__()`
`complex()`	`hasattr()`	`max()`	`round()`
`delattr()`	`hash()`	`memoryview()`	`set()`

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

all(iterable)¶

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

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

any(iterable)¶

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

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

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

bin(x)¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

chr(i)¶

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

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

@classmethod¶

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

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

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

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

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

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

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

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 задаются битами, которые можно объединять побитовым ИЛИ для указания нескольких операторов. Битовое поле, необходимое для указания конкретной возможности, можно найти как атрибут compiler_flag в экземпляре _Feature в модуле __future__.

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

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

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

Примечание

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

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

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

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

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

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()   # показать имена в пространстве имён модуля
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct 
['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. Если они указаны, globals должен быть словарём. Если указаны, locals может быть любым отображением (mapping).

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

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

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

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

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

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

Значение 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, опционально с элементами, взятыми из итерируемого объекта. frozenset – это встроенный класс. См. frozenset и Типы множеств – set, frozenset для документации об этом классе.

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

getattr(object, name[, default])¶: Возвращает значение именованного атрибута объекта object. name должен быть строкой. Если эта строка является именем одного из атрибутов объекта, результатом будет значение этого атрибута. Например, getattr(x, 'foobar') эквивалентно x.foobar. Если именованный атрибут не существует, возвращается значение по умолчанию, если оно предоставлено, в противном случае возбуждается 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 присутствует, он выводится в стандартный вывод без символа новой строки. Затем функция читает строку из ввода, преобразует её в строку (удаляя конечный символ новой строки) и возвращает её. Когда достигнут конец файла, возбуждается 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. При необходимости литерал может предваряться + или - (без пробела) и быть окружен пробелами. Литерал в системе счисления n состоит из цифр от 0 до n-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)¶: Возвращает истину, если аргумент object является экземпляром аргумента classinfo, или его (прямого, косвенного или виртуального) подкласса. Если object не является объектом указанного типа, функция всегда возвращает ложь. Если classinfo является кортежем объектов типа (или рекурсивно других таких кортежей), возвращает истину, если object является экземпляром любого из типов. Если classinfo не является типом, кортежем типов или таких кортежей, возбуждается исключение TypeError.

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

iter(object[, sentinel])¶

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

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

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

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

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

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

Новое в версии 3.4: Аргумент default, указываемый только по ключевому слову.

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

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

Примечание

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

oct(x)¶

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

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

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

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

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

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

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

file – это path-like object, задающий путь (абсолютный или относительный текущего рабочего каталога) к открываемому файлу или целочисленный файловый дескриптор оборачиваемого файла. (Если передан файловый дескриптор, он закрывается при закрытии возвращаемого объекта I/O, если только 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 Private Use Area в диапазоне от U+DC80 до U+DCFF. Затем эти частные кодовые точки будут преобразованы обратно в те же байты при использовании обработчика ошибок surrogateescape при записи данных. Это полезно для обработки файлов с неизвестной кодировкой.
'xmlcharrefreplace' поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей XML-ссылкой на символ &#nnn;.
'backslashreplace' заменяет повреждённые данные escape-последовательностями 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)  # не допустить утечки файлового дескриптора

Тип файлового объекта, возвращаемого функцией 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)¶: Принимает строку, представляющую один символ Unicode, и возвращает целое число – кодовую точку Unicode этого символа. Например, 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)¶

Выводит 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)¶

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

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 будет строкой документации атрибута property. В противном случае property скопирует строку документации fget (если она существует). Это позволяет легко создавать свойства только для чтения, используя property() в качестве декоратора:

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

    @property
    def voltage(self):
        """Получить текущее напряжение."""
        return self._voltage

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

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

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

    @property
    def x(self):
        """Я – свойство 'x'."""
        return self._x

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

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

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

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

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

range(stop)
range(start, stop[, step]): range – не функция, а неизменяемый тип последовательности, как описано в Ranges и Sequence Types – list, tuple, range.

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

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

round(number[, ndigits])¶

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

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

Для произвольного объекта Python number функция round делегирует выполнение number.__round__.

Примечание

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

class set([iterable])

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

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

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

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

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

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

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

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

Примеры сортировки и краткое руководство см. в Sorting 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-версию объекта. Подробнее см. str().

str – это встроенный строковый класс. Общую информацию о строках см. в Text Sequence Type – str.

sum(iterable[, start])¶

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

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

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

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

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

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

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

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

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

class C(B):
    def method(self, arg):
        super().method(arg)    # Делает то же самое, что и:
                               # super(C, self).method(arg)

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

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

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

tuple([iterable]): tuple на самом деле не функция, а неизменяемый тип последовательности, как описано в Кортежи и Типы последовательностей – list, tuple, range.

class type(object)¶

class type(name, bases, dict)

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

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

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

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

См. также Type Objects.

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

vars([object])¶

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

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

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

zip(*iterables)¶

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

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

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.