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

Интерпретатор 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 экранирование. Это генерирует строку, похожую на ту, что возвращается repr() в Python 2.

bin(x)

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

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

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

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

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

class bool([x])

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

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

breakpoint(*args, **kws)

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

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

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 в шестнадцатеричной системе). Если i находится за пределами этого диапазона, будет поднято исключение ValueError.

@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 управляют тем, как заявления о будущем влияют на компиляцию source. Если ни один из них не указан (или оба равны нулю), код компилируется с теми будущими заявлениями, которые действуют в коде, вызывающем compile(). Если аргумент flags указан, а dont_inherit нет (или равен нулю), то будущие операторы, указанные в аргументе flags, используются дополнительно к тем, которые были бы использованы в любом случае. Если dont_inherit — ненулевое целое число, то аргумент flags это оно — будущие операторы, действующие вокруг вызова compile, игнорируются.

Будущие операторы задаются битами, которые можно побитово объединять OR, чтобы указать несколько операторов. Поле битов, необходимое для указания данного функционального объекта, можно найти как атрибут 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: Ранее при обнаружении нулевых байтов в source генерировалось исключение TypeError.

class complex([real[, imag]])

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

Примечание

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

Тип комплексного числа описан в Числовые типы — 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[, locals]])

Аргументы — строка и необязательные значения globals и locals. Если задано, 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: Разрешено группирование цифр с помощью символов подчеркивания, как в литералах кода.

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

format(value[, format_spec])

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

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])

Возвращает значение именованного атрибута объекта объект. имя должно быть строкой. Если строка является именем атрибута объекта, результат — значение этого атрибута. Например, 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])

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

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

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

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

hex(x)

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

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

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

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

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

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

Примечание

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

id(object)

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

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

input([prompt])

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

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

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

class int([x])

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: Разрешено группировать цифры с помощью символов нижнего подчёркивания, как и в литералах кода.

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

isinstance(object, classinfo)

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

issubclass(class, classinfo)

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

iter(object[, sentinel])

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

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

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

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

len(s)

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

class list([iterable])

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

locals()

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

Примечание

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

map(function, iterable, ...)

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

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

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

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

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

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

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

Введено в версии 3.4: Необязательный аргумент default только для ключевых слов.

class 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])

Извлекает следующий элемент из итератора, вызывая его метод __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.

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

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

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

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

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

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

Примечание

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

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

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

кодировка — это имя кодировки, используемой для декодирования или кодирования файла. Это должно использоваться только в текстовом режиме. Кодировка по умолчанию зависит от платформы (что возвращает 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 с (файл, флаги). 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, будет удалено в версии 3.9: Режим '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 вызовет метод получения, c.x = value — метод установки, а del c.x — метод удаления.

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

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

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

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

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

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

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

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

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

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

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

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

class range(stop)

class range(start, stop[, step])

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

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

Примечание

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

class set([iterable])

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

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

setattr(object, name, value)

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

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() гарантирует стабильность. Сортировка стабильна, если она гарантирует, что не будет изменять относительный порядок элементов, которые сравниваются как равные — это полезно для сортировки по нескольким проходам (например, сначала по отделу, а затем по разряду зарплаты).

Примеры сортировки и краткий учебник по сортировке см. в Руководство по сортировке.

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

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

Если второй аргумент опущен, возвращаемый объект 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() реализован как часть процесса связывания для явных точечных поисков атрибутов, таких как super().__getitem__(name). Для этого он реализует собственный метод __getattribute__() для поиска классов в предсказуемом порядке, поддерживающем кооперативное множественное наследование. Соответственно, super() не определено для неявных поисков с помощью операторов или инструкций, таких как super()[name].

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

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

class tuple([iterable])

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

class type(object)

class type(name, bases, dict)

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