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

У 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 имеют значение true (или если итабль пуст). Эквивалентно

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

any(iterable)

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

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

ascii(object)

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

bin(x)

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

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

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

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

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

class bool([x])

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

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

breakpoint(*args, **kws)

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

Raises an auditing event builtins.breakpoint with argument breakpointhook.

Добавлено в версии 3.7.

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

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

Дополнительный параметр source может быть используемый, чтобы инициализировать множество в нескольких различных ways:

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

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

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

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

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

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

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

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

callable(object)

Возвращает True если аргумент object выглядит вызываемым, False если not. Если это возвращает 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 в базе 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 установлен, объект возвращает code имеет набор CO_COROUTINE в co_code и может быть в интерактивном режиме выполнен через await eval(code_object).

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

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

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

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

Примечание

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

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

Возможно разбить Python интерпретатор с достаточно большим/сложным строка, когда компилирование к AST возражает должный сложить ограничения глубины в компиляторе Python’s 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() по умолчанию ведет себя по-разному с различными типами объектов, так как пытается получить наиболее релевантную, а не полную информацию:

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

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

>>> import struct
>>> dir()   # отображение имен в пространстве имен модулей  # doctest: +SKIP
['__builtins__', '__name__', 'struct']
>>> dir(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 = ['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. Если оба словаря опущены, выражение выполняется с globals и locals в среде, где вызывается eval(). Обратите внимание, что eval() не имеет доступа к вложенные области (нелокальным) в окружении.

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

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

Эта функция может также быть используемый, чтобы выполнить произвольные объекты код (такие как созданные compile()). В этом случае передайте объект код вместо объекта строка. Если объект код скомпилирован с аргументом 'exec' в качестве аргумента mode, eval()“ s возвращает значение будет 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.

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’s) возвращено. Если аргумент будет вне диапазона плавания 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(), это означает, что параметры до разреза позиционно- единственные. Дополнительные сведения см. в разделе запись 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 используйте метод float.hex().

id(object)

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

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

Raises an auditing event builtins.id with argument id.

input([prompt])

Если аргумент prompt присутствует, он записывается в стандартный вывод без конечной новой строки. Функция тогда читает линию от входа, новообращенные это к строка (раздевающий перемещение newline), и прибыль это. При считывании 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 to 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: Допускается группирование цифр с подчеркиванием, как в literals код.

Изменено в версии 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__(); если значение возвращенныйis, равный 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])

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

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

Существует два дополнительных аргумента ключевой-only. Аргумент key задает функцию упорядочивания в один аргумент, подобную функции используемый для list.sort(). Аргумент default определяет объект к возвращает if, обеспеченное повторяемое пусто. Если повторяемое пусто, и 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)

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

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

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

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

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

Как сказано в Обзор, Python различает двоичный и текстовый I/O. Файлы, открытые в режиме двоичного счета (включая 'b' в аргументе mode) возвращает contents как bytes, возражают без любой расшифровки. В текстовом режиме (дефолт, или когда 't' включен в аргумент mode), содержание файла - возвращенныйas 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' заменяет уродливые данные последовательностями побега Python’s backslashed.
• 'namereplace' (также только поддержанный, сочиняя) заменяет неподдержанные знаки последовательностями побега \N{...}.

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

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

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

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

Созданный файл будет non-inheritable.

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

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

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

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

Raises an auditing event open with arguments file, mode, flags.

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

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

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

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

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

Deprecated since version 3.4, will be removed in version 3.9: Режим 'U'.

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

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

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

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

ord(c)

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

pow(base, exp[, mod])

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

Аргументы должны иметь числовые типы. В случае смешанных типов операндов применяются правила принуждения для бинарных арифметических операторов. Для операндов int у результата есть тот же тип как операнды (после принуждения), если второй аргумент не отрицателен; в этом случае все аргументы преобразуются в float и доставляется результат float. Например, 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, если они присутствуют, должны быть приведены в качестве ключевой аргументов.

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

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

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

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

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

Собственность возвращает атрибут.

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

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

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

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

Декоратор @property превращает метод voltage() в «getter» для атрибут только для чтения с тем же именем, и он устанавливает докстринг для 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)

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

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

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

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

Существует два типичных варианта использования 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))

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

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

vars([object])

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

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

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

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

zip(*iterables)

Создать итератор, объединяющий элементы из каждого итерабля.

Возвращает итератор кортежей, где кортеж i-th содержит элемент i-th от каждой из последовательностей аргумента или iterables. Итератор останавливается, когда самая короткая входная итерация исчерпана. С одним аргументом итератора он возвращает итератор из 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() должен только быть используемый с неравными исходными данными длины, когда вы не заботитесь о перемещении, непревзойденном значения от дольше iterables. Если эти значения важны, используйте вместо этого 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, обычно, пакет верхнего уровня (имя до первой точки) возвращен, not модуль, названный 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 - возвращенныйfrom __import__(). Из этого объекта извлекаются имена для импорта и присваиваются их соответствующим именам.

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

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

Сноски

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