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

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

abs(x)

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

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() автоматически вызовет её, позволяя вам перейти в отладчик по своему выбору.

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

Новая в версии 3.7.

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

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

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

• Если это строка, вам также необходимо указать параметры encoding (и необязательно, errors); bytearray() затем преобразует строку в байты с помощью str.encode().
• Если это целое число, массив будет иметь такой размер и будет инициализирован нулевыми байтами.
• Если это объект, соответствующий интерфейсу буфера, будет использоваться только для чтения буфер объекта для инициализации массива байтов.
• Если это итерируемый объект, он должен быть итерируемым объектом целых чисел в диапазоне 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)

Возвращает строку, представляющую символ с кодом 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)

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

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

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

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

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

Необязательный аргумент flags также контролирует, разрешено ли компилируемому источнику содержать top-level await, async for и async with. Когда бит ast.PyCF_ALLOW_TOP_LEVEL_AWAIT установлен, объект возвращаемого кода имеет CO_COROUTINE в co_code, и может быть интерактивно выполнен через await eval(code_object).

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

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

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

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

Примечание

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

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

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

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

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

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

class complex([real[, imag]])

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

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

Примечание

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

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

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

Изменено в версии 3.8: При отсутствии __complex__() и __float__() используется __index__().

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(). Обратите внимание, что eval() не имеет доступа к вложенным областям имён (non-locals) в окружающем пространстве имён.

Возвращаемое значение — результат вычисленного выражения. Синтаксические ошибки сообщаются в виде исключений. Пример:

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

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

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

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

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

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

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

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

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

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

Примечание

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

Примечание

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

filter(function, iterable)

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

Обратите внимание, что 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, будет поднято исключение OverflowError.

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

Если аргумент не указан, возвращается 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 теперь является параметром только по позиции.

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

format(value[, format_spec])

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

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

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

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

class frozenset([iterable])

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

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

getattr(object, name[, default])

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

globals()

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

hasattr(object, name)

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

hash(object)

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

Примечание

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

help([object])

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

Обратите внимание, что если в списке параметров функции появляется косая черта (/), при вызове 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: Это адрес объекта в памяти.

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

input([prompt])

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

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

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

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

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

class int([x])

class int(x, base=10)

Возвращает объект целого типа, созданный из числа или строки x, или возвращает 0, если аргументы отсутствуют. Если x определяет __int__(), int(x) возвращает x.__int__(). Если x определяет __index__(), он возвращает x.__index__(). Если 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.__index__ использовался base.__int__.

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

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

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

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

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, ...)

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

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

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.

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

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. См. Чтение и запись файлов для получения дополнительных примеров использования этой функции.

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

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Изменено в версии 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(base, exp[, mod])

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

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

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

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

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

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

Изменено в версии 3.8: Поддержка ключевых аргументов.

print(*objects, sep=' ', end='\n', file=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=0)

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

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

Изменено в версии 3.8: Параметр start может быть задан как именованный аргумент.

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

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

Объект-или-тип определяет порядок разрешения методов, который нужно искать. Поиск начинается с класса, следующего за type.

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

Атрибут __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, **kwds)

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

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

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

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

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

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

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

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

vars([object])

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

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

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

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

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.