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

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

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

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

all(iterable)¶

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

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

any(iterable)¶

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

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

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

bin(x)¶

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

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

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

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

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

class bool([x])¶: Возвращает логическое значение, например True или False. x конвертируется с использованием стандартной процедуры проверки истинности. Если x ложно или пропущено, возвращается False; в противном случае возвращается 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 можно использовать для инициализации массива несколькими способами:

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

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

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

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

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

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

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

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

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 по основанию 16). Будет вызвано ValueError, если i находится вне этого диапазона.

@classmethod¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Функция вызывает SyntaxError, если скомпилированный источник ошибочен и ValueError, если источник содержит null байты.

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

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

Примечание

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

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

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

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

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

Добавлено в версии 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT теперь можно передавать во флагах, чтобы включить высокоуровневую поддержку 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: Возвращается к __index__(), если __complex__() и __float__() не определены.

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

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

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

>>> import struct
>>> dir()   # отображение имён в пространстве имён модулей  # doctest: +SKIP
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct # doctest: +SKIP
['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)¶

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

>>> seasons = ['Весна', 'Лето', 'Осень', 'Зима']
>>> list(enumerate(seasons))
[(0, 'Весна'), (1, 'Лето'), (2, 'Осень'), (3, 'Зима')]
>>> list(enumerate(seasons, start=1))
[(1, 'Весна'), (2, 'Лето'), (3, 'Осень'), (4, 'Зима')]

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

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

eval(expression[, globals[, locals]])¶

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

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

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

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

Обратите внимание, что 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])¶

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

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

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

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

class frozenset([iterable])

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

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

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

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

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

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

Примечание

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

help([object])¶

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

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

Функция добавляется во встроенное пространство имён модулем 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. У литералов Base-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 теперь является только позиционным параметром.

Изменено в версии 3.8: Возвращается к __index__(), если __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, ...)¶: Возвращает итератор, который применяет 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.

Изменено в версии 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])¶: Получить следующий элемент из iterator, вызвав его метод __next__(). Если задано default и итератор исчерпан, то возвращается данное значение, в противном случае вызывается StopIteration.

class object¶: Возвращает новый безликий объект. object — родитель для всех классов. В нём есть методы, общие для всех экземпляров классов Python. Функция не принимает никаких аргументов.

Примечание

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

oct(x)¶

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

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

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

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

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

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

Открывает file и возвращает соответствующий файловый объект. Если файл не открывается, вызывается 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' будет представлять любые неправильные байты как кодовые точки в области частного использования Юникод в диапазоне от U+DC80 до U+DCFF. Данные частные кодовые точки затем будут преобразованы обратно в те же байты, когда обработчик ошибок surrogateescape используется при записи данных. Это полезно для обработки файлов в неизвестной кодировке.
'xmlcharrefreplace' поддерживается только при записи в файл. Символы, не поддерживаемые кодировкой, заменяются соответствующей ссылкой на символы XML &#nnn;.
'backslashreplace' заменяет искаженные данные escape- последовательностями Python с обратной косой чертой.
'namereplace' (также поддерживается только при записи) заменяет неподдерживаемые символы управляющими последовательностями \N{...}.

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

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

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

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

Вновь созданный файл — не наследуемый.

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

>>> import os
>>> dir_fd = os.open('somedir', os.O_RDONLY)
>>> def opener(path, flags):
...     return os.open(path, flags, dir_fd=dir_fd)
...
>>> with open('spamspam.txt', 'w', opener=opener) as f:
...     print('Это будет записано в somedir/spamspam.txt', file=f)
...
>>> os.close(dir_fd)  # не допускайте утечки файлового дескриптора

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

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

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

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

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

Добавлен параметр opener.

Добавлен режим 'x'.

Раньше вызывался IOError, теперь это псевдоним OSError.

Теперь вызывается FileExistsError, если файл, открытый в режиме монопольного создания ('x'), уже существует.

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

Теперь файл не наследуется.

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

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

pow(base, exp[, mod])¶

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "Я 'x' свойство.")

Если 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):
        """Получить текущее напряжение."""
        return self._voltage

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

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

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

    @property
    def x(self):
        """Я 'х' свойство."""
        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])¶

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

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

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

Примечание

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

Примеры сортировки и краткое руководство по сортировке см. в HOWTO по сортировке.

@staticmethod¶

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

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

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

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

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

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

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

class C:
    builtin_open = staticmethod(open)

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

class str(object='')

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

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

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

sum(iterable, /, start=0)¶

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

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

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

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

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

object-or-type определяет порядок разрешения метода для поиска. Поиск начинается с класса сразу после type.

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

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

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

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

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

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

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

Помимо поиска методов, super() также работает для поиска атрибутов. Один из возможных вариантов использования для него — вызов дескрипторов в родительском или родственном классе.

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

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

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

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

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

Изменено в версии 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). Это повторяет итератор same 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.