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

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

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

Кроме того, есть ещё четыре встроенные функции, которые больше не считаются необходимыми: apply(), buffer(), coerce() и intern(). Они описаны в разделе Необязательные встроенные функции.

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

all(iterable)¶

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

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

Новое в версии 2.5.

any(iterable)¶

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

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

Новое в версии 2.5.

basestring()¶: Этот абстрактный тип является суперклассом для str и unicode. Его нельзя вызвать или создать экземпляр, но его можно использовать для проверки, является ли объект экземпляром str или unicode. isinstance(obj, basestring) эквивалентен isinstance(obj, (str, unicode)).

Новое в версии 2.3.

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

Новое в версии 2.6.

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

Новое в версии 2.2.1.

Изменено в версии 2.3: Если аргумент не указан, эта функция возвращает False.

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

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

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

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

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

Новое в версии 2.6.

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

chr(i)¶: Возвращает строку из одного символа, код ASCII которого равен целому числу i. Например, chr(97) возвращает строку 'a'. Это обратная функция к ord(). Аргумент должен находиться в диапазоне [0..255] включительно; если i выходит за пределы этого диапазона, возбуждается ValueError. См. также unichr().

classmethod(function)¶

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

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

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

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

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

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

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

Новое в версии 2.2.

Изменено в версии 2.4: Добавлен синтаксис декораторов функций.

cmp(x, y)¶: Сравнивает два объекта x и y и возвращает целое число в зависимости от результата. Возвращаемое значение отрицательно, если x < y, равно нулю, если x == y, и строго положительно, если x > y.

compile(source, filename, mode[, flags[, dont_inherit]])¶

Компилирует source в объект кода или AST. Объекты кода могут быть выполнены с помощью инструкции exec или вычислены вызовом eval(). source может быть строкой Unicode, строкой, закодированной в Latin-1, или объектом 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__.

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

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

Примечание

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

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

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

Изменено в версии 2.3: Добавлены аргументы flags и dont_inherit.

Изменено в версии 2.6: Добавлена поддержка компиляции объектов AST.

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

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

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

Примечание

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

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

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

class dict(**kwarg)

class dict(mapping, **kwarg)

class dict(iterable, **kwarg)

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

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

dir([object])¶

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

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

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

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

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

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

>>> import struct
>>> dir()   # показать имена в пространстве имён модуля
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # показать имена в модуле struct
['Struct', '__builtins__', '__doc__', '__file__', '__name__',
 '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
>>> class Shape(object):
        def __dir__(self):
            return ['area', 'perimeter', 'location']
>>> s = Shape()
>>> dir(s)
['area', 'perimeter', 'location']

Примечание

Поскольку 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).

Изменено в версии 2.3: Использование divmod() с комплексными числами устарело.

enumerate(sequence, start=0)¶

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

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

Новое в версии 2.3.

Изменено в версии 2.6: Был добавлен параметр start.

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

Аргументами являются строка в кодировке Unicode или Latin-1 и необязательные глобальные и локальные переменные. Если указан, globals должен быть словарём. Если указан, locals может быть любым отображающим объектом.

Изменено в версии 2.4: ранее locals должен был быть словарём.

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

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

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

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

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

execfile(filename[, globals[, locals]])¶

Эта функция аналогична оператору exec, но анализирует файл, а не строку. Она отличается от оператора import тем, что не использует управление модулями – она читает файл безусловно и не создаёт новый модуль. 1

Аргументами являются имя файла и два необязательных словаря. Файл анализируется и выполняется как последовательность инструкций Python (аналогично модулю) с использованием словарей globals и locals в качестве глобального и локального пространства имён. Если указан, locals может быть любым отображением. Помните, что на уровне модуля globals и locals – один и тот же словарь. Если в качестве globals и locals передаются два разных объекта, код будет выполняться так, как если бы он был встроен в определение класса.

Изменено в версии 2.4: ранее locals должен был быть словарём.

Если словарь locals опущен, по умолчанию используется словарь globals. Если оба словаря опущены, выражение выполняется в окружении, где вызывается execfile(). Возвращаемое значение – None.

Примечание

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

file(name[, mode[, buffering]])¶

Функция-конструктор для типа file, описанного далее в разделе Файловые объекты. Аргументы конструктора совпадают с аргументами встроенной функции open(), описанной ниже.

При открытии файла предпочтительнее использовать open() вместо непосредственного вызова этого конструктора. file больше подходит для проверки типа (например, при написании isinstance(f, file)).

Новое в версии 2.2.

filter(function, iterable)¶

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

class float([x])¶

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

Если аргумент – строка, она должна содержать, возможно, знаковое десятичное целое или число с плавающей точкой, возможно, окружённое пробелами. Аргументом также может быть [+|-]nan или [+|-]inf. В противном случае аргументом может быть обычное или длинное целое или число с плавающей точкой, и возвращается число с плавающей точкой с тем же значением (в пределах точности Python). Если аргумент не указан, возвращается 0.0.

Примечание

При передаче строки могут возвращаться значения NaN и Infinity в зависимости от используемой библиотеки C. Float принимает строки nan, inf и -inf для NaN и положительной или отрицательной бесконечности. Регистр и ведущий + игнорируются, а для NaN игнорируется также ведущий -. Float всегда представляет NaN и бесконечность как nan, inf или -inf.

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

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

Примечание

format(value, format_spec) просто вызывает value.__format__(format_spec).

Новое в версии 2.6.

class frozenset([iterable])

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

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

Новое в версии 2.4.

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

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

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

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

help([object])¶

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

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

Новое в версии 2.2.

hex(x)¶

Преобразует целое число (любого размера) в шестнадцатеричную строку в нижнем регистре с префиксом «0x», например:

>>> hex(255)
'0xff'
>>> hex(-42)
'-0x2a'
>>> hex(1L)
'0x1L'

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

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

Примечание

Чтобы получить шестнадцатеричное строковое представление числа с плавающей точкой, используйте метод float.hex().

Изменено в версии 2.4: Ранее возвращал только беззнаковый литерал.

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

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

input([prompt])¶

Эквивалентно eval(raw_input(prompt)).

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

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

Рекомендуется использовать функцию raw_input() для общего ввода от пользователей.

class int(x=0)¶

class int(x, base=10)

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

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

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

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

Изменено в версии 2.2: Добавлена поддержка кортежа информации о типах.

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

Изменено в версии 2.3: Добавлена поддержка кортежа информации о типах.

iter(o[, sentinel])¶

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

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

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

Новое в версии 2.2.

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

class list([iterable])

Возвращает список, элементы которого те же и в том же порядке, что и элементы iterable. iterable может быть последовательностью, контейнером, поддерживающим итерацию, или объектом итератора. Если iterable уже является списком, создаётся и возвращается его копия, аналогично iterable[:]. Например, list('abc') возвращает ['a', 'b', 'c'], а list( (1, 2, 3) ) возвращает [1, 2, 3]. Если аргумент не указан, возвращает новый пустой список [].

list – изменяемый тип последовательности, как описано в Типы последовательностей – str, unicode, list, tuple, bytearray, buffer, xrange. Для других контейнеров см. встроенные классы dict, set и tuple, а также модуль collections.

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

Примечание

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

class long(x=0)¶

class long(x, base=10)

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

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

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

max(iterable[, key])¶

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

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

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

Необязательный аргумент key задаёт одноаргументную функцию упорядочивания, подобную используемой для list.sort(). Аргумент key, если указан, должен быть передан в виде ключевого слова (например, max(a,b,c,key=func)).

Изменено в версии 2.5: Добавлена поддержка необязательного аргумента key.

memoryview(obj): Возвращает объект «memory view», созданный из переданного аргумента. Подробнее см. тип memoryview.

min(iterable[, key])¶

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

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

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

Изменено в версии 2.5: Добавлена поддержка необязательного аргумента key.

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

Новое в версии 2.6.

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

Новое в версии 2.2.

Изменено в версии 2.3: Эта функция не принимает никаких аргументов. Ранее она принимала аргументы, но игнорировала их.

oct(x)¶: Преобразует целое число (любого размера) в восьмеричную строку. Результат – корректное выражение Python.

Изменено в версии 2.4: Ранее возвращал только беззнаковый литерал.

open(name[, mode[, buffering]])¶

Открывает файл, возвращая объект типа file, описанного в разделе Файловые объекты. Если файл не удаётся открыть, возбуждается IOError. При открытии файла предпочтительнее использовать open() вместо прямого вызова конструктора file.

Первые два аргумента такие же, как для stdio's fopen(): name – имя открываемого файла, а mode – строка, указывающая, как файл должен быть открыт.

Наиболее часто используемые значения mode: 'r' для чтения, 'w' для записи (с усечением файла, если он уже существует), и 'a' для добавления (что на некоторых системах Unix означает, что все записи добавляются в конец файла независимо от текущей позиции курсора). Если mode опущен, по умолчанию используется 'r'. По умолчанию используется текстовый режим, который может преобразовывать символы '\n' в платформозависимое представление при записи и обратно при чтении. Поэтому при открытии двоичного файла следует добавить 'b' к значению mode, чтобы открыть файл в двоичном режиме, что улучшит переносимость. (Добавление 'b' полезно даже в системах, не различающих двоичные и текстовые файлы, где это служит документацией.) См. ниже дополнительные возможные значения mode.

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

Режимы 'r+', 'w+' и 'a+' открывают файл для обновления (чтения и записи); обратите внимание, что 'w+' усекает файл. Добавьте 'b' к режиму, чтобы открыть файл в двоичном режиме, в системах, различающих двоичные и текстовые файлы; в системах, не имеющих такого различия, добавление 'b' не даёт эффекта.

В дополнение к стандартным значениям fopen(), mode может быть 'U' или 'rU'. Python обычно собирается с поддержкой универсальных символов новой строки; указание 'U' открывает файл как текстовый, но строки могут завершаться любым из следующих символов: соглашение Unix '\n', соглашение Macintosh '\r' или соглашение Windows '\r\n'. Все эти внешние представления воспринимаются программой Python как '\n'. Если Python собран без поддержки универсальных новых строк, режим mode с 'U' эквивалентен обычному текстовому режиму. Обратите внимание, что файловые объекты, открытые таким образом, также имеют атрибут newlines, значение которого может быть None (если новые строки ещё не встречались), '\n', '\r', '\r\n' или кортеж, содержащий все встреченные типы новых строк.

Python требует, чтобы режим, после удаления 'U', начинался с 'r', 'w' или 'a'.

Python предоставляет множество модулей для работы с файлами, включая fileinput, os, os.path, tempfile и shutil.

Изменено в версии 2.5: Введено ограничение на первый символ строки режима.

ord(c)¶: Получая строку длиной в один символ, возвращает целое число, представляющее код Unicode точки символа, если аргумент – объект unicode, или значение байта, если аргумент – 8-битная строка. Например, ord('a') возвращает целое 97, ord(u'\u2020') возвращает 8224. Это обратная операция по отношению к chr() для 8-битных строк и к unichr() для unicode-объектов. Если передан unicode-аргумент и Python был собран с UCS2 Unicode, то кодовая точка символа должна находиться в диапазоне [0..65535] включительно; в противном случае длина строки равна двум, и будет возбуждено TypeError.

pow(x, y[, z])¶

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

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

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

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

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

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

Примечание

Эта функция обычно недоступна как встроенная, поскольку имя print распознаётся как оператор print. Чтобы отключить этот оператор и использовать функцию print(), добавьте следующую инструкцию future в начало модуля:

from __future__ import print_function

Новое в версии 2.6.

class property([fget[, fset[, fdel[, doc]]]])¶

Возвращает атрибут property для классов нового стиля (классов, которые наследуются от object).

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

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

class C(object):
    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 будет строкой документации атрибута property. В противном случае property скопирует строку документации fget (если она существует). Это позволяет легко создавать свойства только для чтения, используя property() в качестве декоратора:

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

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

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

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

class C(object):
    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 в данном случае.)

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

Новое в версии 2.2.

Изменено в версии 2.5: Используется docstring fget, если doc не задан.

Изменено в версии 2.6: Добавлены атрибуты getter, setter и deleter.

range(stop)¶

range(start, stop[, step])

Это универсальная функция для создания списков, содержащих арифметические прогрессии. Чаще всего она используется в циклах for. Аргументы должны быть обычными целыми числами. Если аргумент step опущен, по умолчанию он равен 1. Если аргумент start опущен, по умолчанию он равен 0. Полная форма возвращает список обычных целых чисел [start, start + step, start + 2 * step, ...]. Если step положителен, последний элемент – это наибольшее start + i * step, меньшее stop; если step отрицателен, последний элемент – это наименьшее start + i * step, большее stop. step не должен быть равен нулю (иначе возбуждается ValueError). Пример:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input([prompt])¶

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

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

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

reduce(function, iterable[, initializer])¶

Применяет функцию function от двух аргументов последовательно к элементам iterable слева направо, сводя итерируемый объект к одному значению. Например, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) вычисляет ((((1+2)+3)+4)+5). Левый аргумент x – накопленное значение, а правый аргумент y – очередное значение из iterable. Если передан необязательный initializer, он помещается перед элементами итерируемого объекта в вычислениях и служит значением по умолчанию, когда итерируемый объект пуст. Если initializer не задан, а iterable содержит только один элемент, возвращается первый элемент. Примерная реализация:

def reduce(function, iterable, initializer=None):
    it = iter(iterable)
    if initializer is None:
        try:
            initializer = next(it)
        except StopIteration:
            raise TypeError('reduce() of empty sequence with no initial value')
    accum_value = initializer
    for x in it:
        accum_value = function(accum_value, x)
    return accum_value

reload(module)¶

Перезагружает ранее импортированный модуль module. Аргумент должен быть объектом модуля, то есть он должен быть успешно импортирован ранее. Это полезно, если вы отредактировали исходный файл модуля во внешнем редакторе и хотите опробовать новую версию, не выходя из интерпретатора Python. Возвращаемое значение – объект модуля (тот же, что и аргумент module).

Когда выполняется reload(module):

Код модулей Python перекомпилируется, и код уровня модуля выполняется заново, определяя новый набор объектов, которые привязываются к именам в словаре модуля. Функция init модулей расширения не вызывается второй раз.
Как и в случае со всеми другими объектами в Python, старые объекты освобождаются только после того, как их счётчики ссылок упадут до нуля.
Имена в пространстве имён модуля обновляются, чтобы указывать на любые новые или изменённые объекты.
Другие ссылки на старые объекты (например, имена вне модуля) не перепривязываются для указания на новые объекты и должны быть обновлены в каждом пространстве имён, где они встречаются, если это необходимо.

Существует ряд других предостережений:

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

try:
    cache
except NameError:
    cache = {}

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

Если модуль импортирует объекты из другого модуля с помощью from … import …, вызов reload() для другого модуля не переопределяет импортированные из него объекты – один из способов обойти это – повторно выполнить оператор from, другой – использовать import и полные имена (module.*name*).

Если модуль создаёт экземпляры класса, перезагрузка модуля, определяющего класс, не влияет на определения методов экземпляров – они продолжают использовать старое определение класса. То же самое верно для производных классов.

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

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

Новое в версии 2.4.

Изменено в версии 2.6: Добавлена возможность написания пользовательского метода __reversed__().

round(number[, ndigits])¶: Возвращает значение с плавающей точкой number, округлённое до ndigits знаков после десятичной точки. Если ndigits опущен, по умолчанию он равен нулю. Результат – число с плавающей точкой. Значения округляются до ближайшего кратного 10 в степени минус ndigits; если два кратных одинаково близки, округление производится в сторону от нуля (например, round(0.5) равно 1.0, а round(-0.5) равно -1.0).

Примечание

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

class set([iterable])

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

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

Новое в версии 2.4.

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. Объекты slice имеют атрибуты только для чтения start, stop и step, которые просто возвращают значения аргументов (или значения по умолчанию). Они не имеют другой явной функциональности; однако они используются Numerical Python и другими сторонними расширениями. Объекты slice также создаются при использовании расширенного синтаксиса индексации. Например: a[start:stop:step] или a[start:stop, i]. См. itertools.islice() для альтернативной версии, возвращающей итератор.

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

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

Необязательные аргументы cmp, key и reverse имеют тот же смысл, что и для метода list.sort() (описанного в разделе Mutable Sequence Types).

cmp задаёт пользовательскую функцию сравнения двух аргументов (элементов итерируемого объекта), которая должна возвращать отрицательное, нулевое или положительное число в зависимости от того, считается ли первый аргумент меньше, равным или больше второго: cmp=lambda x,y: cmp(x.lower(), y.lower()). Значение по умолчанию – None.

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

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

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

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

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

Новое в версии 2.4.

staticmethod(function)¶

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

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

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

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

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

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

Дополнительную информацию о статических методах см. в The standard type hierarchy.

Новое в версии 2.2.

Изменено в версии 2.4: Добавлен синтаксис декораторов функций.

class str(object='')¶

Возвращает строку, содержащую аккуратное печатное представление объекта. Для строк возвращается сама строка. Отличие от repr(object) в том, что str(object) не всегда пытается вернуть строку, приемлемую для eval(); его цель – вернуть печатную строку. Если аргумент не указан, возвращается пустая строка ''.

Дополнительную информацию о строках см. в разделе Sequence Types – str, unicode, list, tuple, bytearray, buffer, xrange, который описывает функциональность последовательностей (строки являются последовательностями), а также методы, специфичные для строк, описанные в разделе String Methods. Для вывода форматированных строк используйте строки шаблонов или оператор %, описанный в разделе String Formatting Operations. Кроме того, см. раздел String Services. См. также unicode().

sum(iterable[, start])¶

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

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

Новое в версии 2.3.

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

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

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

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

Примечание

super() работает только для классов нового стиля.

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

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

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

class C(B):
    def method(self, arg):
        super(C, self).method(arg)

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

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

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

Новое в версии 2.2.

tuple([iterable])¶

Возвращает кортеж, элементы которого совпадают и находятся в том же порядке, что и элементы итерируемого объекта. Итерируемый объект может быть последовательностью, контейнером, поддерживающим итерацию, или объектом-итератором. Если итерируемый объект уже является кортежем, он возвращается без изменений. Например, tuple('abc') возвращает ('a', 'b', 'c'), а tuple([1, 2, 3]) возвращает (1, 2, 3). Если аргумент не передан, возвращается новый пустой кортеж, ().

tuple – неизменяемый тип последовательности, как описано в Типы последовательностей – str, unicode, list, tuple, bytearray, buffer, xrange. Для других контейнеров см. встроенные классы dict, list и set, а также модуль collections.

class type(object)¶

class type(name, bases, dict)

С одним аргументом возвращает тип объекта. Возвращаемое значение – объект типа. Для проверки типа объекта рекомендуется встроенная функция isinstance().

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

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

Новое в версии 2.2.

unichr(i)¶: Возвращает строку Unicode из одного символа, код Unicode которого – целое число i. Например, unichr(97) возвращает строку u'a'. Это обратная операция для ord() для строк Unicode. Допустимый диапазон аргумента зависит от конфигурации Python: это может быть UCS2 [0..0xFFFF] или UCS4 [0..0x10FFFF]. В противном случае возбуждается ValueError. Для строк ASCII и 8-битных строк см. chr().

Новое в версии 2.0.

unicode(object='')¶

unicode(object[, encoding[, errors]])

Возвращает строковое представление объекта в Unicode, используя один из следующих режимов:

Если заданы encoding и/или errors, unicode() декодирует объект, который может быть 8-битной строкой или символьным буфером, используя кодек для encoding. Параметр encoding – строка, задающая имя кодировки; если кодировка неизвестна, возбуждается LookupError. Обработка ошибок производится в соответствии с errors; это определяет обработку символов, недопустимых во входной кодировке. Если errors равно 'strict' (по умолчанию), при ошибках возбуждается ValueError, значение 'ignore' вызывает игнорирование ошибок без предупреждения, а значение 'replace' приводит к использованию официального заменяющего символа Unicode, U+FFFD, для замены входных символов, которые не могут быть декодированы. См. также модуль codecs.

Если необязательные параметры не указаны, unicode() имитирует поведение str(), за исключением того, что возвращает строки Unicode вместо 8-битных строк. Точнее, если object – строка Unicode или подкласс, она возвращает эту строку Unicode без дополнительного декодирования.

Для объектов, предоставляющих метод __unicode__(), он вызывает этот метод без аргументов для создания строки Unicode. Для всех остальных объектов запрашивается 8-битная строковая версия или представление, а затем преобразуется в строку Unicode с использованием кодека для кодировки по умолчанию в режиме 'strict'.

Дополнительную информацию о строках Unicode см. в Типы последовательностей – str, unicode, list, tuple, bytearray, buffer, xrange, где описана функциональность последовательностей (строки Unicode являются последовательностями), а также методы, специфичные для строк, описанные в разделе Методы строк. Для форматированного вывода строк используйте строки шаблонов или оператор %, описанный в разделе Операции форматирования строк. Кроме того, см. раздел Службы строк. См. также str().

Новое в версии 2.0.

Изменено в версии 2.2: Добавлена поддержка __unicode__().

vars([object])¶

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

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

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

xrange(stop)¶
xrange(start, stop[, step]): Эта функция очень похожа на range(), но возвращает объект xrange вместо списка. Это непрозрачный тип последовательности, который выдает те же значения, что и соответствующий список, не сохраняя их одновременно. Преимущество xrange() перед range() минимально (поскольку xrange() все равно создает значения при запросе), за исключением случаев, когда используется очень большой диапазон на машине с ограниченной памятью или когда элементы диапазона никогда не используются (например, когда цикл обычно завершается с помощью break). Дополнительную информацию об объектах xrange см. в Тип XRange и Типы последовательностей – str, unicode, list, tuple, bytearray, buffer, xrange.

Особенность реализации CPython: xrange() задуман как простой и быстрый. Реализации могут накладывать ограничения для достижения этой цели. Реализация Python на C ограничивает все аргументы нативными длинными целыми C («короткие» целые Python), а также требует, чтобы количество элементов помещалось в нативное длинное целое C. Если требуется больший диапазон, можно создать альтернативную версию, используя модуль itertools: islice(count(start, step), (stop-start+step-1+2*(step<0))//step).

zip([iterable, ...])¶

Эта функция возвращает список кортежей, где i-й кортеж содержит i-й элемент из каждой из последовательностей или итерируемых объектов-аргументов. Длина возвращаемого списка усекается до длины самой короткой последовательности аргументов. Если несколько аргументов имеют одинаковую длину, zip() аналогичен map() с начальным аргументом None. С одним аргументом-последовательностью она возвращает список 1-кортежей. Без аргументов возвращает пустой список.

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

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

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

Новое в версии 2.0.

Изменено в версии 2.4: Ранее zip() требовал как минимум один аргумент, и zip() возбуждал TypeError вместо возврата пустого списка.

__import__(name[, globals[, locals[, fromlist[, level]]]])¶

Примечание

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

Эта функция вызывается оператором import. Её можно заменить (импортировав модуль __builtin__ и присвоив __builtin__.__import__), чтобы изменить семантику оператора import, но в настоящее время обычно проще использовать перехватчики импорта (см. PEP 302). Прямое использование __import__() встречается редко, за исключением случаев, когда требуется импортировать модуль, имя которого известно только во время выполнения.

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

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

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

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

spam = __import__('spam', globals(), locals(), [], -1)

Оператор import spam.ham приводит к следующему вызову:

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

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

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

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

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

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

Изменено в версии 2.5: Добавлен параметр level.

Изменено в версии 2.5: Добавлена поддержка именованных аргументов для параметров.

3. Необязательные встроенные функции¶Non-essential Built-in Functions

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

Программисты на Python, преподаватели, студенты и авторы книг могут свободно обходить эти функции, не беспокоясь о том, что упустят что-то важное.

apply(function, args[, keywords])¶: Аргумент function должен быть вызываемым объектом (пользовательской или встроенной функцией, методом или объектом класса), а аргумент args должен быть последовательностью. function вызывается с args в качестве списка аргументов; количество аргументов равно длине кортежа. Если присутствует необязательный аргумент keywords, он должен быть словарём, ключами которого являются строки. Он задаёт именованные аргументы, которые будут добавлены в конец списка аргументов. Вызов apply() отличается от простого вызова function(args), поскольку в последнем случае всегда ровно один аргумент. Использование apply() эквивалентно function(*args, **keywords).

Устарело с версии 2.3: Используйте function(*args, **keywords) вместо apply(function, args, keywords) (см. Распаковка списков аргументов).

buffer(object[, offset[, size]])¶: Аргумент object должен быть объектом, поддерживающим буферный интерфейс вызова (например, строки, массивы и буферы). Будет создан новый буферный объект, который ссылается на аргумент object. Буферный объект будет представлять собой срез от начала object (или от указанного offset). Срез будет простираться до конца object (или будет иметь длину, заданную аргументом size).

coerce(x, y)¶: Возвращает кортеж из двух числовых аргументов, приведённых к общему типу, с использованием тех же правил, что и в арифметических операциях. Если приведение невозможно, возбуждает TypeError.

intern(string)¶: Помещает строку в таблицу «интернированных» строк и возвращает интернированную строку – строку (ту же самую или копию). Интернирование строк полезно для небольшого повышения производительности поиска в словаре: если ключи в словаре интернированы и искомый ключ интернирован, сравнение ключей (после хеширования) может выполняться сравнением указателей, а не строк. Обычно имена, используемые в программах Python, автоматически интернируются, и словари, используемые для хранения атрибутов модулей, классов или экземпляров, имеют интернированные ключи.

Изменено в версии 2.3: Интернированные строки больше не являются бессмертными (как это было в Python 2.2 и ранее); для получения преимущества необходимо сохранять ссылку на возвращаемое значение intern().

Сноски

1: Он используется относительно редко, поэтому не стоит делать из него отдельный оператор.
2: Указание размера буфера в настоящее время не действует на системах, не имеющих setvbuf(). Интерфейс для задания размера буфера не реализован с помощью метода, который вызывает setvbuf(), потому что это может привести к дампу ядра при вызове после выполнения любого ввода-вывода, и нет надёжного способа определить, так ли это.
3: В текущей реализации локальные привязки переменных обычно нельзя так изменить, но переменные, полученные из других областей видимости (например, из модулей), можно. Это может измениться.