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

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

Встроенные функции
abs()	dict()	help()	min()	setattr()
all()	dir()	hex()	next()	slice()
any()	divmod()	id()	object()	sorted()
ascii()	enumerate()	input()	oct()	staticmethod()
bin()	eval()	int()	open()	str()
bool()	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()
delattr()	hash()	memoryview()	set()

abs(x)

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

all(iterable)

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

def all(iterable):

    for element in iterable:

        if not element:

            return False

    return True 

any(iterable)

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

def any(iterable):

    for element in iterable:

        if element:

            return True

    return False 

ascii(object)

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

bin(x)

Преобразует целое число в двоичную строку, имеющую префикс '0b'. Результатом является допустимое выражение Python. Если x не является Python-объектом int , он должен определить метод __index__() (docs.python.org/3/reference/datamodel.html#object.__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])

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

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

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

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

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

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

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

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

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

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

Объекты bytes также могут быть созданы с литералов, см. String and Bytes literals (docs.python.org/3/reference/lexical_analysis.html#strings).

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

callable(object)

Возвращает True, если аргумент object является вызываемым, False, если нет. Если возвращается истина, все еще возможно, что вызов не удастся, но если это ложь, вызов object никогда не удастся. Обратите внимание, что классы вызываемы (вызов класс возвращает новый экземпляр); экземпляры вызываемы, если их класс имеет метод __call__() (docs.python.org/3/reference/datamodel.html#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(function)

Возвращает метод класса для function.

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

class C:

    @classmethod

    def f(cls, arg1, arg2, ...): ... 

Форма @classmethod является декоратором (docs.python.org/3/glossary.html#term-decorator) функции - для дополнительной информации см. описание определений функций в Function definitions (docs.python.org/3/reference/compound_stmts.html#function).

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

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

Для получения более подробной информации о методах класса, обратитесь к документации по стандартной иерархии типов в The standard type hierarchy (docs.python.org/3/reference/datamodel.html#types).

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

Компиляция source в код или объект AST. Кодовые объекты могут быть выполнены exec()  или eval() . source может быть либо обычной строкой, либо строкой байтов или объектом AST. Обратитесь к документации модуля ast (docs.python.org/3/library/ast.html#module-ast) для получения информации о том, как работать с объектами AST.

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

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

Необязательные аргументы flags и dont_inherit управляют будущими операторами (см. PEP 236 (www.python.org/dev/peps/pep-0236)), влияющими на компиляцию source. Если их нет (или оба равны нулю) код компилируется с теми будущими операторами, которые в действительности в коде, который вызывает compile() . Если аргумент flags задан, а dont_inherit нет (или равен нулю), то будущие операторы, указанные в аргументе flags используются в дополнение к тем, которые использовались бы в любом случае. Если dont_inherit является ненулевым целым, то аргумент flags - будущие операторы в действительности вокруг вызова компиляции игнорируются.

Будущие операторы задаются битами, которые могут быть побитово ORed вместе для задания нескольких операторов. Логическое поле необходимое к указанию переданной функции можно найти как атрибут compiler_flag экземпляра _Feature в модуле __future__ (docs.python.org/3/library/__future__.html#module-__future__).

Аргумент optimize определяет уровень оптимизации компилятора; значение по умолчанию -1 выбирает уровень оптимизации интерпретатора как заданный опцией -O (docs.python.org/3/using/cmdline.html#cmdoption-O). Явные уровни 0 (нет оптимизация; __debug__ есть true), 1 (утверждения удаляются, __debug__ есть false) или 2 (строки документации удаляются также).

Эта функция возбуждает SyntaxError (docs.python.org/3/library/exceptions.html#SyntaxError), если компилируемый код содержит ошибки, и ValueError (docs.python.org/3/library/exceptions.html#ValueError), если код содержит несуществующие (null) байты.

Если вы хотите парсить код Python в его предтавление AST, см. ast.parse() (docs.python.org/3/library/ast.html#ast.parse).

Примечание. Когда компилируется строка с многострочным кодом в режимах 'single' или 'eval', ввод должен быть завершен по крайней мере одним символом новой строки. Это необходимо для облегчения обнаружения неполных и полных выражений в модуле code (docs.python.org/3/library/code.html#module-code).

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

Изменено в версии 3.5: Ранее возбуждалось TypeError (docs.python.org/3/library/exceptions.html#TypeError), когда в sourse встречались несуществующие байты.

class complex([real[, imag]])

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

Примечание: При преобразовании из строки, она не должна содержать пробелы вокруг центрального оператора + или -. Например, complex('1+2j') правильно, но complex('1 + 2j') вызовет ValueError (docs.python.org/3/library/exceptions.html#ValueError).

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

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

delattr(object, name)

Родственный с setattr() . Аргументы являются объектом и строкой. Строка должна быть именем одного из атрибутов объекта. Функция удаляет названный атрибут, если предоставленный объект это позволяет. Например, delattr(x, 'foobar') эквивалентно del x.foobar.

class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

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

Для других контейнеров см. встроенные классы list , set  и tuple , также как модуль collections (docs.python.org/3/library/collections.html#module-collections).

dir([object])

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

Если у объекта есть метод с именем __dir__() (docs.python.org/3/reference/datamodel.html#object.__dir__), этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, которые реализуют обычные функции __getattr__() (docs.python.org/3/reference/datamodel.html#object.__getattr__) или __getattribute__() (docs.python.org/3/reference/datamodel.html#object.__getattribute__), настроить способ, каким dir() будет представлять их атрибуты.

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

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

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

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

>>> import struct

>>> dir()   # показывает имена в пространстве имен модуля

['__builtins__', '__name__', 'struct']

>>> dir(struct)   # показывает имена в модуле struct 

['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 должен быть последовательностью, iterator (docs.python.org/3/glossary.html#term-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(sequence, start=0):

    n = start

    for elem in sequence:

        yield n, elem

        n += 1 

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

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

Аргумент expression анализируется и оценивается как выражение Python (с технической точки зрения, список условий), использующее globals и locals словари как глобальные и локальные пространства имен. Если словарь globals присутствует и не хватает '__builtins__', текущие глобальные копируются в globals перед тем, как анализируется expression. Это означает, что expression обычно имеет полный доступ к стандартному модулю builtins (docs.python.org/3/library/builtins.html#module-builtins) и распространяются ограничения окружения. Если словарь locals опущен, по умолчанию используется словарь globals. Если оба словаря опущены, выражение выполняется в среде, где вызывается eval(). Возвращаемое значение является результатом вычисляемого выражения. Синтаксические ошибки сообщаются как исключения. Пример:

>>> x = 1

>>> eval('x+1')

2 

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

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

См. ast.literal_eval() (docs.python.org/3/library/ast.html#ast.literal_eval) для функции, которая может безопасно оценить строки с выражениями, содержащими только литералы.

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

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

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

Если словарь globals не содержит значение для ключа __builtins__, ссылка на словарь из встроенного модуля builtins (docs.python.org/3/library/builtins.html#module-builtins) вставляется под этим ключом. Таким образом вы можете контролировать то, что встроенные функции доступны для исполняемого кода, вставив свой ​​собственный словарь __builtins__ в globals, прежде чем передать его exec().

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

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

filter(function, iterable)

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

Обратите внимание, что filter(function, iterable) есть эквивалент выражению-генератору (item for item in iterable if function(item)), если функция не None и (item for item in iterable if item), если функция является None.

См. itertools.filterfalse() (docs.python.org/3/library/itertools.html#itertools.filterfalse) для дополнительной функции, которая возвращает элементы iterable, для которых function возвращает false.

class float([x])

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

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

sign           ::=  "+" | "-"

infinity       ::=  "Infinity" | "inf"

nan            ::=  "nan"

numeric_value  ::=  floatnumber | infinity | nan

numeric_string ::=  [sign] numeric_value 

Здесь floatnumber является формой литерала с плавающей точкой в Python, описанный в Floating point literals (docs.python.org/3/reference/lexical_analysis.html#floating). Регистр не имеет значения, так, например, “inf”, “Inf”, “INFINITY” и “iNfINity” - все приемлемые варианты написания для положительной бесконечности.

В ином случае, если аргумент является целым числом или числом с плавающей точкой, возвращается число с плавающей точкой с тем же значением (в пределах точности числа с плавающей точкой в Python). Если аргумент находится вне диапазона float в Python, будет возбуждено OverflowError (docs.python.org/3/library/exceptions.html#OverflowError).

Для общего объекта Python x float(x) представляется в x.__float__().

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

Примеры:

>>> float('+1.23')

1.23

>>> float('   -12345\n')

-12345.0

>>> float('1e-003')

0.001

>>> float('+1E6')

1000000.0

>>> float('-Infinity')

-inf 

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

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

format(value[, format_spec])

Преобразует value к "отформатированному" представлению, как контролируется format_spec. Интерпретация format_spec будет зависеть от типа аргумента value, однако есть стандартный синтаксис форматирования, который используется большинством встроенных типов: Format Specification Mini-Language (docs.python.org/3/library/string.html#formatspec).

По умолчанию format_spec - это пустая строка, которая обычно дает тот же эффект, что и вызов str(value) (docs.python.org/3/library/stdtypes.html#str).

Вызов format(value, format_spec) переводится в type(value).__format__(format_spec), который обходит словарь экземпляра при поиске значения метода __format__() (docs.python.org/3/reference/datamodel.html#object.__format__). Возникает исключение TypeError (docs.python.org/3/library/exceptions.html#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 (docs.python.org/3/library/collections.html#module-collections).

getattr(object, name[, default])

Возвращает значение атрибута object с указанным именем. name должен быть строкой. Если строка является именем одного из атрибутов объекта, результатом является значение этого атрибута. Например, getattr(x, 'foobar') эквивалентна x.foobar. Если названный атрибут не существует, то возвращается то, что задано по умолчанию, если предусмотрено, в противном случае возбуждается AttributeError (docs.python.org/3/library/exceptions.html#AttributeError).

globals()

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

hasattr(object, name)

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

hash(object)

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

Примечание. Для объекта с пользовательскими методами __hash__(), обратите внимание, что hash() обрезает возвращаемое значение на основе битовой ширины хост-машины. Смотрите __hash__()  (docs.python.org/3/reference/datamodel.html#object.__hash__) для получения подробной информации.

help([object])

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

Эта функция добавлена к встроенному пространству имен модуля site (docs.python.org/3/library/site.html#module-site).

Изменено в версии 3.4: Изменения в pydoc (docs.python.org/3/library/pydoc.html#module-pydoc) и inspect (docs.python.org/3/library/inspect.html#module-inspect) означают, что сообщаемые подписи для вызываемых объектов в настоящее время более полный и последовательный.

hex(x)

Преобразует целое число в строчное шестнадцатеричное представление с префиксом “0x”, например:

>>> hex(255)

'0xff'

>>> hex(-42)

'-0x2a' 

Если x не является объектом int Python, у него должен быть определен метод __index__(), возвращающий целое.

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

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

id(object)

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

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

input([prompt])

Если аргумент prompt присутствует, он пишется в стандартный вывод без последующего символа новой строки. Затем функция считывает строку из ввода, преобразует ее в строковый тип данных (удаляя символ конца строки) и возвращает результат. Когда считывается EOF, возбуждается EOFError (docs.python.org/3/library/exceptions.html#EOFError). Пример:

>>> s = input('--> ')  

--> Monty Python's Flying Circus

>>> s  

"Monty Python's Flying Circus" 

Если был загружен модуль readline (docs.python.org/3/library/readline.html#module-readline), то input() будет использовать его для предоставления сложного редактирования строки и возможностей истории.

class int(x=0)
class int(x, base=10)

Возвращает целочисленный объект, созданный из числа или строки x, или возвращает 0, если аргументы не заданы. Если x является числом, возвращает x.__int__() (docs.python.org/3/reference/datamodel.html#object.__int__). У вещественных чисел удаляется дробная часть.

Если x не число или если задано base, то x должен быть строкой, байтами , или экземпляром bytearray , представляющим литерал целого числа (docs.python.org/3/reference/lexical_analysis.html#integers) по основанию base. Литералу может предшествовать + или - (без пробела между ними) и окруженный пробелами. Литерал по основанию n состоит из цифр от 0 до n-1, включая от a до z (или от A до Z), имеющих значения от 10 до 35. По умолчанию base равно 10. Допустимые значения 0 и 2-36. Основания -2, -8, и -16 могут иметь необязательные префиксы 0b/0B, 0o/0O или 0x/0X, как с целочисленными литералами в коде. Основание 0 означает точно интерпретировать как кодовый литерал, так что фактическое основание 2, 8, 10 или 16, и так что int('010', 0) не является правильным, в то время как int('010') верно, а также int('010', 8).

Целочисленный тип описан в Числовые типы — int, float, complex .

Изменено в версии 3.4: Если base не является экземпляром int и объект base имеет метод base.__index__ (docs.python.org/3/reference/datamodel.html#object.__index__), то этот метод вызывается для получения целого для base. В предыдущих версиях использовали base.__int__ (docs.python.org/3/reference/datamodel.html#object.__int__) вместо base.__index__.

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

isinstance(object, classinfo)

Возвращает правду, если аргумент object является экземпляром аргумента classinfo, или (прямым, косвенным или виртуальным (docs.python.org/3/glossary.html#term-abstract-base-class)) подклассом от него. Если object не является объектом данного типа, функция всегда возвращает ложь. Если classinfo не является классом (тип объекта), это может быть кортеж объектов типа, или может рекурсивно содержать другие такие кортежи (другие типы последовательностей не принимаются). Если classinfo не является типом или кортежем типов и подобных кортежей, возбуждается исключение TypeError (docs.python.org/3/library/exceptions.html#TypeError).

issubclass(class, classinfo)

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

iter(object[, sentinel])

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

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

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

with open('mydata.txt') as fp:

    for line in iter(fp.readline, ''):

        process_line(line) 

len(s)

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

class list([iterable])

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

locals()

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

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

map(function, iterable, ...)

Возвращает итератор, который применяет function к каждому элементу из iterable, принося результаты. Если передаются дополнительные аргументы iterable, function должна принять все множество аргументов и применится к элементам из всех параллельно. С несколькими итерируемыми итератор останавливается, когда самая короткая итерация исчерпана. Для случаев, когда входы функции уже расположены в аргументе кортежей см itertools.starmap() (docs.python.org/3/library/itertools.html#itertools.starmap).

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

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

Если предоставляется один позиционный аргумент, он должен быть iterable (docs.python.org/3/glossary.html#term-iterable). Возвращается наибольший элемент из итерации. Если передаются два или более позиционных аргументов, возвращается самый большой из них.

Есть два необязательных keyword-only (именованных - прим. пер.) аргумента. Аргумент key определяет одно-аргументную упорядочивающую функцию такую же, как используемую для list.sort() . Аргумент default определяет возвращаемый объект, если предоставленная итерация пуста. Если итерация пуста и default не предоставлен, возбуждается ValueError (docs.python.org/3/library/exceptions.html#ValueError).

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

Новое в версии 3.4: default keyword-only аргумент.

memoryview(obj)

Возвращает объект “memory view”, созданный из данного аргумента. Для детальной информации см. Memory Views .

min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])

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

Если предоставлен один позиционный аргумент, он должен быть iterable (docs.python.org/3/glossary.html#term-iterable). Если предоставляются два и более позиционных аргумента, возвращается наименьший позиционный аргумент.

Существует два необязательных keyword-only аргумента. Аргумент key определяет одно-аргументную порядковую функцию такую же, как используемую для list.sort() . Аргумент default определяет возвращаемый объект, если предоставленная итерация пуста. Если итерация пуста и default не предоставлен, возбуждается ValueError (docs.python.org/3/library/exceptions.html#ValueError).

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

Новое в версии 3.4: default keyword-only аргумент.

next(iterator[, default])

Извлекает следующий элемент из iterator, путем вызова его методом __next__() . Если дан default, то он возвращается, если итератор исчерпан, иначе возбуждается StopIteration (docs.python.org/3/library/exceptions.html#StopIteration).

class object

Возвращает новый безликий объект. object является основой для всех классов. У него есть методы, которые общие для всех экземпляров классов Python. Эта функция не принимает никакие аргументы.

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

oct(x)

Обращает целое десятичное число в восьмеричное число в виде строки. Результатом является валидное выражение Python. Если x не является объектом int, он должен определить метод __index__() (docs.python.org/3/reference/datamodel.html#object.__index__), который возвращает целое десятичное число.

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

Открывает file и возвращает соответствующий file object (docs.python.org/3/glossary.html#term-file-object). Если файл не может быть открыт, то возбуждается OSError (docs.python.org/3/library/exceptions.html#OSError).

file - это path-like object (docs.python.org/3/glossary.html#term-path-like-object), задающий путь-имя (абсолютное или относительное к текущей рабочей директории) файла, который открыт, или числовой файловый дескриптор файла, который был обернут. (Если дан файловый дескриптор, он закрывается, когда возвращаемый объект I/O закрыт, до тех пор пока closefd не установлен в False.

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

Символ	Значение
'r'	открывает для чтения (по умолчанию)
'w'	открывает для записи, сначала усекая файл
'x'	открывает исключительно для создания, терпит неудачу, если файл уже существует
'a'	открывает для записи, если файл уже существует, то для добавления в его конец
'b'	бинарный режим
't'	текстовый режим (по умолчанию)
'+'	открывает дисковый файл для обновления (чтения или записи)
'U'	режим universal newlines (docs.python.org/3/glossary.html#term-universal-newlines) (устаревший)

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

Как уже упоминалось в Overview (docs.python.org/3/library/io.html#io-overview), Python делает различия между бинарным и текстовым вводом-выводом. Файлы, открытые в бинарном режиме (включающие 'b' в аргументе mode) возвращают содержимое как объекты bytes (docs.python.org/3/library/stdtypes.html#bytes) без какого-либо декодирования. В текстовом режиме (по умолчанию или когда 't' включено в аргумент mode) содержимое файла возвращается как str (docs.python.org/3/library/stdtypes.html#str), байты сначала декодируются, используя платформенно-зависимую кодировку или используя указанную кодировку, если она задана.

Замечание: Python не зависит от идеи текстовых файлов, лежащей в основе операционной системы; вся обработка выполняется Python'ом самостоятельно и является поэтому платформенно-независимой.

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

• Бинарные файлы буферизуются частями фиксированного размера; размер буфера выбирается, используя эвристическую попытку определить лежащий в основе "размер блока" устройства и отступание на io.DEFAULT_BUFFER_SIZE (docs.python.org/3/library/io.html#io.DEFAULT_BUFFER_SIZE). Во многих системах буфер обычно будет 4096 или 8192 байтов длиной.
• "Интерактивные" текстовые файлы (файлы, для которых isatty() (docs.python.org/3/library/io.html#io.IOBase.isatty) возвращает True) используют строчную буферизацию. Другие текстовые файлы используют политику, описанную выше для бинарных файлов.

encoding есть название кодирования, используемого для декодирования или кодирования файла. Его следует использовать только в текстовом режиме. По умолчанию кодирование платформенно-зависимо (что бы ни вернул locale.getpreferredencoding() (docs.python.org/3/library/locale.html#locale.getpreferredencoding)), но любой
text encoding (docs.python.org/3/glossary.html#term-text-encoding), поддерживаемый Python, может быть использован. Смотрите модуль codecs (docs.python.org/3/library/codecs.html#module-codecs) для списка поддерживаемых кодировок.

errors - это необязательная строка, которая определяет, как ошибки кодирования и декодирования должны быть обработаны, она не может быть использовано в бинарном режиме. Разнообразие обработчиков стандартных ошибок доступно (перечислены в Error Handlers (docs.python.org/3/library/codecs.html#error-handlers)), хотя любое имя обрабатываемой ошибки, которая была зарегистрирована с codecs.register_error() (docs.python.org/3/library/codecs.html#codecs.register_error) также действительна. Стандартные имена включают:

• 'strict' возбуждает исключение ValueError (docs.python.org/3/library/exceptions.html#ValueError), если есть ошибка кодирования. По умолчанию значение None имеет тот же эффект.
• 'ignore' игнорирует ошибки. Заметьте, что игнорирование ошибок кодирования может привести к потере данных.
• 'replace' вызывает замену маркера (таких как '?'), который будет вставлен, где есть бесформенные данные.
• 'surrogateescape' будет представлять любые некорректные байты как указатели кода в Unicode Private Use Area, находящиеся в диапазоне от U+DC80 до U+DCFF. Эти частные указатели кода будут затем переведены назад в те же байты, когда обработчик ошибок 'surrogateescape' используется, когда данные записываются. Это полезно при обработки файлов в неизвестной кодировке.
• 'xmlcharrefreplace' поддерживается только при записи в файл. Неподдерживаемые кодировкой символы заменяются ссылкой соответствующего символа XML &#nnn;.
• 'backslashreplace' заменяет бесформенные данные backslashed escape последовательностями Python.
• 'namereplace' (также поддерживается только при записи) заменяет неподдерживаемые символы на \N{...} escape-последовательности.

newline контролирует, как работает режим universal newlines (docs.python.org/3/glossary.html#term-universal-newlines) (это применяется только к текстовому режиму). Это может быть None, '', '\n', '\r' и '\r\n'. Это работает следующим образом:

• При чтении ввода из потока, если newline есть None, режим universal newlines включен. Строки во вводе могут заканчиваться '\n', '\r' или '\r\n', и это переводится в '\n' перед возвратом к вызывающему. Если это есть '', режим universal newlines включен, но концы строк возвращаются к вызывающему непереведенными. Если у него любое другое допустимое значение, вводимые строки прерываются только заданной строкой, и концы строк возвращаются к вызывающему непереведенными.
• При записи вывода в поток, если newline есть None, любые записываемые символы '\n' переводятся в системный по умолчанию разделитель строк, os.linesep (docs.python.org/3/library/os.html#os.linesep). Если newline есть '' или '\n', перевод не происходит. Если newline есть любое другое допустимое значение, любые записываемые символы '\n' переводятся в заданную строку.

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

Пользовательский открыватель можно использовать, передавая вызываемый как opener. Лежащий в основе файловый дескриптор для файлового объекта есть затем полученный с вызывающим opener (file, flags). opener должен возвращать открытый файловый дескриптор (передающий os.open (docs.python.org/3/library/os.html#os.open) как результаты opener в функциональности похожей на передающийся None).

Вновь созданный файл является non-inheritable (docs.python.org/3/library/os.html#fd-inheritance).

Следующий пример использует параметр dir_fd (docs.python.org/3/library/os.html#dir-fd) функции os.open() (docs.python.org/3/library/os.html#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)  # файловый дескриптор не просачивается 

Тип file object (docs.python.org/3/glossary.html#term-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.

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

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

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

• Файл теперь ненаследственный.

Устаревший, начиная с версии 3.4, будет удален в версии 4.0: Режим 'U'.

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

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

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

• Добавлена поддержка для принятия объектов, реализующих os.PathLike (docs.python.org/3/library/os.html#os.PathLike).
• В Windows открытие консольного буфера может вернуть подкласс io.RawIOBase, отличный от io.FileIO.

ord(c)

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

pow(x, y[, z])

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

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

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

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

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

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

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

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

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

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

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

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

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 будет вызывать getter, c.x = value будет вызывать setter и del c.x - deleter.

Если задано, doc будет строкой документации свойства атрибута. Иначе свойство скопирует строку документации fget (если она существует). Это делает возможным легко создать свойства только для чтения, используя property() как decorator (docs.python.org/3/glossary.html#term-decorator).

class Parrot:

    def __init__(self):

        self._voltage = 100000

    @property

    def voltage(self):

        """Get the current voltage."""

        return self._voltage 

Декоратор @property превращает метод voltage() в "getter" для атрибута только для чтения с таким же именем, и это устанавливает строку документации для voltage в “Get the current 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: Строки документации свойств объекта теперь записываемые.

range(stop)
range(start, stop[, step])

range (docs.python.org/3/library/stdtypes.html#range) скорее не функция, а на самом деле тип неизменяемой последовательности, как документировано в Диапазоны  и Типы последовательностей — list, tuple, range .

repr(object)

Возвращает строку, содержащую печатную версию объекта. Для многих типов эта функция делает попытку вернуть строку, которая бы дала объект с таким же значением, когда передается eval() (docs.python.org/3/library/functions.html#eval), иначе представление - это строка, заключенная в угловые скобки, которые содержат имя типа объекта вместе с дополнительной информацией, часто включающей имя и адрес объекта. Класс может контролировать, что эта функция возвращает для ее экземпляров, путем определения метода __repr__() (docs.python.org/3/reference/datamodel.html#object.__repr__).

reversed(seq)

Возвращает перевернутый iterator (docs.python.org/3/glossary.html#term-iterator). 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 (положительное, ноль или отрицательное). Возвращаемое значение есть целое, если вызывается с одним аргументом, иначе такого же типа как number.

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

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

class set([iterable])

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

Для других контейнеров смотрите встроенные классы frozenset, list, tuple и dict, а также модуль collections (docs.python.org/3/library/collections.html#module-collections).

setattr(object, name, value)

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

class slice(stop)
class slice(start, stop[, step])

Возвращает объект slice (docs.python.org/3/glossary.html#term-slice), представленный множеством индексов, определенных range(start, stop, step). Аргументы start и step по умолчанию None.
У объектов среза (slice) есть только для чтения данные атрибутов start, stop и step, которые просто возвращают значения аргументов (или их по-умолчанию). Они не имеют никакой другой явной функциональности; однако они используются Numerical Python и другими сторонними расширениями. Объекты срезов также генерируются, когда используется расширенный синтаксис индексирования. Например: a[start:stop:step] или a[start:stop, i]. Смотрите itertools.islice() (docs.python.org/3/library/itertools.html#itertools.islice) для альтернативной версии, которая возвращает итератор.

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

Возвращает новый отсортированный список из элементов в iterable.

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

key определяет функцию одного аргумента, которая используется для извлечения ключа сравнения из каждого элемента списка: key=str.lower. По умолчанию значение None (непосредственное сравнение элементов).

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

Используйте functools.cmp_to_key() (docs.python.org/3/library/functools.html#functools.cmp_to_key) для преобразования функции cmp старого стиля в функцию key.

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

Примеры сортировки и краткий учебник по сортировке смотри в Sorting HowTo (docs.python.org/3/howto/sorting.html#sortinghowto).

staticmethod(function)

Возвращает статический метод для function.

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

class C:

    @staticmethod

    def f(arg1, arg2, ...): ... 

Форма @staticmethod - это функция decorator (docs.python.org/3/glossary.html#term-decorator) - смотри описание определений функций в Function definitions (docs.python.org/3/reference/compound_stmts.html#function) для подробностей.

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

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

Для получения более подробной информации о статических методах, обращайтесь к документации по иерархии стандартных типов в The standard type hierarchy (docs.python.org/3/reference/datamodel.html#types).

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

Возвращает str версию object. Смотри str()  для деталей.

str - это встроенный строковый class (docs.python.org/3/glossary.html#term-class). Для получения общей информации о строках смотрите Тип текстовой последовательности — str .

sum(iterable[, start])

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

В некоторых случаях есть хорошая альтернатива для sum(). Предпочтительный, быстрый способ объединить последовательность строк - это вызов ''.join(sequence). Чтобы добавить значения с плавающей точкой с расширенной точностью, смотри math.fsum() (docs.python.org/3/library/math.html#math.fsum). Для объединения ряда итераций рассмотрите использование itertools.chain() (docs.python.org/3/library/itertools.html#itertools.chain).

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

Возвращает объект прокси, который делегирует метод, вызывающий родительский или сестринский класс для type. Это полезно для доступа к унаследованным методам, которые были переопределены в классе. Порядок поиска такой же как при использовании getattr()  за исключением того, что сам type пропускается.

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

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

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

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

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

class C(B):

    def method(self, arg):

        super().method(arg)    # Делает тоже самое как:

                               # super(C, self).method(arg) 

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

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

Для практических предложений, как разрабатывать совместные классы, использующие super(), смотри guide to using super() (rhettinger.wordpress.com/2011/05/26/super-considered-super/)

tuple([iterable])

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

class type(object)
class type(name, bases, dict)

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

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

С тремя аргументами возвращает новый объект типа. Это по-сути динамическая форма оператора class (docs.python.org/3/reference/compound_stmts.html#class). Строка name является именем класса и становится атрибутом __name__; кортеж bases перечисляет базовые классы и становится атрибутом __bases__; словарь dict является пространством имен, содержащим определения для тела класса, и становится атрибутом __dict__. Например, следующие два выражения создают объекты идентичного типа:

>>> class X:

...     a = 1

...

>>> X = type('X', (object,), dict(a=1)) 

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

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

vars([object])

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

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

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

zip(*iterables)

Создает итератор, который агрегирует элементы от каждого из iterables.

Возвращает итератор кортежей, где i-й кортеж содержит i-й элемент каждого из аргументов последовательностей или iterables. Итератор останавливается, когда самая короткая итерация исчерпывается. Если в качестве аргумента только одна итерация, то возвращает итератор одноэлементных кортежей. Без аргументов возвращает пустой итератор. Эквивалентно следующему:

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) 

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

zip() следует использовать только с входящими неравной длины, если вам не важны концы, неучтенные значения из более длинных iterables. Если эти значения важны, используйте вместо этого itertools.zip_longest() (docs.python.org/3/library/itertools.html#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() (docs.python.org/3/library/importlib.html#importlib.import_module).

Эта функция вызывается оператором import (docs.python.org/3/reference/simple_stmts.html#import). Это может быть заменено (путем импорта модуля builtings (docs.python.org/3/library/builtins.html#module-builtins) и назначения builtins.__import__) для изменения семантики оператора import, но делать так настоятельно не рекомендуется, поскольку это, как правило, проще при использовании импортируемых hooks (см. PEP 302 (www.python.org/dev/peps/pep-0302)) для достижения тех же целей, и это не вызывает проблем с кодом, который предполагает реализацию импорта по умолчанию в использовании. Прямое использование __import__() также не приветствуется в пользу importlib.import_module().

Функция импортирует модуль name, потенциально используя заданные globals и locals для определения, как интерпретировать имя в контексте пакета. fromlist задает имена объектов или подмодулей, которые должны быть импортированы из модуля, заданного как name. Стандартная реализация не использует ее аргумент locals вообще, и использует ее globals только для определения пакета контекста оператора import.

level определяет использовать ли абсолютный или относительный импорт. 0 (по умолчанию) обозначает выполнение только абсолютных импортов. Положительное значение для level указывает количество родительских каталогов для поиска по отношению к директории модуля вызываемого __import__() (для подробностей см. PEP 328 (python.org/dev/peps/pep-0328)).

Когда переменная 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.

С другой стороны, выражение от spam.ham import eggs, sausage as saus дает подобный результат:

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)

eggs = _temp.eggs

saus = _temp.sausage 

Здесь от __import__() возвращается модуль spam.ham. Из этого объекта имена в импорте извлекаются и присваиваются их соответствующим именам.

Если вы просто хотите импортировать модуль (возможно в пакете) по имени, используйте importlib.import_module() (docs.python.org/3/library/importlib.html#importlib.import_module).

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

Примечания

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

Создано

2014-06-30

Обновлено

2017-07-30

• Добавить комментарий

Перекрёстные ссылки книги для 2. Встроенные функции

• 1. Введение
• Вверх
• 3. Встроенные константы