2. Встроенные функции¶Built-in Functions

Интерпретатор 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(), используя escape-последовательности \x, \u или \U. Это создаёт строку, похожую на возвращаемую repr() в Python 2.

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

class bool([x])¶: Возвращает логическое значение, то есть True или False. x преобразуется с использованием стандартной процедуры проверки истинности. Если x ложен или опущен, возвращает False; в противном случае возвращает True. Класс bool является подклассом int (см. Numeric Types – int, float, complex). Он не может быть далее унаследован. Его единственные экземпляры – False и True (см. Boolean Values).

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

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

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

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

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

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

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

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

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

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

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

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

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

chr(i)¶: Возвращает строку, представляющую символ, кодовая точка Unicode которого равна целому числу i. Например, chr(97) возвращает строку 'a'. Это обратная операция для ord(). Допустимый диапазон аргумента – от 0 до 1 114 111 (0x10FFFF в шестнадцатеричной системе). ValueError будет возбуждено, если i выходит за пределы этого диапазона.

classmethod(function)¶

Возвращает метод класса для функции.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

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

class complex([real[, imag]])¶

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

Примечание

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

Создаёт новый словарь. Объект dict – это класс словаря. См. dict и Отображения (Mapping Types) – dict для документации об этом классе.

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

dir([object])¶

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

Если у объекта есть метод с именем __dir__(), этот метод будет вызван и должен вернуть список атрибутов. Это позволяет объектам, реализующим собственную функцию __getattr__() или __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)¶

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

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

Эквивалентно следующему:

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

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

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

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

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

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

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

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

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

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

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

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

Примечание

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

Примечание

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

filter(function, iterable)¶

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

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

См. itertools.filterfalse() – дополняющую функцию, которая возвращает элементы iterable, для которых function возвращает ложь.

class float([x])¶

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

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

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

Здесь floatnumber – это форма литерала числа с плавающей точкой Python, описанная в Литералы чисел с плавающей точкой. Регистр не имеет значения, так, например, “inf”, “Inf”, “INFINITY” и “iNfINity” – все это допустимые написания для положительной бесконечности.

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

format(value[, format_spec])¶

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

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

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

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

class frozenset([iterable])

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

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

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

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

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

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

Примечание

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

help([object])¶

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

Эта функция добавляется во встроенное пространство имён модулем site.

Изменено в версии 3.4: Изменения в pydoc и 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. Пример:

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

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

class int(x=0)¶

class int(x, base=10)

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

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

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

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

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

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

iter(object[, sentinel])¶

Возвращает объект итератора. Первый аргумент интерпретируется совершенно по-разному в зависимости от наличия второго аргумента. Без второго аргумента object должен быть объектом коллекции, поддерживающим протокол итерации (метод __iter__()), или он должен поддерживать протокол последовательности (метод __getitem__() с целочисленными аргументами, начиная с 0). Если он не поддерживает ни один из этих протоколов, возбуждается TypeError. Если задан второй аргумент sentinel, то object должен быть вызываемым объектом. Созданный в этом случае итератор будет вызывать object без аргументов при каждом вызове своего метода __next__(); если возвращённое значение равно sentinel, будет возбуждено StopIteration, в противном случае значение будет возвращено.

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

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

with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

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

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

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

Примечание

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

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

max(iterable, *[, key, default])¶

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

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

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

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

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

Новое в версии 3.4: Аргумент default, указываемый только по ключевому слову.

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

min(iterable, *[, key, default])¶

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

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

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

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

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

Новое в версии 3.4: Аргумент default, указываемый только по ключевому слову.

next(iterator[, default])¶: Извлекает следующий элемент из iterator вызовом его метода __next__(). Если задан default, он возвращается, когда итератор исчерпан; в противном случае возбуждается StopIteration.

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

Примечание

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

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

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

Открывает file и возвращает соответствующий объект файла. Если файл не удаётся открыть, возбуждается OSError.

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

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

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

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

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

Примечание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Изменено в версии 3.4: Файл теперь не наследуется.

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

ord(c)¶: Принимает строку, представляющую один символ Unicode, и возвращает целое число – кодовую точку Unicode этого символа. Например, ord('a') возвращает целое число 97, а ord('\u2020') возвращает 8224. Это обратная функция к 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)¶

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

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

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

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

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

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

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

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

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

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

    def getx(self):
        return self._x

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

    def delx(self):
        del self._x

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

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

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

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

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

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

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

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

    @property
    def x(self):
        """Я – свойство 'x'."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

Этот код полностью эквивалентен первому примеру. Убедитесь, что дополнительные функции имеют то же имя, что и исходное свойство (в данном случае x).

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

range(stop)
range(start, stop[, step]): На самом деле range – это не функция, а неизменяемый тип последовательности, как описано в Ranges и Sequence Types – list, tuple, range.

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

reversed(seq)¶: Возвращает обратный итератор. seq должен быть объектом, который имеет метод __reversed__() или поддерживает протокол последовательности (метод __len__() и метод __getitem__() с целочисленными аргументами, начиная с 0).

round(number[, ndigits])¶

Возвращает значение с плавающей запятой number, округлённое до ndigits знаков после десятичной точки. Если ndigits опущен, по умолчанию используется ноль. Делегирует number.__round__(ndigits).

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

Примечание

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

class set([iterable])

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

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

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

class slice(stop)¶
class slice(start, stop[, step]): Возвращает объект slice, представляющий набор индексов, заданный range(start, stop, step). Аргументы start и step по умолчанию равны None. Объекты среза имеют атрибуты только для чтения start, stop и step, которые просто возвращают значения аргументов (или их значения по умолчанию). Другой явной функциональности у них нет; однако они используются Numerical Python и другими сторонними расширениями. Объекты среза также создаются при использовании расширенного синтаксиса индексации. Например: a[start:stop:step] или a[start:stop, i]. См. itertools.islice() для альтернативной версии, возвращающей итератор.

sorted(iterable[, key][, reverse])¶

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

Имеет два необязательных аргумента, которые должны быть указаны как именованные.

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

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

Используйте functools.cmp_to_key() для преобразования устаревшей функции cmp в функцию key.

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

Примеры сортировки и краткое руководство см. в Sorting HOW TO.

staticmethod(function)¶

Возвращает статический метод для функции.

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

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

Форма @staticmethod является декоратором функции – см. описание определений функций в Function definitions для подробностей.

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

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

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

class str(object='')

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

Возвращает строковое представление str объекта object. См. str() для подробностей.

str – это встроенный строковый класс. Общую информацию о строках см. в Text Sequence Type – str.

sum(iterable[, start])¶

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

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

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

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

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

Если второй аргумент опущен, возвращаемый объект 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). Это достигается за счет реализации собственного метода __getattribute__() для поиска классов в предсказуемом порядке, поддерживающем кооперативное множественное наследование. Соответственно, super() не определен для неявного поиска с помощью операторов или инструкций, таких как super()[name].

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

За практическими рекомендациями по проектированию кооперативных классов с использованием super() обратитесь к руководству по использованию super().

tuple([iterable]): На самом деле tuple – это не функция, а неизменяемый тип последовательности, как описано в Кортежи и Типы последовательностей – list, tuple, range.

class type(object)¶

class type(name, bases, dict)

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

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

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

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

См. также Type Objects.

vars([object])¶

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

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

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

zip(*iterables)¶

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

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

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

Гарантируется порядок вычисления итерабельных объектов слева направо. Это делает возможным идиому для группировки ряда данных в группы длины n с использованием zip(*[iter(s)]*n).

zip() следует использовать с входами разной длины только в тех случаях, когда не важны лишние, непарные значения из более длинных итерабельных объектов. Если эти значения важны, вместо этого используйте itertools.zip_longest().

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

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

__import__(name, globals=None, locals=None, fromlist=(), level=0)¶

Примечание

Это продвинутая функция, которая не нужна в повседневном программировании на Python, в отличие от importlib.import_module().

Эта функция вызывается инструкцией import. Она может быть заменена (путем импорта модуля builtins и присваивания builtins.__import__) для изменения семантики инструкции import, но делать это настоятельно не рекомендуется, так как обычно проще использовать хуки импорта (см. PEP 302) для достижения тех же целей, и это не вызывает проблем с кодом, который предполагает использование реализации импорта по умолчанию. Прямое использование __import__() также не рекомендуется; вместо него предпочтительнее importlib.import_module().

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

level указывает, использовать ли абсолютные или относительные импорты. 0 (по умолчанию) означает выполнять только абсолютные импорты. Положительные значения level указывают количество родительских каталогов для поиска относительно каталога модуля, вызывающего __import__() (см. PEP 328 для подробностей).

Когда переменная name имеет вид package.module, в обычном случае возвращается пакет верхнего уровня (имя до первой точки), а не модуль, заданный name. Однако, если задан непустой аргумент fromlist, возвращается модуль, заданный name.

Например, инструкция import spam приводит к байт-коду, напоминающему следующий код:

spam = __import__('spam', globals(), locals(), [], 0)

Инструкция import spam.ham приводит к следующему вызову:

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

Обратите внимание, как __import__() здесь возвращает модуль верхнего уровня, потому что это объект, который связывается с именем инструкцией import.

С другой стороны, оператор from spam.ham import eggs, sausage as saus приводит к

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

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

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

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

Сноски

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