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

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

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

abs(x)

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

all(iterable)

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

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

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

any(iterable)

Возвращает True, если любой элемент итерируемого объекта истинный. Если итерируемый объект пуст, возвращается 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 не является объектом Python int, он должен определять метод __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, для инициализации массива байтов будет использоваться только для чтения буфер объекта.
• Если это итерируемый объект, он должен быть итерируемым объектом целых чисел в диапазоне 0 <= x < 256, которые используются в качестве начального содержимого массива.

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

Введено в версии 2.6.

callable(object)

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

chr(i)

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

classmethod(function)

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

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

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

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

Метод класса можно вызвать либо на классе (например, 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 управляют тем, какие будущие операторы (см. PEP 236) влияют на компиляцию source. Если ни один из них не присутствует (или оба равны нулю), код компилируется с теми будущими операторами, которые действуют в коде, вызывающем compile(). Если аргумент flags задан, а dont_inherit нет (или равен нулю), то будущие операторы, заданные аргументом flags, используются дополнительно к тем, которые будут использоваться в любом случае. Если dont_inherit — целое число, отличное от нуля, то аргумент flags является им — будущие операторы, действующие вокруг вызова compile, игнорируются.

Будущие операторы задаются битами, которые могут быть побитово сложены вместе для указания нескольких операторов. Поле битов, необходимое для указания данного функционального оператора, можно найти как атрибут 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()   # show the names in the module namespace
['__builtins__', '__doc__', '__name__', 'struct']
>>> dir(struct)   # show the names in the struct module
['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. Если указаны, 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 возвращает true. 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 возвращает false.

class float([x])

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

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

Примечание

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

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

format(value[, format_spec])

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

Примечание

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

Введено в версии 2.6.

class frozenset([iterable])

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

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

Введено в версии 2.4.

getattr(object, name[, default])

Возвращает значение именованного атрибута объекта object. name должно быть строкой. Если строка — имя одного из атрибутов объекта, результатом является значение этого атрибута. Например, getattr(x, 'foobar') эквивалентно x.foobar. Если искомый атрибут не существует, возвращается default, если задан, иначе возникает 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 не объект Python int или long, он должен определить метод __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, как и в коде.

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

isinstance(object, classinfo)

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

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

issubclass(class, classinfo)

Возвращает True, если 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.

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

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

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

next(iterator[, default])

Получает следующий элемент из итератора, вызывая его метод 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: name — имя файла, который нужно открыть, а mode — строка, указывающая способ открытия файла.

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

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

Режимы '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, или значение байта, когда аргумент — строка из 8 бит. Например, ord('a') возвращает целое число 97, а ord(u'\u2020') возвращает 8224. Это обратное преобразование к chr() для строк из 8 бит и к unichr() для объектов unicode. Если задан аргумент unicode, а Python был скомпилирован с поддержкой UCS2, тогда код символа должен находиться в диапазоне [0..65535] включительно; в противном случае длина строки — два, и будет поднято исключение TypeError.

pow(x, y[, z])

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

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

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

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

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

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

Примечание

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

from __future__ import print_function

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

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

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

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

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

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

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

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

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

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

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

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

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

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

Изменено в версии 2.5: Используется строка документации 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 присутствует, он выводится в стандартный вывод без заключительной новой строки. Затем функция считывает строку из ввода, преобразует её в строку (удаляя заключительную новую строку) и возвращает её. Когда считывается конец файла, возбуждается исключение EOFError. Пример:

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

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

reduce(function, iterable[, initializer])

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

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

New in version 2.4.

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

round(number[, ndigits])

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

Примечание

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

class set([iterable])

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

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

New in version 2.4.

setattr(object, name, value)

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

class slice(stop)

class slice(start, stop[, step])

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

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

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

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

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

Примеры сортировки и краткий учебник по сортировке см. в Руководство по сортировке.

New in version 2.4.

staticmethod(function)

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

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

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

Форма @staticmethod — это функция-декоратор — см. Определения функций для получения подробностей.

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

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

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

New in version 2.2.

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

class str(object='')

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

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

sum(iterable[, start])

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

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

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

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

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

Атрибут __mro__ типа перечисляет порядок поиска разрешения методов, используемый как функцией getattr(), так и 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])

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

С одним аргументом возвращает тип объекта object. Возвращаемое значение — объект типа. Для проверки типа объекта рекомендуется использовать встроенную функцию 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 версии object, используя один из следующих режимов:

Если 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() предназначен для простоты и скорости. Реализации могут наложить ограничения для достижения этого. Реализация C Python ограничивает все аргументы коренными C-long («короткими» целыми числами Python), а также требует, чтобы количество элементов поместилось в коренной C-long. Если требуется больший диапазон, можно создать альтернативную версию с использованием модуля 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: Добавлена поддержка ключевых параметров.

Несущественные встроенные функции

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

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

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

Примечания

1

Он используется относительно редко, поэтому не стоит делать его оператором.

2

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

3

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