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

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

Встроенные функции
А `abs()` `aiter()` `all()` `anext()` `any()` `ascii()` В `bin()` `bool()` `breakpoint()` \|функция-bytearray\|_ \|функциональные байты\|_ C `callable()` `chr()` `classmethod()` `compile()` `complex()` D `delattr()` \|функция\|_ `dir()` `divmod()`	E `enumerate()` `eval()` `exec()` F `filter()` `float()` `format()` \|функция-замораживание\|_ G `getattr()` `globals()` Ч `hasattr()` `hash()` `help()` `hex()` Я `id()` `input()` `int()` `isinstance()` `issubclass()` `iter()`	L `len()` \|список функций\|_ `locals()` М `map()` `max()` \|функция-просмотр памяти\|_ `min()` N `next()` O `object()` `oct()` `open()` `ord()` P `pow()` `print()` `property()`	R \|функциональный диапазон\|_ `repr()` `reversed()` `round()` S \|набор функций\|_ `setattr()` `slice()` `sorted()` `staticmethod()` \|функциональный\|_ `sum()` `super()` Т \|функциональный кортеж\|_ `type()` В `vars()` Z `zip()` _ `__import__()`

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

aiter(async_iterable)¶

Возвращает asynchronous iterator вместо asynchronous iterable. Эквивалентно вызову x.__aiter__().

Примечание: В отличие от iter(), aiter() не имеет варианта с двумя аргументами.

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

all(iterable)¶

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

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

awaitable anext(async_iterator)¶

awaitable anext(async_iterator, default)

Когда ожидается, верните следующий элемент из заданного asynchronous iterator или default, если он задан, и итератор исчерпан.

Это асинхронный вариант встроенного next(), который ведет себя аналогично.

При этом вызывается __anext__() метод async_iterator, возвращающий значение awaitable. В ожидании этого возвращает следующее значение итератора. Если задано значение default, оно возвращается, если итератор исчерпан, в противном случае вызывается значение StopAsyncIteration.

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

any(iterable)¶

Возвращает True, если какой-либо элемент 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=False)¶: Возвращает логическое значение, т.е. одно из True или False. x преобразуется с использованием стандартного truth testing procedure. Если значение x равно false или опущено, то возвращается 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() автоматически вызовет ее, что позволит вам перейти к выбранному вами отладчику. Если sys.breakpointhook() недоступен, эта функция вызовет RuntimeError.

По умолчанию поведение breakpoint() можно изменить с помощью переменной окружения PYTHONBREAKPOINT. Подробности использования см. в разделе sys.breakpointhook().

Обратите внимание, что это не гарантируется, если был заменен sys.breakpointhook().

Создает auditing event builtins.breakpoint с аргументом breakpointhook.

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

class bytearray(source=b'')

class bytearray(source, encoding)

class bytearray(source, encoding, errors)

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

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

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

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

class bytes(source=b'')

class bytes(source, encoding)

class bytes(source, encoding, errors)

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

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

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

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

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

chr(i)¶

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

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

@classmethod¶

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

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

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

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

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

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

Изменено в версии 3.9: Методы класса теперь могут обертывать другие descriptors, такие как property().

Изменено в версии 3.10: Методы класса теперь наследуют атрибуты method (__module__, __name__, __qualname__, __doc__ и __annotations__) и имеют новый атрибут __wrapped__.

Изменено в версии 3.11: Методы класса больше не могут обертывать другие descriptors, такие как property().

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

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

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

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

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

Параметры компилятора и будущие инструкции задаются битами, которые могут быть побитово объединены для указания нескольких параметров. Битовое поле, необходимое для указания данного функционального объекта, можно найти как атрибут compiler_flag в экземпляре _Feature в модуле __future__. Compiler flags можно найти в ast модуль с префиксом PyCF_.

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

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

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

Создает auditing event compile с аргументами source, filename.

Примечание

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

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

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

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

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

Добавлено в версии 3.8: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT теперь можно передавать с помощью флагов, чтобы включить поддержку верхнего уровня await, async for, и async with.

class complex(real=0, imag=0)¶

class complex(string)

Возвращает комплексное число со значением 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. имя не обязательно должно быть идентификатором Python (см. setattr()).

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Создайте новый словарь. Объектом dict является класс словаря. Документацию об этом классе смотрите в разделах dict и Типы отображения — dict.

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

dir()¶

dir(object)

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

Если у объекта есть метод с именем __dir__(), этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, реализующим пользовательскую функцию __getattr__() или __getattribute__(), настраивать способ, которым dir() отображает их атрибуты.

Если объект не предоставляет __dir__(), функция делает все возможное, чтобы собрать информацию из атрибута объекта __dict__, если он определен, и из его типа object. Результирующий список не обязательно является полным и может быть неточным, если объект имеет пользовательский __getattr__().

Механизм по умолчанию dir() ведет себя по-разному с разными типами объектов, поскольку он пытается получить наиболее релевантную, а не полную информацию:

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

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

>>> import struct
>>> dir()   # show the names in the module namespace  
['__builtins__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module 
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape:
...     def __dir__(self):
...         return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'location', 'perimeter']

Примечание

Поскольку dir() предоставляется в первую очередь для удобства использования в интерактивной подсказке, он пытается предоставить скорее интересный набор имен, чем строго или последовательно определенный набор имен, и его подробное поведение может меняться в разных версиях. Например, атрибуты метакласса отсутствуют в списке результатов, если аргументом является класс.

divmod(a, b)¶: Примите два (некомплексных) числа в качестве аргументов и верните пару чисел, состоящих из их частного и остатка, при использовании целочисленного деления. При использовании смешанных типов операндов применяются правила для бинарных арифметических операторов. Для целых чисел результат будет таким же, как (a // b, a % b). Для чисел с плавающей запятой результатом будет (q, a % b), где q обычно равно math.floor(a / b), но может быть на 1 меньше. В любом случае q * b + a % b очень близко к a, если a % b не равно нулю, то оно имеет тот же знак, что и b, и 0 <= abs(a % b) < abs(b).

enumerate(iterable, start=0)¶

Возвращает объект enumerate. iterable должен быть последовательностью, iterator или каким-либо другим объектом, поддерживающим итерацию. Метод __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(iterable, start=0):
    n = start
    for elem in iterable:
        yield n, elem
        n += 1

eval(expression, globals=None, locals=None)¶

Аргументами являются строка и необязательные глобальные и локальные значения. Если указано, то globals должно быть словарем. Если указано, то locals может быть любым объектом отображения.

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

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

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

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

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

Если заданным источником является строка, то начальные и конечные пробелы и символы табуляции удаляются.

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

Создает auditing event exec с аргументом code_object.

exec(object, globals=None, locals=None, /, *, closure=None)¶

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

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

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

Аргумент closure определяет замыкание - кортеж из подвалов. Он действителен только в том случае, если object является объектом кода, содержащим свободные переменные. Длина кортежа должна точно соответствовать количеству свободных переменных, на которые ссылается объект кода.

Создает auditing event exec с аргументом code_object.

Примечание

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

Примечание

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

Изменено в версии 3.11: Добавлен параметр закрытие.

filter(function, iterable)¶

Создайте итератор из тех элементов iterable, для которых function имеет значение true. iterable может быть либо последовательностью, контейнером, поддерживающим итерацию, либо итератором. Если значение function равно None, то предполагается, что функция identity, то есть все элементы 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=0.0)¶

Возвращает число с плавающей запятой, построенное из числа или строки x.

Если аргумент является строкой, он должен содержать десятичное число, необязательно предваряемое знаком и необязательно заключенное в пробел. Необязательным знаком может быть '+' или '-'; знак '+' не влияет на получаемое значение. Аргументом также может быть строка, представляющая NaN (не число), или положительную или отрицательную бесконечность. Более точно, вводимые данные должны соответствовать правилу создания floatvalue в приведенной ниже грамматике, после удаления начальных и конечных пробельных символов:

sign        ::=  "+" | "-"
infinity    ::=  "Infinity" | "inf"
nan         ::=  "nan"
digit       ::=  <a Unicode decimal digit, i.e. characters in Unicode general category Nd>
digitpart   ::=  digit (["_"] digit)*
number      ::=  [digitpart] "." digitpart | digitpart ["."]
exponent    ::=  ("e" | "E") ["+" | "-"] digitpart
floatnumber ::=  number [exponent]
floatvalue  ::=  [sign] (floatnumber | infinity | nan)

Регистр не имеет значения, поэтому, например, «inf», «Inf», «INFINITY» и «Бесконечность» - все это приемлемые варианты написания для положительной бесконечности.

В противном случае, если аргументом является целое число или число с плавающей запятой, возвращается число с плавающей запятой с тем же значением (в пределах точности с плавающей запятой в Python). Если аргумент находится за пределами диапазона значений с плавающей запятой в Python, будет поднят OverflowError.

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

Если аргумент не задан, возвращается 0.0.

Примеры:

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

Тип float описан в разделе Числовые типы — int, float, complex.

Изменено в версии 3.6: Допускается группировка цифр с подчеркиванием, как в кодовых литералах.

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

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

format(value, format_spec='')¶

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

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

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

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

class frozenset(iterable=set())

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

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

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

Примечание

Поскольку private name mangling происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы получить его с помощью getattr().

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

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

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

Примечание

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

help()¶

help(request)

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

Обратите внимание, что если при вызове help() в списке параметров функции появляется косая черта(/), это означает, что параметры, предшествующие косой черте, являются позиционными. Для получения дополнительной информации см. the FAQ entry on positional-only parameters.

Эта функция добавляется во встроенное пространство имен модулем 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: Это адрес объекта в памяти.

Создает auditing event builtins.id с аргументом id.

input()¶

input(prompt)

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

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

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

Создает auditing event builtins.input с аргументом prompt.

Создает auditing event builtins.input/result с аргументом result.

class int(x=0)¶

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. Значения 0-9 могут быть представлены любой десятичной цифрой в кодировке Unicode. Значения от 10 до 35 могут быть представлены от a до z (или от A до Z). Значение по умолчанию равно 10. Допустимыми основаниями являются 0 и 2-36. Строки с базовыми значениями-2, -8 и -16 могут иметь необязательный префикс 0b/0B, 0o/0O, или 0x/0X, как и в случае с целыми литералами в коде. Для основания 0 строка интерпретируется аналогично integer literal in code в том смысле, что фактическое основание равно 2, 8, 10 или 16, как определено префиксом. Основание 0 также запрещает начальные нули: int('010', 0) недопустимо, в то время как int('010') и int('010', 8) допустимы.

Тип integer описан в разделе Числовые типы — int, float, complex.

Изменено в версии 3.4: Если base не является экземпляром int, а объект base имеет метод base.__index__, этот метод вызывается для получения целого числа для base. В предыдущих версиях использовалось base.__int__ вместо base.__index__.

Изменено в версии 3.6: Допускается группировка цифр с подчеркиванием, как в кодовых литералах.

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

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

Изменено в версии 3.11: Делегирование __trunc__() устарело.

Изменено в версии 3.11: int ввод строк и их представление могут быть ограничены, чтобы избежать атак типа «отказ в обслуживании». Значение ValueError возникает при превышении предела при преобразовании строки x в int или при преобразовании int в строку, превышающем предел. Смотрите документацию по integer string conversion length limitation.

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

Изменено в версии 3.10: classinfo может быть Тип соединения.

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

Изменено в версии 3.10: classinfo может быть Тип соединения.

iter(object)¶

iter(object, sentinel)

Возвращает объект iterator. Первый аргумент интерпретируется по-разному в зависимости от наличия второго аргумента. Без второго аргумента object должен быть объектом коллекции, который поддерживает протокол iterable (метод __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)¶: Возвращает длину (количество элементов) объекта. Аргументом может быть последовательность (например, строка, байты, кортеж, список или диапазон) или коллекция (например, словарь, набор или замороженный набор).

Детали реализации CPython: len вызывает OverflowError на длинах, превышающих sys.maxsize, таких как range(2 ** 100).

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

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

Примечание

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

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

max(iterable, *, key=None)¶

max(iterable, *, default, key=None)

max(arg1, arg2, *args, key=None)

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

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

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

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

Изменено в версии 3.4: Добавлен параметр default, предназначенный только для ключевых слов.

Изменено в версии 3.8: Ключом *может быть None.

class memoryview(object): Возвращает объект «представление в памяти», созданный на основе заданного аргумента. Дополнительную информацию смотрите в разделе Виды памяти.

min(iterable, *, key=None)¶

min(iterable, *, default, key=None)

min(arg1, arg2, *args, key=None)

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

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

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

Изменено в версии 3.4: Добавлен параметр default, предназначенный только для ключевых слов.

Изменено в версии 3.8: Ключом *может быть None.

next(iterator)¶
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 object. Если файл открыть не удается, выводится OSError. Дополнительные примеры использования этой функции приведены в Чтение и запись файлов.

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

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

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

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

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

Примечание

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

буферизация - это необязательное целое число, используемое для настройки политики буферизации. Введите 0, чтобы отключить буферизацию (разрешена только в двоичном режиме), 1, чтобы выбрать буферизацию строк (используется только при записи в текстовом режиме), и целое число > 1, чтобы указать размер фрагмента буфера фиксированного размера в байтах. Обратите внимание, что указание размера буфера таким образом применимо для двоичного буферизованного ввода-вывода, но TextIOWrapper (т.е. файлы, открытые с помощью mode='r+') будут иметь другую буферизацию. Чтобы отключить буферизацию в TextIOWrapper, попробуйте использовать флаг write_through для io.TextIOWrapper.reconfigure(). Если аргумент «буферизация» не задан, политика буферизации по умолчанию работает следующим образом:

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

encoding - это название кодировки, используемой для декодирования или кодирования файла. Это значение следует использовать только в текстовом режиме. Кодировка по умолчанию зависит от платформы (независимо от того, что возвращает locale.getencoding()), но можно использовать любую text encoding, поддерживаемую 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{...} escape-последовательности.

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

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

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

Пользовательский открыватель можно использовать, передав вызываемый параметр как открыватель. Базовый файловый дескриптор для файлового объекта затем получается при вызове открывателя с помощью (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)  # don't leak a file descriptor

Тип file object, возвращаемый функцией 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.

Создает auditing event open с аргументами file, mode, flags.

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

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

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

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

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

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

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

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

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

Изменено в версии 3.11: Режим 'U' был удален.

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

pow(base, exp, mod=None)¶

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

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

Для 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=None, flush=False)¶

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

    x = property(getx, setx, delx, "I'm the 'x' property.")

Если c является экземпляром C, c.x вызовет средство получения, c.x = value вызовет средство установки, а del c.x - средство удаления.

Если c является экземпляром C, property() вызовет средство получения, decorator вызовет средство установки, а - средство удаления.

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

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

Если c является экземпляром C, @property вызовет средство получения, voltage() вызовет средство установки, а - средство удаления.

@getter¶

@setter¶

@deleter¶

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

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

У объекта property есть x, , и методы, используемые в качестве декораторов, которые создают копию свойства с соответствующей функцией доступа, установленной на функцию decorated. Это лучше всего объяснить на примере:

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

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

class range(stop)
class range(start, stop, step=1): Вместо того, чтобы быть функцией, range на самом деле является неизменяемым типом последовательности, как описано в Диапазоны и Типы последовательностей — list, tuple, range.

repr(object)¶

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

Этот класс имеет пользовательское представление, которое может быть оценено:

class Person:
   def __init__(self, name, age):
      self.name = name
      self.age = age

   def __repr__(self):
      return f"Person('{self.name}', {self.age})"

reversed(seq)¶: iterator`Этот класс :meth:`~object.__reversed__ имеет __len__() пользовательское __getitem__() представление, 0 которое может быть оценено:

round(number, ndigits=None)¶

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

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

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

Примечание

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

class set

class set(iterable)

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

Возвращает новый frozenset объект, необязательно с элементами, взятыми из iterable. list - это встроенный класс. Документацию об этом классе смотрите в tuple и dict collections .

setattr(object, name, value)¶

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

name не обязательно должен быть идентификатором Python, как определено в Идентификаторы и ключевые слова, если только объект не решит применить это, например, в пользовательском __getattribute__() или с помощью __slots__. Атрибут, имя которого не является идентификатором, не будет доступен с использованием точечной записи, но доступен через getattr() и т.д..

Примечание

Поскольку private name mangling происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на setattr().

class slice(stop)¶

class slice(start, stop, step=None)

Поскольку slice происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на range(start, stop, step) None .

start¶

stop¶

step¶: Поскольку start происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на stop step .

Поскольку a[start:stop:step] происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на a[start:stop, i] itertools.islice() iterator .

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

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

Поскольку key=str.lower происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на None.

Поскольку True происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

Поскольку functools.cmp_to_key() происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

Поскольку sorted() происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

Поскольку < происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на __lt__() PEP 8 rich comparisons max() __gt__() .

Поскольку Сортировка, КАК происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

@staticmethod¶

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

Поскольку @staticmethod происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на decorator Определения функций .

Поскольку C.f() происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на C().f() f() .

Поскольку classmethod() происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

Поскольку staticmethod происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

def regular_function():
    ...

class C:
    method = staticmethod(regular_function)

Поскольку Иерархия стандартных типов происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

Изменено в версии 3.10: Поскольку __module__ происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на __name__ __qualname__ __doc__ __annotations__ __wrapped__ .

class str(object='')

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

Поскольку str происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на str().

sum(iterable, /, start=0)¶

Поскольку sum() происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на ''.join(sequence) math.fsum() itertools.chain() .

Изменено в версии 3.8: Поскольку происходит во время компиляции, необходимо вручную изменить имя private attributes (атрибуты с двумя начальными символами подчеркивания), чтобы установить его на .

class super¶

class super(type, object_or_type=None)

Параметр object_or_type определяет method resolution order для поиска. Поиск начинается с класса сразу после type.

Параметр object_or_type определяет __mro__ для поиска. D -> B -> C -> A -> object Поиск B начинается super() с класса C -> A -> object сразу после type.

Параметр object_or_type определяет __mro__ для поиска. getattr() Поиск super() начинается с класса сразу после type.

Параметр object_or_type определяет isinstance(obj, type) для поиска. issubclass(type2, type) Поиск начинается с класса сразу после type.

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

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

class C(B):
    def method(self, arg):
        super().method(arg)    # This does the same thing as:
                               # super(C, self).method(arg)

super`Для обоих :term:`descriptors вариантов использования типичный вызов суперкласса выглядит следующим образом:

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

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

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

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

class type(object)¶

class type(name, bases, dict, **kwds)

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

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

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

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

Смотрите также Введите объекты.

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

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

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

vars()¶

vars(object)

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

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

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

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

zip(*iterables, strict=False)¶

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

Пример:

>>> for item in zip([1, 2, 3], ['sugar', 'spice', 'everything nice']):
...     print(item)
...
(1, 'sugar')
(2, 'spice')
(3, 'everything nice')

:func:`zip`Пример:

Другой способ представить zip() заключается в том, что он преобразует строки в столбцы, а столбцы - в строки. Это аналогично transposing a matrix.

Другой способ представить zip() заключается в том, что он преобразует строки в столбцы, а столбцы - в строки. Это аналогично for list .

Другой способ представить zip() заключается в том, что он преобразует строки в столбцы, а столбцы - в строки. Это аналогично .

Другой способ представить zip() заключается в том, что он преобразует строки в столбцы, а столбцы - в строки. Это аналогично .
```
>>> list(zip(range(3), ['fee', 'fi', 'fo', 'fum']))
[(0, 'fee'), (1, 'fi'), (2, 'fo')]
```
zip() часто используется в случаях, когда предполагается, что итеративные значения имеют одинаковую длину. В таких случаях рекомендуется использовать параметр strict=True. Его выходные данные такие же, как и у обычных zip():
```
>>> list(zip(('a', 'b', 'c'), (1, 2, 3), strict=True))
[('a', 1), ('b', 2), ('c', 3)]
```
В отличие от поведения по умолчанию, оно вызывает ValueError, если одна итерируемая функция исчерпывается раньше других:
```
>>> for item in zip(range(3), ['fee', 'fi', 'fo', 'fum'], strict=True):  
...     print(item)
...
(0, 'fee')
(1, 'fi')
(2, 'fo')
Traceback (most recent call last):
  ...
ValueError: zip() argument 2 is longer than argument 1
```
Без аргумента strict=True любая ошибка, приводящая к появлению итераций разной длины, будет устранена, что, возможно, проявится как труднодоступная ошибка в другой части программы.
Более короткие повторяющиеся элементы можно дополнить постоянным значением, чтобы все повторяющиеся элементы имели одинаковую длину. Это делается с помощью itertools.zip_longest().

Крайние случаи: С единственным итерационным аргументом zip() возвращает итератор из 1 кортежей. Без аргументов он возвращает пустой итератор.

Советы и рекомендации:

Порядок вычисления итераций слева направо гарантирован. Это позволяет использовать идиому для кластеризации ряда данных в группы длиной n, используя zip(*[iter(s)]*n, strict=True). Это повторяет один и тот же итератор n раз, так что каждый выходной кортеж имеет результат n вызовов итератора. Это приводит к разделению входных данных на n фрагментов длиной.

zip() в сочетании с оператором * может использоваться для распаковки списка:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]
>>> x2, y2 = zip(*zip(x, y))
>>> x == list(x2) and y == list(y2)
True

Изменено в версии 3.10: Добавлен аргумент strict.

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

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

Изменено в версии 3.9: При использовании параметров командной строки -E или -I переменная окружения PYTHONCASEOK теперь игнорируется.

Сноски

Вступление

Встроенные константы

Вернуться на верх

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

Python 3.11

Содержание

Дополнительно

Вы здесь: