Перейти на главную страничку сайта (список статей, файлы для скачивания)
Г. Россум, Ф.Л.Дж. Дрейк, Д.С. Откидач, Язык программирования Python
Эта часть книги является справочным руководством, описывающим встроенные возможности языка Python. Здесь описаны синтаксис и семантика различных конструкций языка (выражений, инструкций), встроенные типы данных — в общем то, что обычно рассматривается как "ядро" языка.
Здесь также описаны встроенные функции и исключения — объекты, использование которых не требует предварительного импортирования. Их имена содержатся в отдельном пространстве имен, поиск в котором происходит в последнюю очередь. Таким образом, пользователь может переопределять их в локальном или глобальном пространстве имен.
В настоящей главе описаны синтаксис и семантика различных конструкций языка Python. Формальное определение грамматики приведено в приложении B.
Программа на языке Python состоит из логических строк. Инструкции не могут быть разделены на несколько логических строк, за исключением составных инструкций. Логическая строка составляется из одной или нескольких физических строк, следуя правилам явного или подразумеваемого объединения строк. Отступ в физической строке, являющейся продолжением логической строки, не имеет значения.
Физическая строка заканчивается символом конца строки, принятым для данной платформы: ASCII символ LF для UNIX, последовательность CR LF для DOS и Windows, CR для Macintosh.
Комментарий начинается символом '#', не являющимся частью строкового литерала, и заканчивается в конце физической строки. Комментарии лексическим анализатором игнорируются.
Две или более физических строки могут быть объединены в логическую строку явно с помощью символа обратной косой черты ('\'): если физическая строка заканчивается символом обратной косой черты, который не является частью строкового литерала или комментария, она объединяется со следующей физической строкой, образуя одну логическую строку. Например:
if 1900 < year < 2100 and 1 <= month <= 12 \
and 1 <= day <= 31 and 0 <= hour < 24 \
and 0 <= minute < 60 and 0 <= second < 60:
# Похоже на правильную дату
return 1
Строка, заканчивающаяся символом обратной косой черты, не может содержать комментария. Лексемы не могут быть разделены на несколько строк, за исключением строковых литералов. Использование символа обратной косой черты в любом другом месте, кроме как в конце строки, в строковом литерале и в комментарии, не допускается.
Выражения в обратных кавычках и скобках (круглых, квадратных, фигурных) могут быть разделены на несколько физических строк без использования символа обратной косой черты, например:
month_names = ['Январь', 'февраль', # Названия
'Март', 'Апрель', # месяцев года
'Май', 'Июнь', # по-русски
'Июль', 'Август',
'Сентябрь', 'Октябрь',
'Ноябрь', 'Декабрь']
Такие физические строки, объединяемые в одну логическую строку по правилам подразумеваемого объединения, могут содержать комментарии. Строковые литералы, записанные с использованием трех кавычек, также могут быть разделены на несколько физических строк, которые, однако, не могут содержать комментарии.
Логические строки, содержащие только символы пропуска (whitespace) и, возможно, комментарий, игнорируются. В интерактивном режиме пустая строка (без символов пропуска и комментариев) используется для обозначения конца составной инструкции.
Символы пробела и табуляции в начале логических строк используются для определения уровня отступа строки. Уровень отступа строк используется для объединения инструкций в группы.
Сначала каждый символ табуляции (слева направо) заменяется на от одного до восьми пробелов таким образом, чтобы общее количество символов до этого места, включая замененные символы, было кратным восьми. Затем общее количество пробелов в начале логической строки используется для определения уровня отступа. Отступ не может быть разделен на несколько физических строк: для определения уровня отступа будут использованы символы пропуска до первого символа обратной косой черты. Только логические строки, имеющие одинаковое количество пробелов (после преобразования символов табуляции) в начале строки, считаются имеющими одинаковый уровень отступа.
Приведенный ниже пример имеет правильные, хотя и сбивающие с толку, отступы:
def perm(l):
# Создает список всех возможных перестановок в l
if len(l) <= 1:
return [l]
r = []
for i in range(len(l)):
s = l[:i] + l[i+1:]
p = perm(s)
for x in p:
r.append(l[i:i+1] + x)
return r
А следующий пример показывает возможные ошибки в отступах:
# ошибка: отступ в первой строке
def perm(l):
# ошибка: нет отступа
for i in range(len(l)):
s = l[:i] + l[i+1:]
# ошибка: неожиданный отступ
p = perm(l[:i] + l[i+1:])
for x in p:
r.append(l[i:i+1] + x)
# ошибка: при уменьшении отступа должна существовать
# строка с точно таким же отступом
return r
Общепринято добавлять четыре пробела для каждого следующего уровня отступа. Использование символов табуляции не желательно, так как их интерпретация зависит от используемого редактора и его настроек. Большинство редакторов позволяют настроить автоматическую поддержку отступов. Если Вы работаете с редактором vim, достаточно добавить строчку 'autocmd FileType python set softtabstop=4 shiftwidth=4 expandtab autoindent' в конфигурационный файл редактора '.vimrc' ('_vimrc' под Windows).
Символ подачи страницы (FF) может присутствовать в начале строки и игнорируется при определении отступа. В других местах отступа символ подачи страницы может давать неопределенный эффект (например, обнулить счетчик пробелов).
За исключением начала логической строки и строковых литералов, символы пробела, табуляции и подачи страницы могут быть взаимозаменяемо использованы для разделения лексем.
Выражения состоят из атомов ("неделимых" частей), объединенных различными операторами. Описание операторов разделено на несколько подразделов, расположенных в порядке убывания приоритета описанных в них операторов (в конце этого раздела приведена сводная таблица приоритетов). Перед применением бинарных операторов операнды приводятся к общему типу по правилам, описанным в разделе 11.6.3. Назначение большинства операторов зависит от типа операндов и описано в соответствующих разделах главы 11.
Идентификаторы
Идентификаторы являются ссылками на локальные, глобальные или встроенные имена. Если к идентификатору привязан объект в текущем блоке кода и в этом блоке не было явно указано с помощью инструкции global, что имя является глобальным, то идентификатор ссылается на локальное имя для этого блока. Если идентификатору в текущем блоке кода не был привязан объект, идентификатор ссылается на глобальное (если оно существует) или встроенное имя. Если же идентификатор явно указан в инструкции global в текущем блоке кода, то он всегда ссылается на глобальное имя.
Если к идентификатору привязан объект, его вычисление как атома в выражении дает этот объект. При попытке использования в выражении имени, не привязанного к объекту, будет сгенерировано исключение NameError.
Идентификаторы (имена) должны начинаться с буквы латинского алфавита или символа подчеркивания и содержать только буквы латинского алфавита, цифры и символы подчеркивания. Интерпретатор языка Python различает регистры букв: идентификаторы, например, spam и Spam считаются разными. Длина идентификаторов не ограничена.
Следующие идентификаторы являются зарезервированными (или ключевыми) словами языка и не могут быть использованы как обычные имена:
and del for is raise assert elif from lambda return break else global not try class except if or while continue exec import pass def finally in print
Помимо ключевых слов, некоторые идентификаторы имеют специальное значение (символ '*' обозначает "любое количество любых допустимых символов"; имена относятся к следующему классу, только если они не относятся к предыдущему):
__*__
Системные имена (особых модулей, специальных атрибутов и методов).
__*
(только в определении класса)
Если идентификатор такого вида встречается в определении класса, то он считается частным атрибутом класса и подвергается специальному преобразованию. Например, имя '__spam', определенное в классе с именем 'Ham', преобразуется к '_Ham_spam'. Преобразование производится независимо от контекста, в котором идентификатор используется. Если имя класса состоит только из символов подчеркивания, преобразование не производится.
_*
Частные объекты модуля, не импортируются инструкцией 'from module import *'. В интерактивном режиме идентификатор с именем '_' используется для хранения результата вычисления последней инструкции-выражения, сохраняется в пространстве встроенных имен. Не в интерактивном режиме имя '_' не имеет специального значения (часто используется для выбора сообщений в соответствии с текущими национальными установками).
Литеральные выражения
Литеральные выражения являются записью значений некоторых встроенных типов: чисел различного типа (см. раздел 11.1), обычных строк (раздел 11.2.1) и строк Unicode (раздел 11.2.2).
"Замкнутые" выражения
Формы, заключенные в обратные кавычки и различные скобки также распознаются синтаксическим анализатором как атомы.
Круглые скобки представляют содержащееся в нем выражение и используются для контроля порядка вычисления. Обратите внимание, что кортеж (см. раздел 11.2.3) образуется не с помощью круглых скобок, а путем перечисления выражений через запятую. Скобки необходимы только для образования пустого кортежа, а также в тех случаях, когда перечисление через запятую используется синтаксисом для других целей (список аргументов функции или инструкции).
Квадратные и фигурные скобки используются для представления списков и словарей соответственно (см. разделы 11.2.6 и 11.3).
Обратные кавычки используются для получения строкового представления объекта, являющегося результатом вычисления заключенного в них выражения. Тот же результат Вы можете получить, используя встроенную функцию repr(). Смотрите также описание функции repr() (раздел 12) и специального метода __repr__() (раздел 11.6.3).
Первичное выражение может быть атомом или выражением, представляющим применение к первичному выражению (primary) следующих операций, имеющих наибольший приоритет:
primary.attr
Операция получения атрибута. Первичное выражение primary должно представлять объект, поддерживающий доступ к атрибутам. Если атрибут attr объекта primary не доступен, генерируется исключение AttributeError.
primary[key]
Операция получения элемента по индексу/ключу, характерная для последовательностей и отображений (см. разделы 11.2 и 11.3).
primary[slice_list]
Операция получения подпоследовательности по срезу. Последовательности встроенного типа поддерживают лишь простую запись среза (slice_list) в виде '[start]:[stop]' (где start — нижняя и stop — верхняя границы). Расширенная запись (используется, например, в модулях расширения Numerical Python) позволяет указать через запятую несколько срезов вида '[start]:[stop][:[step]]' (step — шаг) или использовать троеточие ('...'). Например: 'x[1:10:2]', 'x[:10, ...]', 'x[5:, ::2]'. Расширенная запись среза представляется с помощью специальных объектов slice и ellipsis, описанных в разделе 11.8.3.
primary(arg_list)
Операция вызова. Встроенные типы, поддерживающие вызов, перечислены в разделе 11.4. arg_list — список (через запятую) аргументов, которые могут быть переданы следующими способами (Вы можете использовать сразу несколько способов, однако порядок их следования в списке аргументов должен быть таким, в котором они здесь перечислены (exprN — произвольные выражения):
>>> def print_vector(s, (x, y, z)):
>>> print s+':'
>>> print 'x =', x
>>> print 'y =', y
>>> print 'z =', z
...
>>> velocity = 0.0, 1.0, 1.0
>>> print_vector('Вектор скорости', velocity)
Вектор скорости:
x = 0.0
y = 1.0
z = 1.0
Операция вызова всегда возвращает значение (возможно None), если выполнение не было прервано (например, сгенерировано исключение).
Ниже приведены все арифметические и битовые операторы в порядке уменьшения их приоритета. Операторы с одинаковым приоритетом объединены в группы.
x ** y
Оператор возведения в степень имеет больший приоритет, чем унарный арифметический или битовый оператор слева, но меньший, чем унарный арифметический или битовый оператор справа (во избежание нелепых ошибок использование оператора not справа от любого арифметического или битового оператора не допускается). Так, например, выражение '-x ** -y' будет вычисляться справа налево, то есть эквивалентно выражению '-(x ** (-y))'.
+x, -x, ~x
x * y, x / y, x%y
x + y, x - y
x << y, x >> y
x & y
x ^ y
x | y
Все условные операторы (операторы сравнения, проверки идентичности и вхождения) имеют одинаковый приоритет (больший, чем у логических операторов). Кроме того, условные операторы могут быть записаны в цепь, например, выражение 'x < y <= z' интерпретируется так же, как это принято в математике, и эквивалентно 'x < y and y <= z', за исключением того, что y вычисляется только один раз (но в обоих случаях z не вычисляется, если выражение 'x < y' ложно).
Заметим, что конструкции типа 'a < b > c' вполне допустимы, однако выглядят довольно неприятно (сравнение между a и c не производится). Операторы != и <> полностью эквивалентны, использование первого предпочтительнее.
Сравнение
x < y
1, если x меньше y, иначе 0.
x <= y
1, если x меньше или равен y, иначе 0.
x > y
1, если x больше y, иначе 0.
x >= y
1, если x больше или равен y, иначе 0.
x == y
1, если x равен y, иначе 0.
x <> y
x != y
0, если x равен y, иначе 1. <> и != — две альтернативные формы записи одного оператора, вторая форма предпочтительнее.
Операторы сравнения работают со всеми типами данных. Вы можете сравнивать объекты разного типа. Переменные численных типов равны, если равны их значения. Если Вы сравниваете обычную строку и строку Unicode, к обычной строке сначала применяется встроенная функция unicode() (считается, что строка имеет кодировку ASCII, если обычная строка содержит символы с кодом больше 127, генерируется исключение UnicodeError). Для экземпляров классов может быть определен специальный метод __cmp__() (иногда также будет полезен метод __rcmp__(), см. раздел 11.6.3), который будет использоваться для реализации операторов <, <=, >, >=, ==, != (<>), в том числе, и с объектами других типов (следует помнить, что перед выполнением операций сравнения производится попытка привести операнды к общему типу). Во всех остальных случаях производится проверка идентичности: объекты равны, только если они являются одним и тем же объектом. Порядок следования при сортировке объектов, для которых не определена операция сравнения, определяется типом объектов и их идентификаторами [Возможны ситуации, при которых obj1 < obj2 и obj2 < obj3, но obj1 > obj3, например, если один из объектов является экземпляром, для которого не определен метод __cmp__().].
Идентичность
Операторы is и is not проверяют идентичность объектов: являются ли операнды на самом деле одним и тем же объектом (сравниваются идентификаторы объектов; см. также описание функции id() в разделе 12).
x is y
1, если x и y ссылаются на один и тот же объект, иначе 0.
x is not y
0, если x и y ссылаются на один и тот же объект, иначе 1.
Вхождение
Еще два условных оператора — in и not in — предназначены для определения, является ли объект элементом последовательности (или любого другого контейнера) и подробно описаны в разделе 11.2.
x in y
1, если y содержит элемент, который при сравнении (оператор ==) оказывается равным x, иначе 0.
x not in y
1, если y не содержит элемента равного x, иначе 0.
Для любого объекта можно проверить его истинность при использовании в инструкциях if и while или в качестве операнда логических операторов, описанных ниже. Следующие значения считаются ложью:
Все остальные значения считаются истинными — так что многие объекты всегда истинны.
Ниже приведены логические операторы в порядке уменьшения приоритета. Заметим, что оператор not имеет меньший приоритет, чем арифметические и условные операторы. То есть 'not a == b' интерпретируется как 'not (a == b)', а выражение 'a == not b' является синтаксической ошибкой.
Операторы or и and всегда возвращают один из своих операндов. Причем второй операнд операторов or и and вычисляется, только если это необходимо для получения результата.
not x
Если x ложно, то 1, иначе 0.
x and y
Если x ложно, то x, иначе y.
x or y
Если x ложно, то y, иначе x.
lambda param_list: expression
Короткая форма создания (безымянной) функции, возвращающей значение выражения expression. Ее поведение аналогично поведению функции, созданной с помощью инструкции 'def name(param_list): return expression'. Синтаксис списка параметров описан в разделе 10.4.5.
Обратите внимание, что функция, создаваемая с помощью оператора lambda, не может содержать инструкций. Кроме того, lambda-функция (как и функция, определенная с помощью инструкции def) не имеет доступа к локальному пространству имен блока, в котором она определена. Однако Вы можете обойти это ограничение, используя аргументы, имеющие значения по умолчанию, например:
def make_incrementor(increment):
return lambda x, n=increment: x+n
lambda имеет наименьший приоритет среди операторов, однако его приоритет больше чем у конструкции, образующей список выражений. Так, например, выражение 'lambda: 1, 2' эквивалентно выражению '(lambda: 1), 2' и образует кортеж из двух элементов: функции, возвращающей 1, и числа 2.
Список выражений (аргументов) образуется путем перечисления выражений (идентификаторов) через запятую. Списки аргументов функции и выражений, образующий кортеж, может содержать завершающую запятую, однако она не имеет никакого значения, за исключением одного случая: завершающая запятая необходима для образования кортежа, содержащего один элемент (см. раздел 11.2.3). Использование завершающей запятой в списке аргументов инструкций, кроме инструкции print, не допускается. Завершающая запятая в списке аргументов инструкции print указывает на то, что не нужно выводить символ перехода на новую строку (см. раздел 10.3.5).
Ниже перечислены все конструкции и операторы, которые могут быть использованы для создания выражений, в порядке уменьшения приоритета. Конструкции, перечисленные в одном пункте, имеют одинаковый приоритет.
Простые инструкции записываются в одну логическую строку. Логическая строка может содержать несколько простых инструкций разделенных точкой с запятой.
Инструкции-выражения обычно используются для вычисления и вывода значения выражения (в интерактивном режиме) или для вызова "процедур" — функций, возвращающих незначимый результат (None) и состоят из одного выражения (список выражений также является выражением).
В интерактивном режиме значение выражения, если оно не равно None, преобразуется в строку аналогично тому, как это делает встроенная функция repr() и выводится на стандартный поток вывода. Значение None не выводится — таким образом вызов процедур не дает никакого вывода.
Присваивание ('lvalue = expression') используется для того, чтобы связать идентификатор (существующий или новый) с объектом, для создания и изменения атрибутов объектов, изменения элементов изменяемых последовательностей, добавления и изменения записей в отображениях. Присваивание может производиться (выражения, которые могут быть использованы слева от знака равенства, обычно называют lvalue):
name = expression
Идентификатору.
x.attribute = expression
Атрибуту. Обычно имя attribute в пространстве имен объекта x связывается с объектом, являющимся результатом вычисления выражения expression. Вы можете контролировать поведение при присваивании атрибуту экземпляра класса, определив для класса специальный метод __setattr__().
x[key] = expression
Элементу последовательности или отображения. Изменение элементов экземпляров классов реализуется специальным методом __setitem__().
x[slice_list] = expression
Подпоследовательности (синтаксис списка срезов slice_list описан в разделе 10.2.2). Выражение expression должно быть последовательностью. Присваивание срезу экземпляра контролируется с помощью специального метода __setslice__() (если используется простая запись среза) или __setitem__() (если используется расширенная запись срезов).
lvalue, . . . = expression
(lvalue, . . . ) = expression
[lvalue, . . . ] = expression
Конструкции, используемой для создания кортежей и списков (в том числе, произвольным образом вложенных) из всех перечисленных выражений. Операция присваивания выполняется путем распаковки последовательностей. Результат вычисления выражения expression должен быть последовательностью, содержащей такое же количество элементов, какое указано слева от знака равенства. Каждому вложенному списку слева в результате должна соответствовать подпоследовательность с таким же количеством элементов. При несоответствии количества элементов генерируется исключение ValueError. Приведем несколько примеров:
>>> x = range(1)
>>> y, = range(1)
>>> print x, y
[0] 0
>>> class c:
... def __init__(self, val):
... self.val = val
... def __repr__(self):
... return 'c('+`self.val`+')'
...
>>> o = c(1)
>>> l = range(3)
>>> l[1], [(x, y), o.val] = [10, (xrange(2, 4), 5)]
>>> print x, y, l, o
2 3 [0, 10, 2] c(5)
Значение выражения справа от = (включая упаковку) вычисляется до того, как начинается присваивание. Таким образом, инструкция 'a, b = b, a' обменивает значения переменных a и b. Однако следующий пример выведет '[0, 2]':
x = [0, 1] i = 0 i, x[i] = 1, 2 print x
Начиная с версии 2.0, возможно одновременное выполнение арифметической или битовой операции и присваивания:
lvalue += expression lvalue -= expression lvalue *= expression lvalue /= expression lvalue %= expression lvalue **= expression lvalue &= expression lvalue |= expression lvalue ^= expression lvalue >>= expression lvalue <<= expression
Если lvalue является неизменяемым объектом, инструкция 'lvalue op=expression' всегда эквивалентна последовательному применению оператора и присваиванию результата (нового объекта) lvalue ('lvalue = lvalue op expression'). Здесь, в отличие от обычного присваивания, lvalue не может быть кортежем.
Заметим, что формально присваивание в языке Python не является оператором, то есть, не возвращает значения и не может быть использовано в выражениях. Так сделано, например, чтобы избежать ошибочного использования = вместо == в инструкции if.
Семантика инструкции 'del lvalue' во многом схожа с семантикой присваивания (синтаксис lvalue описан в разделе 10.3.2). Удаление идентификатора удаляет привязку имени (которое должно существовать) в локальном или глобальном пространстве имен (см. раздел 10.5) к объекту. При удалении атрибута обычно удаляется соответствующее имя из пространства имен объекта. Вы можете контролировать поведение при удалении атрибутов экземпляров, определив для класса специальный метод __delattr__(). Удаление элементов (записей) из экземпляров-последовательностей (экземпляров-отображений) реализуется специальным методом __delitem__(), подпоследовательности — специальным методом __delslice__() (если используется простая запись среза) или __delitem__() (при использовании расширенной записи срезов).
Инструкция pass ничего не делает и может быть полезна там, где инструкция требуется синтаксисом, однако нет необходимости в выполнении каких либо действий, например:
# функция, которая ничего не делает def do_nothing(arg): pass # пустой класс class record: pass
Инструкция 'print [expr_list]' для каждого выражения в списке выражений expr_list вычисляет его значение и выводит строковое представление значения выражения на стандартный поток вывода, разделяя их пробелами (необходимость вывода пробела контролируется атрибутом softspace файлового объекта). Строковое представление получается аналогично тому, как это делает встроенная функция str() (см. раздел 12).
Если список выражений не заканчивается запятой, в конце выводится символ перехода на новую строку. Это единственное действие, которое выполняется, если инструкция содержит только ключевое слово print.
В качестве стандартного потока вывода используется файловый объект, на который ссылается переменная stdout в модуле sys. Если имя sys.stdout было удалено, генерируется исключение RuntimeError.
Начиная с версии 2.0, инструкция print может быть использована для вывода в любой файл. Для этого после ключевого слова print необходимо поставить >> и первое выражение в списке expr_list должно давать файловый объект или None (в этом случае для вывода будет использоваться sys.stdout). Например:
print >> sys.stderr, 'Ошибочка вышла!'
Инструкция print предъявляет следующие требования к файловому объекту, в который производится вывод: объект должен иметь метод write() и доступный для записи атрибут softspace (последнее всегда верно для экземпляров классов, не имеющих специальных методов __getattr__() и __setattr__()).
Инструкция break может быть использована только (синтаксически) внутри циклов for и while, но не в определении функции или класса, находящегося в цикле. Прерывает выполнение самого вложенного цикла (пропуская ветвь else цикла, если она присутствует). При прерывании цикла for переменная (или переменные), в которой хранится значение текущего элемента, остается неизменной.
Если для выхода из цикла необходимо покинуть блок инструкции try с ветвью finally, перед выходом выполняется ветвь finally.
Инструкция continue может быть использована только (синтаксически) внутри циклов for и while, но не в определении функции или класса, находящегося в цикле. В текущих версиях инструкция continue также не может быть использована внутри основного блока инструкции try (расположенного синтаксически внутри цикла) — только в ветвях except и else [Это ограничение, возможно, будет снято в будущих версиях языка.]. Инструкция продолжает выполнение наиболее вложенного цикла со следующего прохода.
Инструкция 'return [expression]' (может быть использована синтаксически только в определении функции) прерывает выполнение функции (при ее вызове) используя значение выражения expression (None, если выражение опущено) в качестве возвращаемого функцией значения.
Если для возврата из функции необходимо покинуть блок инструкции try с ветвью finally, перед возвратом выполняется ветвь finally.
Инструкция 'global identifier_list' указывает на то, что идентификаторы identifier_list (список через запятую идентификаторов) во всем текущем блоке ссылаются на глобальные переменные. В то время как использование в выражениях глобальных имен производится автоматически, если они не определены (нигде в текущем блоке) в локальном пространстве имен, присваивание глобальным именам без использования инструкции global невозможно.
Если имена где-либо в данном блоке кода указаны в инструкции global, их следует использовать только после этой инструкции. Такие имена не должны использоваться как формальные параметры циклов for, определений классов и функций и не должны быть среди имен, импортируемых инструкцией import. В текущих версиях инструкции for, class и def изменяют глобальную переменную, а инструкция import не импортирует такие имена, однако в будущих версиях поведение может измениться.
Инструкция global является директивой синтаксическому анализатору команд и применяется только к единовременно компилируемому блоку кода. В частности, инструкция global, содержащаяся в инструкции exec не оказывает влияния на блок кода, в котором содержится эта инструкция exec. И наоборот, инструкция global в блоке кода, содержащем также инструкцию exec, не оказывает влияние на код в этой инструкции exec. То же самое верно и для встроенных функций eval(), execfile() и compile().
Существует три формы записи инструкции import:
import module_list
Импортирует указанные модули. module_list — список через запятую полных имен модулей (если модуль находится в пакете - используется запись через точку, например, пакет.подпакет.модуль) с возможным указанием имен, к которым будут привязаны объекты-модули в локальном пространстве имен (см. ниже).
from module import obj_list
Импортирует объекты из модуля module. obj_list — список через запятую идентификаторов объектов (идентификатор объекта может ссылаться, в том числе, и на объект-модуль, но, в отличие от имени модуля, не может использовать запись через точку) с возможным указанием имен, к которым будут привязаны объекты в локальном пространстве имен (см. ниже).
from module import *
Импортирует все имена из модуля module, кроме имен, начинающихся с символа подчеркивания.
Инструкция import выполняется в два этапа:
Начиная с версии 2.0, Вы имеете возможность указать имя, к которому будет привязан объект в локальном пространстве имен, используя запись 'object as local_name' в списке модулей (module_list) или объектов (obj_list). Так, например, инструкция 'import operator' привязывает импортированный объект-модуль к локальному имени operator, в то время как 'import operator as op' привязывает тот же объект-модуль к локальному имени op. Во избежание недоразумений не допускается импортирование под другим именем объектов, для которых используется точечная запись: вместо 'import xml.sax as s' необходимо использовать запись 'from xml import sax as s'.
Под инициализацией модуля, реализованного на языке Python, подразумевается создание пустого объекта-модуля, добавление его в таблицу sys.modules и выполнение в контексте этого модуля инструкций из файла 'module.py' (или '__init__.py' в каталоге 'module', если модуль является пакетом). Точнее, выполняется его байт-компилированная версия — файл 'module.pyc' или 'module.pyo' в зависимости от того, используется оптимизация или нет. Если соответствующий байт-компилированный файл отсутствует или не соответствует исходному '.py'-файлу, интерпретатор компилирует исходный файл (если он содержит синтаксические ошибки, генерируется исключение SyntaxError и объект-модуль в sys.modules не добавляется), пытается записать байт-компилированную версию и выполняет его (независимо от успешности записи байт-компилированной версии). Не перехваченные исключения во время инициализации прерывают процесс импортирования модуля. Однако частично инициализированный модуль остается в таблице sys.modules. Инициализация динамически подгружаемого или встроенного в интерпретатор модуля выполняется путем вызова функции initmodule.
Система запоминает модули, которые были инициализированы в словаре (индексированном именами модулей) sys.modules. При импортировании, если имя модуля найдено в sys.modules, его инициализация пропускается. Если Вы хотите заново инициализировать модуль (например, чтобы не покидать интерпретатор после каждого внесения изменений в модуль при отладке), воспользуйтесь встроенной функцией reload().
Поиск модулей производится сначала среди встроенных в интерпретатор, затем в путях, хранящихся в списке sys.path. sys.path при запуске интерпретатора содержит текущий каталог, список каталогов из переменной окружения PYTHONPATH и зависящие от платформы пути по умолчанию. Если модуль с указанным именем не найден, генерируется исключение ImportError.
Импортируемые имена не должны использоваться в инструкции global в той же области видимости. В текущих реализациях такие имена просто не будут импортированы, однако в будущих версиях поведение может измениться.
Запись 'from ... import *' рекомендуется использовать только в глобальной области видимости.
Вы можете изменить поведение инструкции import, переопределив встроенную функцию __import__(). При этом будут полезны средства, определенные в модуле imp.
Инструкция 'exec expression [in globals, [locals]]' предназначена для динамического выполнения кода. Выражение expression должно давать объект типа code, string или file (открытый для чтения). Если expression является объектом кода, инструкция exec просто выполняет его. Строка или файл считаются содержащими инструкции языка Python, которые должны быть выполнены (если не содержат синтаксических ошибок).
Выражения globals и locals должны давать словари, которые будут использованы как глобальное и локальное пространства имен. Если аргументы опущены, код выполняется в текущей области видимости. Если указан только аргумент globals, он используется в качестве глобального и локального пространств имен. В текущих реализациях в эти словари автоматически добавляется запись (если такой нет) с ключом '__builtins__', ссылающаяся на словарь пространства встроенных имен (то есть, модуля __builtin__).
Динамическое вычисление выражений осуществляется с помощью встроенной функции eval(). Также могут быть полезны встроенные функции globals() и locals(), которые возвращают словари, соответствующие текущим глобальному и локальному пространствам имен.
В текущих реализациях многострочные составные инструкции должны заканчиваться переходом на новую строку. Так, "exec 'for i in (1,2):\n\tprint i\n'" будет работать нормально, но при попытке выполнить "exec 'for i in (1,2):\n\tprint i'" будет сгенерировано исключение SyntaxError.
Общепринятый способ включения в программу отладочных утверждений — инструкция 'assert expression [, exc_arg]'. Если выражение expression ложно, генерируется исключение AssertionError. Если задан необязательный второй аргумент exc_arg, то он используется в качестве аргумента, передаваемого конструктору исключения. При компиляции с оптимизацией инструкции assert игнорируются.
Простая форма 'assert expression' эквивалентна конструкции (предполагается, что идентификаторы __debug__ и AssertionError ссылаются на встроенные переменные с такими именами; встроенная переменная __debug__ равна 1 при отключенной оптимизации)
if __debug__:
if not expression: raise AssertionError()
Расширенная форма 'assert expression, exc_arg' эквивалентна конструкции
if __debug__:
if not expression: raise AssertionError(exc_arg)
В качестве аргумента exc_arg можно, например, использовать строку, поясняющую возможную причину невыполнения утверждения. Заметим, что нет необходимости включать в нее исходный текст выражения expression, так как он в любом случае будет включен в выводимую (если исключение не перехвачено) отладочную информацию.
Инструкцию 'raise [expr1 [, expr2 [, expr3]]]' следует использовать в случае возникновения ошибок и других исключительных ситуаций. Без аргументов инструкция raise повторно генерирует последнее исключение, сгенерированное в текущей области видимости.
Иначе вычисляется значение выражения expr1, которое должно быть строкой, классом или экземпляром класса. Если задан второй аргумент (выражение expr2), вычисляется его значение, в противном случае подставляется None. Если первый аргумент является объектом-классом и второй аргумент является экземпляром этого или производного от него класса, expr2 используется в качестве генерируемого исключения. Если же второй аргумент не является таким экземпляром, он используется для инициализации класса expr1 следующим образом: если выражение expr2 является кортежем, то оно используется в качестве списка аргументов; если expr2 равно None, класс инициализируется с пустым списком аргументов; в остальных случаях expr2 используется как единственный аргумент при инициализации. Если же первый аргумент инструкции raise является экземпляром класса, он используется в качестве исключения (второй аргумент должен быть равен None или опущен).
Поддержка строк в качестве исключений существует лишь для совместимости со старыми версиями и может быть удалена в будущих версиях языка. И, тем не менее, если первый аргумент является строкой, он используется в качестве исключения. В этом случае второй аргумент (или None) является ассоциированным с исключением значением.
Третий аргумент, если задан и не равен None, должен быть объектом traceback (см. раздел 11.9.3). В этом случае он используется вместо объекта, создаваемого для текущего положения, для указания на место возникновения исключительной ситуации.
Составные инструкции содержат другие инструкции и каким-либо образом управляют их выполнением. Обычно составные инструкции записываются в несколько логических строк с использованием отступов, хотя, если составная инструкция имеет только одну ветвь, тело которой содержит только простые инструкции, она может быть записаны в одну логическую строку.
Инструкции if, while и for реализуют традиционные средства управления логикой программы. Инструкция try устанавливает обработчик исключений. Определения функций и классов также являются составными инструкциями.
Составная инструкция состоит из одной или нескольких ветвей. Каждая ветвь состоит из заголовка и тела. Заголовки ветвей одной составной инструкции должны иметь одинаковый уровень отступа. Заголовок каждой ветви начинаются уникальным ключевым словом и заканчиваются двоеточием. Тело является набором инструкций, управляемых данной ветвью. Тело может содержать одну или несколько разделенных точкой с запятой простых инструкций, записанных в одной логической строке с заголовком (сразу после двоеточия), или одну или несколько произвольных инструкций на непосредственно следующих за заголовком стоках, имеющих по сравнению с заголовком дополнительный отступ. Только вторая форма записи тела ветви может содержать составные инструкции. Следующий пример является недопустимым, в первую очередь потому, что не очевидно, к какой из инструкций if должна была бы относиться ветвь else:
if test1: if test2: print x
Логическая строка не может содержать несколько инструкций, если хотя бы одна из них является составной. В следующем примере все инструкции print входят в тело основной ветви инструкции if:
if x < y < z: print x; print y; print z
Обратите внимание, что каждая ветвь любой составной инструкции всегда заканчиваются переходом на новую строку. Кроме того, во избежание неоднозначностей, дополнительные ветви всегда начинаются с ключевого слова, которое никогда не используется в начале инструкций. Характерная для таких языков, как C, проблема отнесения ветви else решается в языке Python требованием правильного использования отступов во вложенных составных инструкциях.
Инструкция if используется для выполнения различных действий в зависимости от условий:
if expr1: suite1 [elif expr2: suite2...] [else: suite0]
Инструкция if вычисляет одно за другим выражения exprN в основной ветви и необязательных ветвях elif до тех пор, пока не будет получена истина, и выполняет соответствующий ему блок кода (вся оставшаяся часть инструкции if пропускается). Если все выражения дают ложь, выполняется блок кода suite0 необязательной ветви else.
Цикл while используется для многократного выполнения действий, пока выполняется условие:
while expr: suite1 [else: suite2]
Инструкция while выполняется в следующем порядке:
Инструкция for используется для перебора элементов последовательности:
for lvalue in sequence: suite1 [else: suite2]
Выражение sequence вычисляется один раз и должно давать последовательность (объект, для которого определена операция получения элемента по индексу; если индекс выходит за пределы диапазона, должно генерироваться исключение IndexError). Для каждого элемента последовательности sequence в порядке возрастания индексов, начиная с 0, выполняется присваивание lvalue элемента (на элемент item и параметр lvalue распространяются обычные правила, действующие при выполнении инструкции присваивания `lvalue = item’; см. раздел 10.3.2) и выполняется блок кода suite1. После того как последовательность исчерпана (определяется по сгенерированному исключению IndexError), если присутствует ветвь else, выполняется блок suite2.
Выполнение инструкции break в блоке suite1 немедленно прерывает выполнение цикла (ветвь else игнорируется). При выполнении инструкции continue в блоке suite1 пропускается остаток блока и выполнение цикла продолжается после присваивания lvalue следующего элемента последовательности sequence или выполняется ветвь else, если в последовательности нет следующего элемента.
Вы можете присваивать переменной или переменным, входящим в lvalue, — это никак не отразится на следующем элементе, который будет присвоен lvalue. Переменные, входящие в lvalue не удаляются после окончания выполнения цикла и сохраняют последние присвоенные им значения. Однако, если последовательность sequence пустая, lvalue не будет присвоено никакое значение (таким образом, используя эти переменные без дополнительной проверки, Вы имеете шанс получить ошибку NameError). См. также описания встроенных функций range() и xrange() в главе 12.
Будьте внимательны, изменяя последовательность, элементы которой Вы перебираете. Текущий элемент последовательности определяется значением внутреннего счетчика. Конец последовательности определяется по исключению IndexError при попытке получить очередной элемент. Таким образом, если в блоке suite1 Вы удалите текущий или один из пройденных элементов последовательности, следующий элемент будет пропущен. Аналогично, если вы добавите в последовательность новый элемент перед текущим, тело цикла для текущего элемента будет выполнено еще раз. Такое поведение может привести к неприятным ошибкам, которых обычно можно избежать, если перебирать элементы копии исходной последовательности, например:
for x in a[:]:
if x < 0: a.remove(x)
Существует две формы инструкции try. Их нельзя смешивать (то есть, инструкция try не может содержать одновременно ветви except и finally), однако они могут быть вложенными друг в друга.
С помощью первой формы Вы определяете обработчики исключений:
try: suite1 except [exc_class1 [, lvalue1]]: suite2 [...] [else: suite0]
Сначала выполняется тело основной ветви — suite1, и если код не генерирует исключение, выполняется блок suite0 (необязательная ветвь else). Если же код в блоке suite1 генерирует исключение, последовательно проверяются (в порядке их следования) ветви except до тех пор, пока не будет найдена ветвь except, удовлетворяющая сгенерированному исключению. Ветвь except без аргументов, если присутствует, должна быть последней ветвью except (в противном случае генерируется исключение SyntaxError) — удовлетворяет всем исключениям. Если указано выражение exc_classN, оно вычисляется и ветвь считается удовлетворяющей исключение, если полученный объект совместим с исключением. Объект exc_classN является совместимым с исключением, если исключение является экземпляром класса exc_classN или производного от него класса или является строкой равной exc_classN. Объект exc_classN также является совместимым с исключением, если он является кортежем, содержащим объект, совместимый с исключением (при этом кортеж может содержать вложенные кортежи).
Если ни одна из ветвей except не удовлетворяет исключению, поиск обработчика продолжается во внешнем блоке try (если такой имеется) и т. д. Если исключение генерируется при вычислении выражения exc_classN, обработка исходного исключения прекращается и производится поиск обработчика нового исключения во внешнем блоке (как будто вся инструкция try сгенерировала исключение).
Если найдена ветвь except, удовлетворяющая исключению, исключение (если оно является экземпляром класса) или ассоциированное с ним значение (если исключение является строкой) присваивается параметру lvalueN (любое выражение, которому допускается присваивание — см. раздел 10.3.2), если он задан, выполняется блок кода ветви (suiteN) и выполнение продолжается инструкций следующих за инструкцией try (исключение считается обработанным). Таким образом, если имеется две вложенных инструкции try и исключительная ситуация возникла в блоке try внутренней инструкции, обработчик внешней инструкции не будет обрабатывать исключение.
Перед выполнением блока ветви except информация об исключении сохраняется и может быть получена с помощью функции sys.exc_info() — функция возвращает кортеж, состоящий из типа исключения (класс или строка), самого исключения (если оно является экземпляром класса) или ассоциированного значения (если исключение является строкой) и объекта traceback (см. раздел 11.9.3). Эти же значения сохраняются в sys.exc_type, sys.exc_value и sys.exc_traceback соответственно. Однако их не рекомендуется использовать, так как это небезопасно в многопоточных программах.
Необязательная ветвь else выполняется, если в блоке основной ветви не было сгенерировано исключение. Если при выполнении ветви except или else генерируется исключение, поиск обработчика производится во внешней инструкции try (если такая имеется), а не в текущей.
Вторая форма используется для определения "страховочного" кода:
try: suite1 finally: suite2
Сначала выполняется ветвь try (блок suite1). Если при этом не возникает исключительной ситуации, далее просто выполняется ветвь finally (блок suite2). Если же в блоке suite1 генерируется исключение, то оно временно сохраняется, выполняется ветвь finally и сохраненное исключение генерируется снова (поиск обработчика производится во внешней инструкции try, если такая имеется). Если Вы прерываете выполнение блока suite2 инструкцией return, break или continue или генерируя новое исключение, сохраненное исключение будет утрачено (то есть не будет сгенерировано снова).
Ветвь finally выполняется и в том случае, если выход из блока suite1 происходит по инструкции return или break. В текущих реализациях использование инструкции continue в основной ветви инструкции try не допускается (ситуация, возможно, изменится в будущих версиях).
С помощью инструкции def Вы можете определить объект-функцию (function, см. раздел 11.4.1):
def func_name(param_list): suite
param_list — список параметров (через запятую; если параметры записаны с использованием только первой и второй форм, список может содержать завершающую запятую, которая игнорируется) в следующих формах (различные формы можно смешивать, но каждая из них может использоваться только один раз и порядок их следования должен быть именно таким, в котором они перечислены):
param1 [, param2 ...]
Список простых позиционных параметров. Каждый из параметров может быть идентификатором или подсписком параметров в виде '(subparam1 [, subparam2 ...])' (подсписки аргументов также могут содержать вложенные подсписки).
param1 = expr1 [, param2 = expr2...]
Список позиционных аргументов paramN, имеющих значение по умолчанию, получаемое вычислением выражения exprN. Форма записи параметров такая же, как и для первой формы записи аргументов. Выражения exprN вычисляются один раз — при выполнении определения функции, в области видимости, которое содержит определение функции.
*indentifier
Получение произвольного числа позиционных аргументов. Переменной indentifier присваивается кортеж всех позиционных аргументов, которым не соответствует параметры, заданные с использованием первых двух форм.
**indentifier
Получение произвольного количества именованных аргументов. Переменной indentifier присваивается словарь всех именованных аргументов, которым не соответствуют параметры, заданные с использованием первых двух форм.
При каждом выполнении определения функции (инструкции def) создается объект-функция и привязывается к имени func_name (идентификатор) в локальном пространстве имен (не рекомендуется использовать в качестве func_name идентификатор, который указан в этом блоке в инструкции global — см. раздел 10.3.9). Создаваемый объект-функция содержит ссылку на текущее глобальное пространство имен, которое будет использоваться в качестве глобального пространства имен при вызове функции.
Определение функции не выполняет тело функции (suite) — оно выполняется только при вызове функции. Аргументы, соответствующие параметрам со значением по умолчанию, могут быть опущены. В этом случае подставляется значение по умолчанию.
Синтаксис и семантика вызова функций описана в разделе 10.2.2. При вызове значения присваиваются всем параметрам, указанным в списке: это может быть значение позиционного или именованного аргумента или значение по умолчанию. Параметры, записанные в виде *identifier и **identifier, если присутствуют, инициализируются пустыми кортежем и словарем соответственно.
Для создания простой анонимной функции вы можете воспользоваться оператором lambda (см. раздел 10.2.7).
Функция (в том числе, и созданная с помощью оператора lambda) не имеет доступа к локальному пространству имен блока, в котором она определена. Чтобы обойти это ограничение, часто используют значения аргументов по умолчанию:
# Возвращает функцию, которая возвращает аргумент,
# увеличенный на n
def make_incrementer(n):
def increment(x, n=n):
return x+n
return increment
add1 = make_incrementer(1)
print add1(3) # Выведет '4'
Как мы уже упоминали, значения по умолчанию вычисляются только один раз. Это особенно важно, если значение по умолчанию является изменяемым объектом (например, списком или словарем): если функция изменяет объект (например, добавляя элемент в список), изменяется значение по умолчанию. Обычно это не то, что Вы ожидаете. Один из способов обойти такое поведение — использовать в качестве значения параметра по умолчанию объект None и явно проверять его в теле функции:
def add_ostrich_notice(notices=None):
if notices is None:
notices = []
notices.append(
"Просьба страусов не пугать - пол бетонный")
return notices
Однако использовать такое поведение для определения статических переменных нежелательно — лучше использовать глобальные переменные модуля или определить класс со специальным методом __call__(), например:
# Для вспомогательных объектов используем частные
# имена, которые не будут импортироваться с помощью
# 'from ... import *'
_MAX_KICKS_ALLOWED = 10 # Число разрешенных пинков
class _dog_kicker:
def __init__(self):
# ведет себя как статическая переменная в
# "функции" kick_a_dog()
self.num_of_kicks = 0
def __call__(self, num=1):
if self.num_of_kicks >= _MAX_KICKS_ALLOWED:
print "А Вам собаку не жалко?"
return
num = min(_MAX_KICKS_ALLOWED-self.num_of_kicks,
num)
self.num_of_kicks = self.num_of_kicks+num
print "Вы пнули собаку", num, "OAU(A)"
# Этот экземпляр можно использовать аналогично функции
kick_a_dog = _dog_kicker()
Определение класса создает объект-класс (class, см. раздел 11.6.1):
class class_name[(base_classes)]: suite
Здесь base_classes — список выражений (см. раздел 10.2.8), каждое из которых должно давать объект-класс. Для класса создается новое локальное пространство имен, глобальное пространство имен используется текущее (то есть того блока кода, в котором находится определение класса) и в этом окружении выполняется блок suite (обычно содержит только определения функций). После выполнения блока suite локальное пространство имен класса (используется для создания словаря атрибутов класса) и список базовых классов (значения выражений, входящих в base_classes) сохраняется в созданном объекте-классе и объект-класс привязывается к имени class_name в текущем локальном пространстве имен.
Имена, определенные в пространстве имен класса являются атрибутами класса — общими для всех экземпляров класса. Для того, чтобы определить атрибут экземпляра класса (имя в пространстве имен экземпляра класса), необходимо присвоить ему значение в одном из методов (например, при инициализации экземпляра — в методе __init__()). И атрибуты класса, и атрибуты экземпляра доступны с использованием записи через точку (instance.name) — атрибуты экземпляра "прячут" атрибуты класса с таким же именем. Атрибуты класса, значение которых равно неизменяемому объекту, могут служить как значения по умолчанию для атрибутов экземпляров этого класса.
Пространство имен — отображение имен (идентификаторов) к объектам. По функциональности пространства имен эквивалентны словарям и реализуются в виде словарей.
В языке Python всегда присутствуют три пространства имен: локальное, глобальное и пространство встроенных имен. Поиск локальных имен всегда производится в локальном пространстве имен, глобальных — сначала в глобальном, затем в пространстве встроенных имен [Если блок программы содержит инструкцию exec или 'from ... import *', семантика локальных имен изменяется: сначала производится их поиск в локальном пространстве имен, затем в глобальном и пространстве встроенных имен.].
Является ли имя локальным или глобальным определяется в момент компиляции: в отсутствии инструкции global, имя, добавляемое где-либо в блоке кода, является локальным во всем блоке; все остальные имена считаются глобальными. Инструкция global позволяет заставить интерпретатор считать указанные имена глобальными.
Имена могут быть добавлены (только в локальное пространство имен) следующими способами:
Если глобальное имя не найдено в глобальном пространстве имен, его поиск производится в пространстве встроенных имен, которое, на самом деле, является пространством имен модуля __builtin__. Этот модуль (или словарь определенных в нем имен) доступен под глобальным именем текущего блока __builtins__. Если же имя не найдено в пространстве встроенных имен, генерируется исключение NameError.
Ниже приведены значения локального и глобального пространств имен для различных типов блоков кода. Пространство имен модуля автоматически создается, когда модуль импортируется первый раз.
| Тип блока | Глобальное пространство имен | Локальное пространство имен |
|---|---|---|
| Модуль (программа и интерактивные команды фактически являются модулем __main__) | пространство имен модуля | то же, что и глобальное |
| Класс | пространство имен модуля, в котором находится определение класса | новое пространство имен (пространство имен класса), создается в момент выполнения определения |
| Функция (если объект кода, представляющий тело функции, выполняется с помощью инструкции exec, Вы можете сами определить, какие пространства имен использовать) | пространство имен модуля, в котором находится определение функции | новое пространство имен (пространство имен функции), создается каждый раз при вызове функции |
| Выражение, вычисляемое с помощью функции input() | глобальное пространство имен блока, из которого вызывается функция | локальное пространство имен блока, из которого вызывается функция |
| Строка, файл или объект кода, выполняемые с помощью инструкции exec, или функций eval() или execfile() (используя необязательные аргументы, Вы можете сами определить, какие пространства имен использовать) | по умолчанию используется глобальное пространство имен блока, в котором выполняется инструкция или из которого вызывается функция | по умолчанию используется локальное пространство имен блока, в котором выполняется инструкция или из которого вызывается функция |
Встроенные функции globals() и locals() возвращают словарь, представляющий глобальное и локальное пространства имен соответственно (см. главу 12).
В этом разделе описываются стандартные типы данных, поддержка которых встроена в интерпретатор: числа, последовательности и другие, включая сами типы. В языке Python нет явного логического типа — используйте целые числа.
Некоторые операции поддерживаются всеми объектами; в частности, любые объекты можно сравнивать, проверять их истинность (см. разделы 10.2.4 и 10.2.5) и для любых объектов можно получить строковое представление с помощью встроенных функций repr() (или используя запись в обратных кавычках: `expression`) и str().
Объекты встроенных типов могут иметь следующие специальные атрибуты:
__methods__
Список имен статических методов объекта. Атрибут определен только, если объект имеет хотя бы один такой метод.
__members__
Список имен статических атрибутов данных объекта. Атрибут определен только, если объект имеет хотя бы один такой атрибут.
При каждом обращении к атрибутам __methods__ и __members__ создается новая копия списка.
В языке Python есть четыре типа чисел: целые (int), длинные целые (long int), с плавающей точкой (вещественные; float) и комплексные (complex).
Числа создаются с использованием литералов или как возвращаемый результат встроенной функции или оператора. Числовые литералы в чистом виде (включая шестнадцатеричные и восьмеричные) дают простые целые числа.
Python полностью поддерживает смешанную арифметику: если бинарный арифметический оператор имеет операнды разного типа, операнд "меньшего" типа приводится к типу другого операнда (int < long int < float < complex). Это же правило используется для сравнения чисел разного типа [В результате, например, списки [1, 2] и [1.0, 2.0] считаются равными.]. Для приведения чисел к нужному типу Вы можете использовать встроенные функции int(), long(), float() и complex(). При приведении числа с плавающей точкой к целому (простому или длинному) типу, число округляется в сторону нуля (см. также функции floor() и ceil() в модуле math).
Целые числа реализованы с использованием типа long в C, поддерживающего числа в диапазоне не менее чем от -2 147 483 647 до 2 147 483 647. Длинные целые имеют неограниченную точность.
Литералы целых чисел могут быть записаны в десятичном, восьмеричном и шестнадцатеричном виде. Десятичная запись состоит из идущих подряд десятичных цифр (0–9), причем первая цифра не может быть нулем. Восьмеричная запись образуется из нуля и следующих за ним восьмеричных цифр (0–7). Шестнадцатеричная запись образуется из приставки ‘0x’ или ‘0X’ и следующих за ней шестнадцатеричных цифр (0–9, a–z, A–Z). Знак ‘-’ или ‘+’ не является частью литерала, а лишь унарным оператором, применяемым к объекту после его создания. Если литерал представляет число, выходящее за пределы диапазона допустимых чисел, генерируется исключение OverflowError.
Целые литералы с суффиксом ‘L’ или ‘l’ дают длинные целые (лучше использовать ‘L’, из-за схожести символа ‘l’ с единицей).
Приведем несколько примеров литералов для целых и длинных целых чисел:
7 2147483647 0177 0x80000000 3L 79228162514264337593543950336L 0377L 0x100000000L
Вещественные числа (числа с плавающей точкой) реализованы с использованием типа double в C (не менее 10 значащих цифр, наибольшее представимое число не меньше 1037).
Запись литералов вещественных чисел состоит из десятичных цифр (первая цифра не может быть нулем) и содержит десятичную точку и/или экспоненциальную часть. Экспоненциальная часть начинается с символа ‘e’ или ‘E’, далее следует необязательный знак (‘+’ или ‘-’) и одна или несколько десятичных цифр.
Приведем несколько примеров литералов для чисел с плавающей точкой:
3.14 10. .001 1e100 3.14e-10
Поведение в случаях, когда результат вычисления выражения не может быть представлен в рамках типа float, зависит от поведения лежащей в основе библиотеки языка C. Обычно существуют значения, представляющие (отрицательные и положительные) бесконечно малые и бесконечно большие числа. Строковое представление таких чисел зависит от версии интерпретатора и используемой для реализации библиотеки языка C, например, они могут выводиться как 1. или -1. c добавлением комментария #INF, #IND или #QNAN.
Комплексные числа имеют мнимую и вещественную части, реализованные с использованием типа double в C. Литералы мнимого числа создаются путем добавления суффикса ‘j’ или ‘J’ к десятичной записи целого или вещественного числа. Например:
3.14j 10.j 10j .001j 1e100j 3.14e-10j
Комплексные числа с ненулевой вещественной частью создаются сложением вещественной и мнимой частей или с помощью встроенной функции complex() (см. главу 12).
Комплексные числа имеют два атрибута данных и один метод:
real
Действительная часть комплексного числа.
imag
Мнимая часть комплексного числа.
conjugate()
Возвращает комплексное число, сопряженное с данным.
Преобразование комплексных чисел к другим числовым типам неоднозначно: для получения действительной части используйте атрибут real, а абсолютной величины - встроенной функцией abs().
Ниже приведены арифметические операторы, применимые ко всем числам:
x + y
Сумма x и y.
x - y
Разница между x и y.
x * y
Произведение x на y.
x / y
Частное x и y. Если оба операнда целые (простые или длинные), то результат тоже будет целым. Результат всегда округляется в меньшую сторону: 1/2 и -1/-2 даст 0, а -1/2 и 1/-2 даст -1.
x % y
Остаток от деления x на y.
-x
x с противоположным знаком.
+x
x (без изменений).
x ** y
x в степени y.
Кроме того, для работы с числами Python предоставляет встроенные функции abs(), divmod() и pow() (см. главу 12), а также более сложные функции, определенные в модуле math.
Для простых и длинных целых чисел в языке Python определены битовые операторы. Приоритет у всех бинарных битовых операторов ниже, чем у арифметических, и выше, чем у операторов сравнения. Унарный оператор ~ имеет такой же приоритет, как и унарные арифметические операторы (+ и -).
Ниже приведены все битовые операторы:
x | y
Битовое ИЛИ x и y.
x ^ y
Битовое исключающее ИЛИ x и y.
x & y
Битовое И x и y.
x << n
Биты x, сдвинутые на n влево, эквивалентно умножению на 2**n без контроля переполнения. Сдвиг на отрицательное число бит не допускается (генерируется исключение ValueError).
x >> n
Биты x, сдвинутые на n вправо, эквивалентно (целочисленному) делению на 2**n без контроля переполнения. Сдвиг на отрицательное число бит не допускается (генерируется исключение ValueError).
~x
Биты x инвертированные.
В языке Python есть шесть встроенных типов последовательностей: string, unicode, tuple, xrange, buffer и list.
Ниже приведены операции, определенные для всех последовательностей. Операторы in и not in имеют такой же приоритет, как и операторы сравнения, а операторы + (бинарный) and * — такие же, как и соответствующие арифметические операторы [Это необходимо, так как синтаксический анализатор не может определить тип операндов.]. Выражения s и t — последовательности одинакового [Последовательности, определяемые пользователем, могут не иметь этого ограничения.] типа, n, i и j — целые.
len(s)
Возвращает число элементов последовательности s.
x in s
1, если элемент x содержится в последовательности s, иначе — 0.
x not in s
0, если элемент x содержится в последовательности s, иначе — 1
s + t
Объединение последовательностей s и t.
s * n
n * s
n копий последовательности s объединенных вместе. Отрицательные значения n воспринимаются как 0 (что дает пустую последовательность такого же типа, как и s).
s += t
s *= t
Эквивалентно ‘s = s + t’ и ‘s = s * n’ соответственно, но, если s является изменяемой последовательностью, то выполнение операции будет производиться без создания нового объекта, то есть переменная s будет ссылаться на один и тот же объект до и после операции.
s[i]
i-й элемент последовательности s, отсчет начинается с 0. Если индекс i имеет отрицательное значение, отсчет ведется с конца, то есть подставляется len(s) + i. Однако -0 означает 0. Если индекс i указывает за пределы последовательности, генерируется исключение IndexError.
s[[i]:[j]]
Срез последовательности s от i до j — подпоследовательность, содержащая элементы последовательности s с такими индексами k, которые удовлетворяют неравенству i <= k < j. Если i или j имеет отрицательное значение, отсчет ведется с конца, то есть подставляется len(s) + i или len(s) + j. Индексы i и j могут быть опущены: i по умолчанию равен 0, j — sys.maxint. Если (после всех преобразований) первый индекс больше или равен второму, возвращается пустая последовательность.
Для работы с последовательностями также могут быть полезны встроенные функции min() и max() (см. главу 12).
В этом разделе описаны свойства обычных строк. Однако они в основном характерны и для строк Unicode.
Строковые литералы
Строки могут быть заключены в одинарные (‘'’) или двойные (‘"’) кавычки (открывающая и закрывающая кавычки должны быть одинаковыми) — так называемые короткие строки. Для длинных строк более удобна другая запись — строка, заключенная в группы из трех одинарных или трех двойных кавычек (открывающая и закрывающая группы должны быть одинаковыми). Короткие строки могут содержать управляющие последовательности и любые символы, кроме обратной косой черты (‘\’), символов перехода на новую строку и кавычек, в которые строка заключена. Длинные строки дополнительно могут содержать символы перехода на новую строку и любые кавычки, хотя и не могут содержать группу из трех кавычек, в которые строка заключена.
В строках можно использовать следующие управляющие последовательности:
| Последовательность | Представляемый символ |
|---|---|
| \newline | Игнорируется (newline — символ новой строки). |
| \\ | Символ обратной косой черты (‘\’). |
| \' | Одинарная кавычка (‘'’). |
| \" | Двойная кавычка (‘"’). |
| \a | Символ оповещения (BEL). |
| \b | Символ возврата на одну позицию (backspace, BS). |
| \f | Символ подачи страницы (formfeed, FF). |
| \n | Символ перехода на новую строку (linefeed, LF). |
| \r | Символ возврата каретки (CR). |
| \t | Символ горизонтальной табуляции (TAB). |
| \v | Символ вертикальной табуляции (VT). |
| \ooo | ASCII символ с восьмеричным кодом, равным ooo. |
| \xhh... | ASCII символ с шестнадцатеричным кодом, равным hh.... |
В соответствии со стандартом C, в последних двух управляющих последовательностях воспринимается до трех восьмеричных цифр и неограниченное количество шестнадцатеричных цифр соответственно (на платформах с 8-битным типом char используются только младшие 8 бит). В отличие от стандарта C, все нераспознанные управляющие последовательности остаются в строке (включая символ обратной косой черты). Такое поведение очень удобно при отладке.
Перед открывающей кавычкой (или группой из трех кавычек) в строковом литерале может быть указана буква ‘r’ или ‘R’. Такие строки называют “необрабатываемыми”, для них используются другие правила обработки управляющих последовательностей: строка всегда будет состоять из тех символов, которые записаны между открывающей и закрывающей кавычками (или группами кавычек). Так, r"\n" даст строку, состоящую из двух символов — обратной косой черты и латинской буквы ‘n’, r"\"" также является правильным строковым литералом и представляет строку, состоящую из символов обратной косой черты и двойной кавычки. Обратите внимание, что строка не может заканчиваться на нечетное количество символов обратной косой черты: последний из них образует с закрывающей кавычкой управляющую последовательность. Например, r"\" не является правильным строковым литералом.
Несколько следующих друг за другом строковых литералов, возможно разделенных символами пропуска (whitespace), использующие различную запись (заключены в различные кавычки; обычные строки и необрабатываемые), автоматически объединяются. Таким образом, строка ’Привет’ "всем" является эквивалентом строки ’Приветвсем’. Строки объединяются даже в том случае, если одна из них является обычной строкой, а другая строкой Unicode ('a' u'b' == u'ab'). Эта особенность позволяет уменьшить количество используемых символов обратной косой черты при записи длинного строкового литерала в несколько строк программного кода и даже снабдить части строк комментариями:
re.compile("[A-Za-z_]" # буква или символ
# подчеркивания
"[A-Za-z0-9_]*" # буква, цифра или символ
# подчеркивания
)
Заметим, что объединение строковых литералов выполняется в момент компиляции, в то время как оператор + объединяет строки во время выполнения программы.
Оператор форматирования
Оператор % с объектом-строкой (string или unicode) в качестве левого аргумента имеет особое значение. Он воспринимает левый аргумент как строку формата, которую необходимо применить к правому аргументу (аналогично функции sprintf() в С), и возвращает полученную в результате форматирования строку.
Правый аргумент должен быть кортежем, содержащим по одному элементу на каждый аргумент, требуемый строкой формата. Если строке формата необходим один аргумент, правым аргументом оператора % может быть также требуемый строкой формата объект, если он не является кортежем [Кортеж в этом случае должен содержать один элемент.].
Строка форматирования может содержать обычные символы (кроме символа ‘%’), которые копируются без изменения, и описания формата. Каждое описание формата имеет вид: ‘%[флаг ... ][ширина][.точность]символ_формата’ [Перед символом формата может быть также указан модификатор длины (‘h’, ‘l’ или ‘L’), однако он игнорируется.].
После символа ‘%’ могут быть указаны следующие флаги:
| Флаг | Назначение |
|---|---|
| # | Используется альтернативное представление аргумента. Для форматов ‘o’, ‘x’ и ‘X’ результат будет начинаться с ‘0’, ‘0x’ и ‘0X’ соответственно. При использовании форматов ‘f’, ‘g’ и ‘G’ результат всегда будет содержать десятичную точку, даже если после нее не следует не одной цифры. Кроме того, для форматов ‘g’ и ‘G’ из результата не будут удалены завершающие нули. В остальных случаях результат остается неизменным. |
| 0 | Результат заполняется слева нулями до нужной ширины поля. Для ‘s’- и ‘%’-форматов игнорируется. |
| - | Результат выравнивается влево (по умолчанию результат выравнивается вправо). |
| пробел | Перед положительным числом вставляется пробел при использовании знаковых форматов. |
| + | Перед числом всегда ставится знак (‘+’ или ‘-’) при использовании знаковых форматов. |
Следующие два необязательных параметра — минимальная ширина поля и точность. Если представление значения содержит меньше символов, чем ширина поля, то оно будет дополнено пробелами (нулями). Точность задает минимальное количество цифр при использовании форматов ‘d’, ‘i’, ‘o’, ‘u’, ‘x’ и ‘X’ (по умолчанию 1), число цифр после десятичной точки для форматов ‘e’, ‘E’ и ‘f’ (по умолчанию 6), максимальное количество значащих цифр для форматов ‘g’ и ‘G’ (по умолчанию 6; 0 воспринимается как 1), максимальное количество символов из строки для формата ‘s’ игнорируется. Вместо того, чтобы прямо указывать ширину поля и/или точность, Вы можете использовать символ ‘*’. В этом случае соответствующее целое значение передается в кортеже аргументов:
>>> import math >>> R = 1 >>> print "Длина окружности равна %*.*f" % ( ... 5, # Ширина поля ... 2, # Точность ... 2*math.pi*R) # Форматируемое число Длина окружности равна 6.28
Отрицательная ширина поля воспринимается как флаг ‘-’ и следующее за ним положительное число. Если значение после ‘.’ не указано или оно отрицательное, точность считается равной нулю.
Интерпретатор Python поддерживает следующие символы формата:
| Символ | Назначение |
|---|---|
| d, i | Десятичное представление целого числа (знакового) |
| o | Восьмеричное представление целого числа без знака |
| u | Десятичное представление целого числа без знака |
| x | Шестнадцатеричное представление целого числа без знака. Используются буквы в нижнем регистре (abcdef). |
| X | Шестнадцатеричное представление целого числа без знака. Используются буквы в верхнем регистре (ABCDEF). |
| e | Экспоненциальное представление вещественного числа. Экспоненциальная часть обозначается буквой ‘e’. |
| E | Экспоненциальное представление вещественного числа. Экспоненциальная часть обозначается буквой ‘E’. |
| f | Представление вещественного числа. Если точность равна 0, десятичная точка не используется. Во избежание вывода бесконечных строк бессмысленных цифр, точность ограничена числом 50. |
| g | Если порядок вещественного числа меньше -4 или больше или равен точности, используется ‘e’-формат, в противном случае используется ‘f’- формат. Завершающие нули из дробной части удаляются. |
| G | Если порядок вещественного числа меньше -4 или больше или равен точности, используется ‘E’-формат, в противном случае используется ‘f’- формат. Завершающие нули из дробной части удаляются. |
| r | Строковое представление объекта, полученное аналогично применению встроенной функции repr(). Поддерживается, начиная с версии 1.6. |
| s | Вставка строки или строкового представления объекта, полученного аналогично применению встроенной функции str(). |
| % | Символ ‘%’. |
Если тип значения для ширины поля или точности не является int (при использовании ‘*’), генерируется исключение TypeError. Остальные аргументы, не являющиеся строками и тип которых не соответствует используемому формату, интерпретатор пытается привести к необходимому типу с помощью соответствующих встроенных функций. Если это не удается, то генерируется исключение TypeError (для встроенных типов) или AttributeError (для объектов типа instance).
В качестве правого аргумента оператора % можно использовать словарь (или любое другое отображение). В этом случае описания формата сразу после символа ‘%’ должны содержать заключенный в скобки ключ, соответствующий необходимому значению в словаре. Например:
>>> count = 2
>>> language = 'Python'
>>> print 'В языке %(language)s %(count)03d типа ' \
'кавычек.' % vars()
В языке Python 002 типа кавычек.
Однако при такой записи Вы не можете передать ширину поля или точность в качестве аргумента (то есть, использовать ‘*’ в описании формата).
Методы строк
Начиная с версии 1.6, строки (обычные и Unicode) имеют набор методов для работы с ними. В более ранних версиях Вы можете воспользоваться функциями, определенными в стандартном модуле string. Далее s — строка, к которой применяется метод.
Форматирование
center(width)
Возвращает строку длиной width, в центре которой расположена исходная строка (центрирует строку в поле заданной ширины). Строка дополняется до нужной длины пробелами. Если width меньше длины исходной строки, она возвращается без изменений.
ljust(width)
Возвращает копию исходной строки, дополненную справа пробелами (выравнивает строку влево в поле заданной ширины). Если width меньше длины исходной строки, она возвращается без изменений.
rjust(width)
Возвращает копию исходной строки, дополненную слева пробелами (выравнивает строку вправо в поле заданной ширины). Если width меньше длины исходной строки, она возвращается без изменений.
Поиск вхождений
count(sub [, start [, end]])
Возвращает количество вхождений подстроки sub в s[start:end]. Необязательные аргументы start и end интерпретируются так же, как и в операции среза (раздел 11.2).
endswith(suffix [, start [, end]])
Возвращает 1, если строка s[start:end] заканчивается на suffix, иначе возвращает 0.
find(sub [, start [, end]])
Возвращает наименьший индекс в исходной строке s начала вхождения подстроки sub в s[start:end]. Необязательные аргументы start и end интерпретируются так же, как и в операции среза (раздел 11.2). Если подстрока не найдена, возвращает -1.
index(sub [, start [, end]])
Аналог метода find(), генерирующий исключение, если подстрока не найдена.
rfind(sub [, start [, end]])
Возвращает наибольший индекс в исходной строке s начала вхождения подстроки sub в s[start:end]. Необязательные аргументы start и end интерпретируются так же, как и в операции среза (раздел 11.2). Если подстрока не найдена, возвращает -1.
rindex(sub [, start [, end]])
Аналог метода rfind(), генерирующий исключение, если подстрока не найдена.
startswith(prefix [, start [, end]])
Возвращает 1, если строка s[start:end] начинается с prefix, иначе возвращает 0.
Преобразование символов и фрагментов строк
expandtabs([tabsize])
Возвращает копию исходной строки, в которой все символы табуляции заменены одним или несколькими пробелами в зависимости от текущей позиции размера табуляции. По умолчанию размер табуляции tabsize равен 8 символам.
lstrip()
Возвращает копию строки, с удаленными идущими в начале строки символами пропуска (см. метод isspace()).
replace(old, new [, maxcount])
Возвращает копию строки, в которой все вхождения подстроки old заменены на new. Если задан необязательный аргумент maxcount, заменяются только первые maxcount вхождений.
rstrip()
Возвращает копию строки, с удаленными идущими в конце строки символами пропуска (см. метод isspace()).
strip()
Возвращает копию строки, с удаленными идущими в начале и конце строки символами пропуска (см. метод isspace()).
translate(table [, delchars])
Возвращает копию строки, в которой все символы, указанные в строке delchars удалены, а для оставшихся символов произведена заменена c ) table[ord(c)]. Аргумент table должен быть строкой из 256 символов. Замечание: у объектов unicode этот метод имеет другой синтаксис (см. раздел 11.2.2).
encode([encoding [, errors]])
Возвращает представление строки в кодировке encoding (по умолчанию ASCII). Аргумент errors (строка) указывает способ обработки ошибок. По умолчанию используется ’strict’ — если символ не может быть представлен в данной кодировке, генерируется исключение UnicodeError (класс, производный от ValueError). Другие возможные значения — ’ignore’ (отсутствующие в кодировке символы удаляются) и ’replace’ (отсутствующие в кодировке символы заменяются, обычно на символ ‘?’). (Метод encode() в версии 1.6 определен только для строк Unicode.)
Разбиение и объединение
join(seq)
Возвращает объединение строк-элементов последовательности seq, используя строку s в качестве разделителя. Если последовательность содержит элементы, которые не являются строками, генерирует исключение ValueError.
split([sep [, maxcount]])
Возвращает список слов, содержащихся в исходной строке. В качестве разделителя слов используется строка sep, если она не задана или равна None, разделителем слов считаются символы пропуска. Если задан аргумент maxcount и maxcount >= 0, возвращается список из maxcount первых слов и остатка (таким образом список будет содержать не более maxcount-1 элементов).
splitlines([keepends])
Аналог метода split(), использующий в качестве разделителя переход на новую строку. Символы перехода на новую строку включаются в результат, только если задан и является истинным необязательный аргумент keepends.
Методы, зависящие от национальных установок
Поведение следующих методов зависит от текущих национальных установок. Вы можете изменить их с помощью функции locale.setlocale() (см. описание стандартного модуля locale). Применительно к строкам Unicode все описанные здесь методы работают со всеми символами Unicode, для которых соответствующее преобразование однозначно.
capitalize()
Возвращает копию строки, в которой первая буква заменена на прописную.
isdigit()
Возвращает 1, если строка содержит только цифры, иначе возвращает 0.
islower()
Возвращает 1, если строка содержит хотя бы один символ, который может быть записан в верхнем и нижнем регистре, и все такие символы в строке находятся в нижнем регистре (строчные), иначе возвращает 0.
isspace()
Возвращает 1, если строка содержит только символы пропуска (whitespace) — пробел, табуляция, перевод на новую строку и т. д., иначе возвращает 0.
istitle()
Возвращает 1, если регистр букв в строке соответствует заголовку (строчные буквы следуют только после символов, которые могут быть записаны в верхнем и нижнем регистре, а прописные только после символов, для которых нет понятия регистра, и с начала строки), иначе возвращает 0 [Несколько упрощенное правило написания заголовков в некоторых западных языках — каждое слово заголовка начинается с прописной буквы. Обычно используется более сложное правило, по которому предлоги пишутся полностью строчными буквами.].
isupper()
Возвращает 1, если строка содержит хотя бы один символ, который может быть записан в верхнем и нижнем регистре, и все такие символы в строке находятся в верхнем регистре (прописные), иначе возвращает 0.
lower()
Возвращает копию строки, все символы которой приведены к нижнему регистру.
swapcase()
Возвращает копию строки, в которой регистр букв изменен с верхнего на нижний и наоборот.
title()
Возвращает копию строки, в которой регистр букв соответствует заголовку (строчные буквы следуют только после символов, которые могут быть записаны в верхнем и нижнем регистре, а прописные только после символов, для которых нет понятия регистра, и с начала строки) [Несколько упрощенное правило написания заголовков в некоторых западных языках — каждое слово заголовка начинается с прописной буквы. Обычно используется более сложное правило, по которому предлоги пишутся полностью строчными буквами.].
upper()
Возвращает копию строки, все символы которой приведены к верхнему регистру.
Литералы для строк Unicode образуются из строковых литералов (любого вида) при добавлении в начало символа ‘u’ или ‘U’: u’abc’, ur"""abc""" (но не ru’abc’). Кроме того, литералы строк Unicode могут содержать управляющие последовательности вида ‘\uhhhh’, которые интерпретируются так же, как и ‘\xhh...’, но всегда должны содержать ровно четыре шестнадцатеричные цифры, что гораздо удобнее. Обратите внимание, что управляющее последовательности вида ‘\xhh...’ и ‘\uhhhh’ позволяют представить все символы Unicode, а ‘\ooo’ — только первые 256.
Синтаксис метода translate объектов unicode отличается от одноименного метода объектов string:
translate(table)
Возвращает копию строки, в которой все символы c, для которых в отображении table содержится запись с ключом ord(c), заменены на unichr(table[ord(c)]) или удалены, если table[ord(c)] == None. table может быть отображением любого типа.
Помимо описанных в предыдущем разделе, строки Unicode имеют еще несколько методов:
isdecimal()
Возвращает 1, если строка не содержит ничего, кроме десятичных цифр, иначе возвращает 0. Под символами десятичных цифр помимо традиционных ASCII символов подразумеваются также символы, используемые в различных языках, надстрочные и подстрочные десятичные цифры (метод isdigit применительно к строкам Unicode охватывает также и символы с точкой, в скобках, в круге и т. д.).
isnumeric()
Возвращает 1, если строка не содержит ничего, кроме символов-чисел, иначе возвращает 0. Помимо символов цифр, символы чисел включают символы римских чисел, дробные и т. п.
Кортежи конструируются простым перечислением элементов через запятую, заключенным в круглые скобки. Обычно (если это не конфликтует с другими элементами синтаксиса языка) скобки можно опустить, однако пустой кортеж всегда должен записываться в скобках. Кортеж с одним элементом должен содержать завершающую запятую: ‘a, b, c’, ‘()’, ‘(d,)’. Последовательности другого типа могут быть преобразованы в кортеж с помощью встроенной функции tuple() (см. главу 12). Кортежи не поддерживают никаких дополнительных операций кроме тех, которые характерны для всех последовательностей.
Объект xrange создается встроенной функцией xrange() (см. главу 12) и является псевдопоследовательностью, представляющей ряд целых чисел (объект не хранит свои элементы, а создает каждый элемент при обращении к нему). Достоинство объектов xrange состоит в том, что они всегда занимают одинаковое количество памяти, независимо от размера представляемого диапазона. Использование объектов xrange вместо списков не дает существенного выигрыша в производительности.
Помимо операций, определенных для всех последовательностей, объекты xrange имеют один метод:
tolist()
Преобразует объект, к которому метод применяется, в объект-список и возвращает его.
Объекты buffer создаются с помощь встроенной функции buffer() (см. главу 12) из различных объектов, поддерживающих соответствующий интерфейс: встроенных типов string, unicode, buffer, а также некоторых типов, определенных в различных модулях (например, array из модуля array). Объекты buffer позволяют обращаться с различными структурами как с массивами байтов. При этом все изменения в исходный объект будут немедленно отражаться в (ранее созданном) объекте buffer. Встроенная функция str() преобразует объект buffer в строку.
Все описанные выше последовательности являются неизменяемыми — после создания такого объекта Вы не можете внести в него изменения. Объекты-списки (list) поддерживают дополнительные операции, позволяющие изменять объект [В дальнейшем, возможно, в язык будут добавлены другие типы изменяемых последовательностей. К ним также будут применимы операции, описанные в этом разделе.]. Списки конструируются путем перечисления в квадратных скобках через запятую его элементов: ‘[a, b, c]’. Начиная с версии 2.0, списки могут быть также сконструированы с помощью расширенной записи ‘[expression iter_list]’, где iter_list состоит из одного или нескольких (разделенных символами пропуска) выражений вида ‘for lvalue in expression’ и, возможно, ‘if test’. При этом для каждой комбинации всех lvalue (см. раздел 10.3.2), для которой все выражения test являются истинными.
Ниже приведены дополнительные операции, позволяющие добавлять, удалять и заменять элементы списка (x — произвольный объект, s и t — последовательности одинакового3 типа):
s[i] = x
Заменяет элемент последовательности, на который указывает индекс i на x.
del s[i]
Удаляет элемент последовательности, на который указывает индекс i.
s[[i]:[j]] = t
Заменяет срез последовательности от i до j на t (удаляет из последовательности элементы входящие в срез и вставляет элементы из t).
del s[[i]:[j]]
Удаляет из последовательности элементы, входящие в срез (эквивалентно ‘s[i:j] = []’).
Кроме того, Вы можете вносить изменения в изменяемые последовательности с помощью методов (x — произвольный объект, s — последовательность, к которой применяется метод, и t — последовательность того же3 типа). Для экономии памяти при работе с большими списками все методы вносят изменения в уже существующий список, а не создают новый. Во избежание возможных ошибок, они (если не указано иного) не возвращают результат.
append(x)
Добавляет объект в конец последовательности (для списков это эквивалентно ‘s[len(s):len(s)] = [x]’).
extend(t)
Добавляет в конец последовательности элементы последовательности t (эквивалентно ‘s[len(s):len(s)] = x’).
count(x)
Возвращает число вхождений элемента x в последовательность (число элементов последовательности s, равных x).
index(x)
Возвращает наименьшее i, для которого s[i] == x. Генерирует исключение ValueError, если последовательность не содержит элемента, равного x.
insert(i, x)
Вставляет в последовательность элемент x перед i-м элементом (для списков это эквивалентно ‘s[i:i] = [x]’, если i >= 0, иначе элемент вставляется в начало). Если значение индекса меньше нуля, элемент вставляется в начало последовательности, если больше длины последовательности — в ее конец.
pop([i])
Возвращает i-й элемент последовательности, одновременно удаляя его из списка. Если индекс не указан, подразумевается последний элемент списка. Положение элемента можно отсчитывать с конца, указывая отрицательный индекс. Если индекс выходит за пределы диапазона, генерируется исключение IndexError.
remove(x)
Удаляет из списка первый элемент со значением x (эквивалентно del s[s.index(x)]). Если такового в списке нет, то генерируется исключение ValueError.
reverse()
Располагает элементы последовательности в обратном порядке.
sort([cmpfunc])
Располагает элементы последовательности в порядке возрастания. В качестве необязательного параметра можно передать функцию двух переменных, определяющую сравнение (по умолчанию сравнение производится так же, как и встроенной функцией cmp()). Однако использование пользовательской функции сравнения значительно замедляет процесс сортировки. Так, например, последовательное применение методов sort() и reverse() работает значительно быстрее, чем сортировка с использованием функции сравнения ‘lambda x, y: cmp(y, x)’.
Отображения ставят в соответствие объектам (ключам) другие объекты. Отображения являются изменяемыми объектами. В настоящее время есть только один стандартный тип отображения — словарь (dictionary). В качестве ключа в словаре не могут использоваться изменяемые объекты, сравнение которых производится по значению вместо простой проверки идентичности (см. раздел 10.2.4), например списки и словари. Если два объекта равны (в том числе, если они имеют разный тип), например 1 и 1.0, при использовании их в качестве ключа Вы получите доступ к одной и той же записи словаря.
Создаются словари путем перечисления в фигурных скобках через запятую пар key: value, например, ‘{'jack': 4098, 'sjoerd': 4127}’ или ‘{4098: 'jack', 4127: 'sjoerd'}’. Интерпретатор не обнаруживает конфликты, связанные с наличием нескольких записей с одинаковыми ключами, — сохраняется только запись, идущая последней.
Для отображений определены следующие операции (m — отображение, k — ключ, v — произвольный объект):
len(m)
Возвращает количество записей в m.
m[k]
Значение, соответствующий ключу k в m. Если отображение не содержит запись с ключом k, генерируется исключение KeyError.
m[k] = v
Устанавливает значение, соответствующее ключу k в v.
del m[k]
Удаляет из m запись, соответствующую ключу k. Если отображение не содержит запись с ключом k, генерируется исключение KeyError.
Кроме того, отображения имеют следующие методы (m — отображение, к которому применяется метод, n — отображение того же [Отображения, определяемые пользователем, могут не иметь этого ограничения.] типа, k — ключ, v — произвольный объект):
clear()
Удаляет все записи из отображения.
copy()
Создает и возвращает поверхностную (т. е. ключи и значения нового отображения являются теми же объектами, которые были в исходном, а не их копиями) копию исходного отображения.
has_key(k)
Возвращает 1, если отображение содержит запись с ключом k, иначе возвращает 0.
items()
Возвращает список записей отображения в виде ‘(key, value)’
keys()
Возвращает список ключей отображения.
update(m)
Эквивалентно выполнению ‘for k in b.keys(): m[k] = b[k]’.
values()
Возвращает список значений, содержащихся в отображении.
get(k [, v])
Возвращает m[k], если отображение содержит запись с ключом k, иначе v (по умолчанию None).
setdefault(k [, v])
Если отображение содержит запись с ключом k, возвращает m[k], в противном случае возвращает значение v, предварительно добавив его в отображение с ключом k. Если аргумент v опущен, он считается равным None. Поведение этого метода похоже на поведение метода get(), за исключением того, что если запись с заданным ключом отсутствует, значение по умолчанию не только возвращается, но и добавляется в отображение.
Порядок следования элементов в списке не определен. Однако, если вызвать методы keys() и values(), не внося между их вызовами изменений в отображение, то порядок следования элементов в возвращаемых списках будет одинаковый. Это позволяет создавать список пар (value, key), используя встроенную функцию map(): ‘pairs = map(None, m.values(), m.keys())’.
В этом разделе описаны типы объектов, для которых определена операция вызова (obj(arglist)). Вы можете узнать, поддерживает ли объект операцию вызова, с помощью встроенной функции callable().
Объекты-функции (function) создаются при определении функции с помощью инструкции def или оператора lambda. Единственная операция, определенная для функций — их вызов: ‘func(arglist)’.
Объекты-функции имеют следующие атрибуты:
func_doc
__doc__
Строка документации или None, если она не определена.
func_name
__name__
Имя функции.
func_defaults
Значения аргументов по умолчанию или None, если ни один аргумент не имеет значения по умолчанию.
func_code
Объект кода (code), представляющий собой байт-компилированное тело функции.
func_globals
Ссылается на словарь, представляющий глобальное пространство имен модуля, в котором определена функция (имена, являющиеся для функции глобальными).
Атрибутам func_doc (или __doc__), func_defaults и func_code можно присвоить новые значения, остальные — доступны только для чтения [func_globals является объектом изменяемого типа — Вы можете внести в него изменения, например, используя методы, но не можете присвоить новое значение. Следует понимать, что при этом будет изменено глобальное пространство имен модуля, в котором определена функция, и изменения отразятся на других объектах, определенных в этом модуле.].
Объект-метод (instance method) создается при обращении к атрибуту класса или экземпляра класса, определенному как функция-атрибут класса. Если же Вы обратитесь к нему напрямую через специальный атрибут класса __dict__, Вы получите объектфункцию в неизменном виде. Метод может быть привязанным к экземпляру класса (если Вы обращаетесь к нему как к атрибуту экземпляра класса) и не привязанным (если Вы обращаетесь к нему как к атрибуту класса). Важно понимать, что преобразование атрибута-функции в атрибут-метод производится, только если функция является атрибутом класса. Функции, являющиеся атрибутами экземпляра класса в метод не преобразуются.
Объекты-методы имеют следующие атрибуты:
im_func
Объект-функция, реализующая метод. Атрибут доступен только для чтения.
im_self
Экземпляр класса, к которому применяется метод (None, если метод не привязан). Атрибут доступен только для чтения.
im_class
Класс, в котором метод определен. Атрибут доступен только для чтения.
__name__
Имя метода (то же самое, что и im_func.__name__).
__doc__
Строка документации (то же самое, что и im_func.__doc__).
При вызове метода, не привязанного к экземпляру класса, вызывается лежащая в его основе функция (im_func) с одной лишь разницей: если первый аргумент не является экземпляром класса im_class или производного от него класса, генерируется исключение TypeError. Если же метод привязан к определенному экземпляру класса, функция im_func вызывается со списком аргументов, в начало которого вставлен экземпляр im_self. То есть, если класс C содержит определение функции f и x является экземпляром класса C, то вызов x.f(1) эквивалентен вызову C.f(x, 1).
Заметим, что преобразование объекта-функции в (привязанный или не привязанный к экземпляру класса) метод происходит при каждом обращении к атрибуту класса или его экземпляра. В некоторых случаях Вы можете немного ускорить работу программы, присвоив метод локальной переменной и затем используя ее для многократного вызова метода.
Встроенные функции и методы представляются в языке Python объектами одного типа - builtin_function_or_method. Количество и тип воспринимаемых ими аргументов определяется реализацией. Объекты, представляющие встроенные функции и методы, являются неизменяемыми и не содержат ссылок на изменяемые объекты.
Объекты builtin_function_or_method имеют следующие атрибуты:
__doc__
Строка документации (None, если строка документации не определена).
__name__
Имя функции/метода.
__self__
Ссылка на объект, к которому должен применяться метод или None для встроенных функций.
Когда вызывается объект-класс, создается и возвращается новый экземпляр этого класса. При этом подразумевается вызов специального метода класса __init__ (если он определен) с аргументами, с которыми вызывается объект-класс. Если метод __init__ не определен, объект-класс должен вызываться без аргументов. Свойства объектов-классов описаны в разделе 11.6.1.
Если для класса определить метод __call__() (см. раздел 11.6.3), то его экземпляры будут поддерживать вызов: вызов экземпляра (x(arglist)) преобразуется в вызов метода __call__() с теми же аргументами (x.__call__(arglist)). Свойства экземпляров классов описаны в разделе 11.6.2.
Единственная операция, поддерживаемая объектами-модулями — доступ к их атрибутам: m.name, где m — модуль и name — имя, определенное в пространстве имен модуля m (Вы можете как получить, так и присвоить новое значение атрибуту модуля). Для создания объекта модуля предназначена инструкция import (см. раздел 10.3.10).
Объекты модули имеют следующие атрибуты:
__dict__
Словарь, являющийся таблицей имен модуля. Внося в него изменения, Вы меняете таблицу имен модуля, однако присваивание атрибуту __dict__ невозможно (то есть Вы можете написать m.__dict__['a'] = 1, тем самым определив m.a равным 1, но не можете написать m.__dict__ = {}).
__name__
Имя модуля.
__doc__
Строка документации модуля.
__file__
Полное имя файла, содержащего определение модуля (у модулей, статически встроенных в интерпретатор, атрибут __file__ отсутствует).
Объект-класс создается с помощью определения класса (см. раздел 10.4.6). Пространство имен класса реализовано в виде словаря, доступного через специальный атрибут __dict__. Ссылка на атрибут класса преобразуется в поиск соответствующего имени в словаре, например, C.x преобразуется в C.__dict__['x']. Если атрибут не найден, поиск продолжается в базовых классах. Поиск производится сначала в глубину, затем слева направо, в порядке следования их в списке базовых классов. Если атрибуту соответствует объект function, то объект преобразуется в не привязанный к экземпляру объект-метод (см. раздел 11.4.2). Атрибут im_class этого объекта-метода указывает на класс, в котором найден соответствующий ему объект-функция (он может быть одним из базовых классов).
Присваивание атрибуту класса вносит изменения в словарь этого класса, но никогда не изменяет словари базовых классов.
Объект-класс может быть вызван, для получения экземпляра класса (см. раздел 11.4.4).
Объекты-классы имеют следующие атрибуты:
__name__
Имя класса.
__module__
Имя модуля, в котором класс определен.
__dict__
Словарь атрибутов класса. Вы можете изменять его содержимое, тем самым добавлять и удалять атрибуты класса и изменять их значения. Вы даже можете присвоить __dict__ новое значение, но это может спровоцировать довольно странные ошибки.
__bases__
Кортеж базовых классов в порядке их следования в списке базовых классов. Вы можете изменить значение этого атрибута, однако вряд ли найдется достаточно веская причина для подобных манипуляций.
__doc__
Строка документации класса или None, если она не определена.
Объект-экземпляр класса возвращается при вызове объекта-класса (см. раздел 11.4.4). Пространство имен объекта-экземпляра реализовано в виде словаря, в котором поиск атрибутов производится в первую очередь. Если атрибут не найден, поиск продолжается среди атрибутов класса (см. раздел 11.6.1). При этом атрибут класса, являющийся методом, становится привязанным к данному экземпляру класса (см. раздел 11.4.2). Если нет атрибута класса с таким именем, вызывается специальный метод __getattr__(). Если же метод __getattr__() не определен, генерируется исключение AttributeError.
Присваивание атрибуту и его удаление вносят изменения в словарь экземпляра класса, но никогда не изменяют словарь класса. Если определены специальные методы __setattr__() и __delattr__(), то вызываются эти методы вместо того, чтобы вносить изменения в словарь экземпляра напрямую.
Объекты-экземпляры имеют следующие атрибуты:
__dict__
Словарь атрибутов экземпляра класса. Вы можете изменять его содержимое, тем самым добавлять и удалять атрибуты экземпляра и изменять их значения. Вы даже можете присвоить __dict__ новое значение, однако это может спровоцировать довольно странные ошибки (часто программы на языке Python рассчитывают на возможность добавить атрибут к экземпляру класса, присваивание же __dict__ нового значения может привести к мистическим исчезновениям таких атрибутов).
__class__
Объект-класс, экземпляром которого объект является. Вы можете изменить значение этого атрибута, однако вряд ли найдется достаточно веская причина для подобных манипуляций.
Определив для класса методы со специальными именами, Вы можете реализовать над его экземплярами определенные операции, которые вызываются с помощью специального синтаксиса.
Инициализация и очистка
__init__(self [, args...])
Вызывается при создании экземпляра класса (конструктор). args... — аргументы, с которыми вызывается объект-класс. Если базовый класс имеет метод __init__(), метод __init__() производного класса должен явно вызвать его, для инициализации части экземпляра, определенной в базовом классе.
__del__(self)
Вызывается перед уничтожением экземпляра (деструктор). Если базовый класс имеет метод __del__(), метод __del__() производного класса должен явно вызвать его, для очистки части экземпляра, определенной в базовом классе. Заметим, что можно (но не рекомендуется) предотвратить уничтожение экземпляра, создав новую ссылку на него. Метод __del__() будет вызван снова — при удалении этой ссылки. Если во время выхода из интерпретатора экземпляр все еще присутствует, вызов деструктора для него не гарантируется.
Замечания:
Истинность и сравнение
__cmp__(self, other)
Вызывается (для первого или второго операнда) при выполнении всех операций сравнения, кроме случаев, когда оба операнда являются экземплярами классов и при этом для первого операнда не определен метод __cmp__(). Должен возвращать целое число: отрицательное, если self < other, ноль, если self == other, и положительное целое число, если self > other (см. также описание функции cmp() в главе 12). Если метод __cmp__() (или __rcmp__()) не определен, сравнение экземпляров производится по идентификаторам.
__rcmp__(self, other)
Вызывается для второго операнда, если оба операнда являются экземплярами классов и при этом для первого операнда не определен метод __cmp__(). Должен возвращать целое число: отрицательное, если self > other, ноль, если self == other, и положительное целое число, если self < other. Нет смысла определять cmp(y, x) отличным от -cmp(x, y), поэтому метод __rcmp__() обычно определяют в виде:
def __rcmp__(self, other):
return -cmp(self, other)
__hash__(self)
Метод предназначен для получения хэш-значения объекта. Вызывается для объектов, используемых в качестве ключа при операциях над словарями, а также при использовании встроенной функции hash(). Должен возвращать 32-битное целое число. Объекты, которые при сравнении считаются равными, должны иметь равные хэш-значения. Рекомендуется использовать своего рода смесь (используя, например, исключающее ИЛИ) хэш-значений компонентов объекта, играющих роль при сравнении. Если для класса не определен метод __cmp__(), то по умолчанию в качестве хэш-значения для его экземпляров будет использоваться идентификатор объекта, определение же метода __hash__() лишь замедлит выполнение программы. Если же у класса есть метод __cmp__(), но нет метода __hash__(), его экземпляры не могут быть использованы в качестве ключа в операциях над словарями. Хэш-значение должно быть постоянно на протяжении всего времени жизни объекта, поэтому изменяемые объекты не должны иметь метода __hash__().
__nonzero__(self)
Вызывается для определения истинности объекта, должен возвращать 0 или 1. Если этот метод не определен, используется метод __len__() (см. раздел 11.6.3); если же для класса не определен ни один из этих методов, все его экземпляры будут истинными.
Доступ к атрибутам
Вы можете изменить действия, выполняемые при доступе к атрибутам: получении значения, присваивании и удалении. Для повышения производительности эти методы кэшируются в объекте-классе в момент выполнения определения класса. Поэтому их изменение после выполнения определения класса не даст желаемого результата.
__getattr__(self, name)
Вызывается, если атрибут не доступен обычным способом (то есть экземпляр, класс, экземпляром которого он является, и все его родительские классы не имеют атрибута с именем name). Метод должен возвращать значение (вычисленное) атрибута или генерировать исключение AttributeError. Обратите внимание, что в отличие от __setattr__() и __delattr__(), метод __getattr__() не вызывается, если атрибут найден обычным способом. Такой вариант эффективней и позволяет получить доступ из этих методов к другим атрибутам.
__setattr__(self, name, value)
Вызывается при попытке присваивания атрибуту вместо обычного механизма, который сохраняет значение в словаре __dict__ экземпляра. name — имя атрибута, value — присваиваемое значение. Обратите внимание, что попытка присвоить значение атрибуту экземпляра (например, ‘setattr(self, name, value)’) внутри метода __setattr__() приведет к его рекурсивному вызову. Вместо этого следует добавить соответствующую запись в словарь атрибутов экземпляра: ‘self.__dict__[name] = value’.
__delattr__(self, name)
Вызывается при попытке удаления атрибута. Этот метод следует определять только в том случае, когда для объектов имеет смысл инструкция ‘del self.name’.
Операция вызова
__call__(self [, args...])
Вызывается при вызове экземпляра класса, то есть ‘x(arg1, arg2, ...)’ является короткой записью для ‘x.__call__(arg1, arg2, ...)’.
Эмуляция последовательностей и отображений
Для того, чтобы определенные Вами объекты вели себя так же, как и встроенные типы string, tuple, list и dictionary, для них необходимо определить методы, описанные в этом разделе. Разница между последовательностями и отображениями заключается в том, что для последовательностей допустимыми ключами (индексами) являются целые числа k, такие что 0 <= k < N, где N — длина последовательности. Для отображений же ключом может являться объект любого типа [Тип dictionary налагает дополнительные ограничения: для его ключа должна быть определена операция получения хэш-значения (см. описание встроенной функции hash() в главе 12).]. Кроме того, при применении к последовательности операции среза, в качестве ключа выступает объект, представляющий один (объект типа slice или ellipsis) или несколько (кортеж из объектов типа slice и ellipsis) срезов (см. раздел 11.8.3).
Кроме описанных здесь методов, для отображений рекомендуется реализовать методы keys(), values(), items(), has_key(), get(), clear(), copy(), и update(), ведущие себя так же, как и для объектов dictionary (см. раздел 11.3); для изменяемых последовательностей следует реализовать методы, характерные для объектов list: append(), count(), index(), insert(), pop(), remove(), reverse() и sort() (см. раздел 11.2.6). И, наконец, специальные методы __add__(), __radd__(), __iadd__(), __mul__(), __rmul__() и __imul__(), реализующие характерные для последовательностей операции сложения (объединение последовательностей) и умножения (размножение последовательностей), описаны в разделе 11.6.3. Для совместимости с предыдущими версиями, могут быть определены специальные методы __getslice__(), __setslice__() и __delslice__() (см. ниже), которые будут обрабатывать операции с простой (но не расширенной) записью среза.
__len__(self)
Вызывается для реализации встроенной функции len(). Возвращаемое значение должно быть целым числом, большим или равным нулю. Кроме того, если для объекта не определен метод __nonzero__(), истинность объекта определяется по значению, возвращаемому методом __len__().
__getitem__(self, key)
Вызывается для реализации получения элемента по индексу или ключу (self[key]). Интерпретация отрицательных индексов (если Вы реализуете последовательность) должна производиться самим методом __getitem__(). Если key имеет несоответствующий тип, следует генерировать исключение TypeError. Если Вы эмулируете последовательность, то, в случае выхода индекса за пределы допустимых значений (с учетом преобразований отрицательных индексов), метод должен генерировать исключение IndexError (таким образом при переборе элементов последовательности определяется ее конец). Если отображение не содержит записи с ключом key, принято использовать исключение KeyError.
__setitem__(self, key, value)
Вызывается для реализации присваивания элементу с заданным ключом или индексом (‘self[key] = value’). Этот метод необходим только для отображений, допускающих изменение значения, соответствующего определенному ключу, или добавление записи с новым ключом, а также для последовательностей, допускающих изменение элементов. Если Вы эмулируете последовательность, то, в случае выхода индекса за пределы допустимых значений (с учетом преобразований отрицательных индексов), следует генерировать исключение IndexError.
__delitem__(self, key)
Вызывается для реализации удаления элемента с заданным индексом или ключом (‘del self[key]’). Этот метод необходим только для последовательностей и отображений, допускающих удаление элементов. Соглашения об использовании исключений такие же, как и для метода __getitem__.
До версии 2.0, для того, чтобы последовательность поддерживала операцию с простой записью среза, необходимо было определить следующие три метода (для неизменяемых последовательностей нужен только метод __getslice__()). Для всех трех методов опущенные значения индексов i и j заменяются на ноль и sys.maxint соответственно. Если в записи среза используются отрицательные индексы, к ним добавляется длина последовательности. Если же метод __len__() не реализован, генерируется исключение AttributeError. Заметим, что нет никакой гарантии того, что после добавления длины последовательности индекс не будет отрицательным. Индексы, превышающие длину последовательности, остаются неизменными. Обратите внимание, что эти методы используются только для реализации операций с простой записью среза.
__getslice__(self, i, j)
Вызывается для реализации получения подпоследовательности (self[i:j]).
__setslice__(self, i, j, sequence)
Вызывается для реализации присваивания срезу, то есть замены подпоследовательности (‘self[i:j] = sequence’).
__delslice__(self, i, j)
Вызывается для реализации удаления подпоследовательности (‘del self[i:j]’).
Для реализации операций, касающихся расширенной записи срезов, используются методы __getitem__(), __setitem__() и __delitem__(). В этом случае в качестве ключа выступает объект типа slice, объект Ellipsis или кортеж из них (см. раздел 11.8.3). Если вы реализовали поддержку расширенной записи среза, то, начиная с версии 2.0, нет необходимости реализовывать методы __getslice__(), __setslice__() и __delslice__(): при их отсутствии автоматически будет вызван метод method__getitem__(), __setitem__() или __delitem__().
Следующий пример показывает, как Вы можете сохранить возможность работы Вашей программы (модуля) со старыми версиями интерпретатора (предполагается, что методы method__getitem__(), __setitem__() или __delitem__() поддерживают объекты, представляющие срез, в качестве аргумента):
class MyClass:
...
def __getitem__(self, item):
...
def __setitem__(self, item, value):
...
def __delitem__(self, item):
...
if sys.hexversion<0x020000F0:
# Эти методы не будут определены, если
# используется версия 2.0 (финальная) или новее
def __getslice__(self, i, j):
return self[max(0, i):max(0, j):]
def __setslice__(self, i, j, seq):
self[max(0, i):max(0, j):] = seq
def __delslice__(self, i, j):
del self[max(0, i):max(0, j):]
...
Обратите внимание на использование функции max(). В то время как методы __*item__() всегда получают индексы без изменений, перед вызовом методов __*slice__() к отрицательным индексам добавляется длина последовательности. После такого преобразования индекс может остаться отрицательным и быть неверно интерпретирован метами __*item__(). Использование max(0, i) гарантирует, что индексы всегда будут интерпретироваться корректно.
Оператор in реализуется путем перебора элементов последовательности и сравнения их с искомым значением. Однако для некоторых последовательностей его можно реализовать более эффективно. Для этих целей в версии 1.6 добавлен еще один специальный метод:
__contains__(self, item)
Вызывается для реализации операторов in и not in (‘item in self’, ‘item not in self’). До версии 1.6, а также если метод __contains__ не определен, для реализации этих операторов используется последовательный перебор элементов последовательности и сравнение их с искомым значением. Операторы in и not in всегда возвращают 0 или 1, определяющие истинность возвращаемого методом __contains__ объекта (см. раздел 10.2.5).
Приведение объектов к базовым типам
В этом разделе описаны специальные методы, реализующие приведение объектов к строковому и числовым типам. Для того, чтобы объект можно было привести к встроенным типам последовательностей, достаточно определить специальные методы __len__() и __getattr__() (см. раздел 11.6.3).
Строковое представление
__repr__(self)
Вызывается встроенной функцией repr() и при использовании обратных кавычек (‘expr‘) (а также функцией str() и инструкцией print, если метод __str__() не определен) для получения формального строкового представления объекта. Обычно такое представление должно выглядеть как выражение языка Python, пригодное для создания объекта с тем же самым значением. По традиции, объекты, для которых нельзя получить такое строковое представление достаточно простым способом, дают строку вида ’<полезная информация>’ (представление такого вида будет получено для экземпляра класса, если он не имеет метода __repr__()).
__str__(self)
Вызывается встроенной функцией str(), инструкцией print и оператором форматирования с символом формата ‘s’ для получения строкового представления, наиболее пригодного для вывода.
__oct__(self)
__hex__(self)
Вызываются для реализации встроенных функций oct() и hex() соответственно. Должны возвращать строковое значение.
Приведение к числовым типам
__complex__(self)
__int__(self)
__long__(self)
__float__(self)
Вызывается при использовании встроенных функций complex(), int(), long(), и float(), а также оператора форматирования с символами формата, отличными от ‘s’. Должны возвращать значение соответствующего типа.
Арифметические и битовые операции
Определение описанных в этом разделе методов позволит производить над объектами соответствующие арифметические и битовые операции привычным способом, то есть, используя операторы и встроенные функции.
Унарные операции
__neg__(self)
__pos__(self)
__invert__(self)
__abs__(self)
Вызывается для реализации унарных операторов -, +, ~ и встроенной функции abs().
Бинарные операции
Для того, чтобы вычислить выражение x op y, предпринимаются следующие шаги (__op__() и __rop__() — методы, реализующие оператор op, например, __add__() и __radd__() реализуют оператор +):
__coerce__(self, other)
Вызывается для приведения операндов к общему [Иногда полезно возвратить значения разного типа, например список и целое число.] типу. Должен возвращать кортеж, содержащий self и other, приведенные к общему типу, или None, если осуществить преобразование невозможно. В тех случаях, когда общий тип будет типом второго аргумента (other), эффективнее вернуть None, так как интерпретатор также будет пытаться вызвать метод __coerce__ второго аргумента (иногда, однако, реализация другого типа не может быть изменена, в этом случае полезно осуществить приведение к типу второго аргумента здесь).
__add__(self, other)
__sub__(self, other)
__mul__(self, other)
__div__(self, other)
__mod__(self, other)
__divmod__(self, other)
__pow__(self, other [, modulo])
__lshift__(self, other)
__rshift__(self, other)
__and__(self, other)
__xor__(self, other)
__or__(self, other)
Вызываются (для правого операнда) для реализации бинарных операторов +, -, *, /, %, встроенной функции divmod(), оператора ** и встроенной функции pow(), операторов <<, >>, &, ^ и | соответственно. Например, для того чтобы вычислить выражение x+y, где x является экземпляром класса, имеющим метод __add__, вызывается x.__add__(y). Обратите внимание, что, если должен поддерживаться вызов встроенной функции pow() с тремя аргументами, метод __pow__() должен быть определен с третьим необязательным аргументом.
__radd__(self, other)
__rsub__(self, other)
__rmul__(self, other)
__rdiv__(self, other)
__rmod__(self, other)
__rdivmod__(self, other)
__rpow__(self, other)
__rlshift__(self, other)
__rrshift__(self, other)
__rand__(self, other)
__rxor__(self, other)
__ror__(self, other)
Вызываются (для левого операнда) для реализации перечисленных выше операций, если правый операнд не имеет соответствующего метода (без буквы ‘r’). Например, для того чтобы вычислить выражение x-y, где y является экземпляром класса, имеющим метод __rsub__, вызывается y.__rsub__(x). Обратите внимание, что функция pow(), вызванная с тремя аргументами, не будет пытаться использовать метод __rpow__() (правила приведения типов были бы слишком сложными).
__iadd__(self, other)
__isub__(self, other)
__imul__(self, other)
__idiv__(self, other)
__imod__(self, other)
__ipow__(self, other)
__ilshift__(self, other)
__irshift__(self, other)
__iand__(self, other)
__ixor__(self, other)
__ior__(self, other)
Вызываются для реализации операций с присваиванием (изменением исходного объекта) +=, -=, *=, /=, %=, **= <<=, >>=, &=, ^= и |= соответственно. Эти методы должны не возвращать результат, а модифицировать объект, к которому метод применяется. Если соответствующий метод не определен, операция ‘x op= y’ выполняется как ‘x = x op y’.
Объекты типа file создаются встроенной функцией open() (см. главу 12), а также с помощью функций os.popen() и os.fdopen() (см. описание модуля os). Кроме того, различные модули предоставляют пути создания объектов с аналогичным интерфейсом (например, метод makefile() объектов, представляющих сетевое соединение). Переменные sys.stdin, sys.stdout и sys.stderr (см. описание модуля sys) инициализируются файловыми объектами, соответствующими стандартным потокам ввода, вывода и ошибок.
Если при выполнении операции над объектом-файлом возникает ошибка вводавывода, включая ситуации, при которых по каким-либо причинам операция не определена (например, метод seek() файлового объекта, представляющего устройство tty, или запись в файл, открытый для чтения), генерируется исключение IOError.
Объекты file имеют следующие методы:
close()
Закрывает файл. При попытке произвести какую-либо операцию над закрытым файлом генерируется исключение ValueError. Допускается вызов метода close() более одного раза.
flush()
Сбрасывает содержимое внутреннего буфера.
isatty()
Возвращает истину, если файл соответствует устройству tty, иначе возвращает 0 (ложь). Если объект с интерфейсом, характерным для файловых объектов, не ассоциирован с реальным файлом, для него этот метод не должен быть реализован.
fileno()
Возвращает дескриптор файла (целое число), используемый для запросов к операционной системе для выполнения операций ввода/вывода. Может быть полезен для выполнения операций низкого уровня, использующих дескрипторы (например, определенные в модулях os и fcntl). Если объект с интерфейсом, характерным для файловых объектов, не ассоциирован с реальным файлом, для него этот метод не должен быть реализован.
read([size])
Считывает не более size байт из файла (меньше, если конец файла достигается раньше, чем прочитано size байт). Если аргумент size опущен или отрицательный, считывается все содержимое файла. Считанные байты возвращаются в виде строкового объекта. Для некоторых файлов (например, устройства tty) вполне осмысленно продолжение чтения после достижения конца файла.
readline([size])
Считывает и возвращает строку из файла, включая завершающий символ новой строки [Основным достоинством того, что завершающий символ строки остается в возвращаемой строке, является возможность использования пустой строки для обозначения достижения конца файла.] (в последней строке файла он может отсутствовать). Если задан неотрицательный аргумент size, считывается не более size байт (учитывая завершающий символ новой строки). В этом случае возвращаемая строка может быть неполной.
readlines([sizehint])
Считывает все содержимое файла и возвращает список строк. Если задан неотрицательный аргумент sizehint, считывает (по сумме длин строк) примерно sizehint байт (sizehint округляется в большую сторону таким образом, чтобы значение было кратным размеру внутреннего буфера). Объекты с интерфейсом, характерным для файловых объектов, могут игнорировать значение sizehint.
seek(offset [, whence])
Устанавливает текущую позицию в файле. Необязательный аргумент whence указывает на точку отсчета: 0 (по умолчанию) — начало файла, 1 — текущая позиция и 2 — конец файла.
tell()
Возвращает текущую позицию в файле.
truncate([size])
Усекает файл до заданного (size) размера. По умолчанию размер равен текущей позиции. Наличие этого метода зависит от операционной системы.
write(s)
Записывает строку s в файл. Заметим, что из-за использования буферизации строка на самом деле может не быть записана в файл до тех пор, пока не будет вызван метод flush() или close().
writelines(slist)
Записывает строки из списка slist в файл. Метод writelines() не добавляет разделители строк. Начиная с версии 1.6, slist может быть последовательностью любого типа, не обязательно list.
Файловые объекты также имеют следующие атрибуты:
closed
Текущее состояние файлового объекта: истина, если файл закрыт, иначе ложь. Доступен только для чтения, значение изменяется при использовании метода close(). Этого атрибута может не быть у объектов, аналогичных файловым.
mode
Режим ввода/вывода. Если файловый объект был создан с помощью встроенной функции open(), равен переданному ей аргументу mode. Доступен только для чтения. Этого атрибута может не быть у объектов, аналогичных файловым.
name
Если файловый объект был создан с помощью встроенной функции open(), равен имени файла. В противном случае, равен строке, которая указывает на происхождение файлового объекта, в виде ‘<происхождение>’. Доступен только для чтения.
softspace
Показывает, должен ли выводиться пробел перед выводом следующего значения с помощью инструкции print (истина) или нет (ложь). При создании собственных типов файловых объектов следует позаботиться о наличии доступного для записи атрибута softspace, который должен быть инициализирован нулем. Для классов, реализованных на языке Python, это происходит автоматически.
Тип None принимает единственное значение, и существует единственный объект этого типа, который доступен через встроенное имя None. Объект None используется для указания на отсутствие значения во многих ситуациях (например, если функция не возвращает явно никакого значения). Значение None всегда ложно.
Объекты типа (type) представляют типы различных объектов. Вы можете получить объект типа для любого объекта (в том числе и для самого объекта типа) с помощью встроенной функции type(). В стандартном модуле types определены объекты типа для всех встроенных типов.
Объекты типа имеют следующие атрибуты, доступные только для чтения:
__doc__
Строка документации, описывающая назначение объектов данного типа, или None.
__name__
Имя типа. Именно эти имена используются в настоящей книге: Вы можете найти описание любого встроенного типа, воспользовавшись предметным указателем.
Строковое представление объектов типа выводится (например, инструкцией print) в виде <type 'имя типа'>.
Эллипсис
Тип ellipsis принимает единственное значение, и существует единственный объект этого типа, который доступен через встроенное имя Ellipsis. Объект Ellipsis используется для указания на использование эллипсиса (‘...’) в расширенной записи среза. Значение объекта Ellipsis всегда истинно.
Срез
Объекты типа slice используются для представления расширенной записи срезов, то есть, если срез записывается с использованием двух символов двоеточия (obj[i:j:s]), указывается несколько срезов или используется эллипсис (obj[i:j, k:l], obj[..., i:j]). Кроме того, Вы можете создать объект slice, используя встроенную функцию slice().
Объекты среза имеют следующие атрибуты, доступные только для чтения (каждый из них может быть любого типа и равен None, если соответствующий аргумент в записи среза ‘start:stop:step’ опущен):
start
Нижняя граница.
stop
Верхняя граница.
step
Шаг.
Фактически объект среза представляет множество индексов ‘range(start, stop, step)’.
Объекты кода (code) используются для представления байт-компилированного исполняемого кода, такого как тело функции. Разница между объектом-кодом и объектомфункцией состоит в том, что объект-функция содержит явную ссылку на словарь, представляющий глобальное пространство имен модуля, в котором определена функция, в то время как объект-код “не знает” контекста, в котором он будет выполняться. Кроме того, значения аргументов по умолчанию сохраняются в объекте-функции, так как они вычисляются во время выполнения. Объект-код, в отличие от объекта-функции, неизменяем и не содержит ссылок (прямо или косвенно) на изменяемые объекты.
Объект-код создается с помощью встроенной функции compile(), а также может быть извлечен из объекта-функции используя его атрибут func_code. Объект-код можно выполнить с помощью инструкции exec или вычислить представляемое им выражение с помощью встроенной функции eval().
Объекты кода имеют следующие атрибуты, доступные только для чтения:
co_name
Содержит имя функции (или ’?’, если объект-код создан с помощью функции compile()).
co_argcount
Число позиционных аргументов функции (включая аргументы, имеющие значения по умолчанию).
co_nlocals
Число локальных переменных (включая аргументы функции).
co_varnames
Кортеж, содержащий имена локальных переменных.
co_code
Строка, представляющая последовательность байт-компилированных инструкций.
co_consts
Кортеж, содержащий значения используемых литеральных выражений.
co_names
Кортеж всех используемых в байт-коде имен.
co_filename
Имя файла, из которого объект-код был скомпилирован.
co_firstlineno
Номер первой строки определения функции в файле.
co_lnotab
Строка, представляющая отображение смещения в байт-коде в номера строк (пустая строка, если включена оптимизация).
co_stacksize
Необходимый для выполнения размер стека (включая локальные переменные).
co_flags
Число, представляющее различные флаги интерпретатора. Для co_flags определены следующие биты (наиболее важные): бит 0x04 установлен, если функция использует запись ‘*args’ (воспринимает произвольное число позиционных аргументов); бит 0x08 установлен, если функция использует запись ‘**kwds’ (воспринимает произвольное число именованных аргументов).
Если объект кода представляет функцию, то первый элемент кортежа co_consts всегда является строкой документации (или None, если строка документации не определена).
Объект frame представляет кадр стека функции, “окружение”, в котором выполняются инструкции кода. Вы можете получить объект кадра стека через атрибут tb_frame объекта traceback (см. раздел 11.9.3). Объекты frame имеют следующие атрибуты (атрибутам f_trace, f_exc_type, f_exc_value и f_exc_traceback можно присвоить новое значение, остальные доступны только для чтения):
f_back
Ссылка на предыдущий кадр стека (то есть, если мы рассматриваем кадр стека функции func, то этот атрибут ссылается на кадр стека функции, вызвавшей функцию func) или None, если рассматриваемый кадр стека является последним (то есть относится не к функции, а к коду, исполняемому в глобальной области видимости).
f_code
Объект кода (см. раздел 11.9.1), который выполняется в рассматриваемом кадре стека.
f_locals
Словарь, используемый для поиска локальных имен.
f_globals
Словарь, используемый для поиска глобальных имен.
f_builtins
Словарь, используемый для поиска встроенных имен.
f_restricted
Флаг, указывающий на то, что функция выполняется в защищенном режиме.
f_lineno
Номер последней выполненной в рассматриваемом кадре стека строки.
f_lasti
Номер последней выполненной в рассматриваемом кадре стека инструкции байткода (может использоваться в качестве индекса для строки байт-кода объекта code).
f_trace
Функция, которая будет вызываться в начале каждой строки исходного кода, или None (используется отладчиком).
f_exc_type
f_exc_value
f_exc_traceback
Эти атрибуты представляют последнее перехваченное в рассматриваемом кадре исключение.
Объект traceback представляет путь, пройденный с момента генерации исключения до его перехвата. Таким образом, он создается при возникновении исключительной ситуации. Вы можете получить объект traceback в качестве третьего элемента кортежа, возвращаемого функцией sys.exc_info() (см. описание модуля sys). Если программа не содержит подходящего обработчика исключения, информация, хранящаяся в объекте traceback, выводится в стандартный поток ошибок. В интерактивном режиме объект traceback для последнего не перехваченного исключения доступен через переменную sys.last_traceback.
Объекты traceback имеют следующие атрибуты, доступные только для чтения:
tb_next
Ссылка на объект traceback, представляющий следующий уровень на пути в сторону кадра стека, в котором возникла исключительная ситуация, или None, если рассматриваемый объект представляет последний уровень.
tb_frame
Ссылка на кадр стека, представляющего текущий уровень.
tb_lineno
Номер строки (на текущем уровне), в которой возникла исключительная ситуация.
tb_lasti
Номер (на текущем уровне) инструкции байт-кода, которая привела к возникновению исключительной ситуации (может использоваться в качестве индекса для строки байт-кода объекта code).
Значения атрибутов tb_lineno и tb_lasti объекта traceback могут отличаться от значений атрибутов f_lineno и f_lasti объекта frame, если исключительная ситуация возникла в теле инструкции try без подходящей ветви except или имеющей ветвь finally.
Существует некоторый набор функций, встроенных в интерпретатор и, таким образом, всегда доступных для использования. Ниже приведены все встроенные функции в алфавитном порядке.
__import__(name [, globals [, locals [fromlist]]])
Эта функция вызывается инструкцией import. Вы можете заменить ее другой функцией, имеющей совместимый с __import__() интерфейс для того, чтобы изменить семантику инструкции import. Чтобы получить представление как и зачем это следует делать, смотрите описание стандартных модулей ihooks и rexec. Обратите также внимание на встроенный модуль imp, в котором определены некоторые операции, полезные для написания собственной функции __import__. Например, инструкция ‘import spam’ приводит к выполнению ‘__import__(’spam’, globals(), locals(), [])’, а инструкция ‘from spam.ham import eggs’ — к выполнению ‘__import__(’spam.ham’, globals(), locals(), [’eggs’])’. Несмотря на то, что locals() и [’eggs’] передаются в качестве аргументов, сама функция __import__() не устанавливает локальную переменную eggs. На самом деле, стандартная функция __import__() вообще не использует аргумент locals, а аргумент globals использует только для определения контекста инструкции import.
Если аргумент name задан в виде ’пакет.модуль’ и список fromlist пустой, функция __import__() возвращает объект-модуль, соответствующий имени ’пакет’ (часть имени name до первой точки), а не объект-модуль с именем name. Однако, если задан не пустой аргумент fromlist, функция __import__() возвращает объект-модуль, соответствующий имени name. Это сделано для совместимости байт-кода, сгенерированного для разных вариантов инструкции import: при использовании ‘import spam.ham.eggs’, объект модуль spam должен быть помещен в пространство имен, соответствующее области видимости, в котором выполняется инструкция import, в то время как при использовании ‘from spam.ham import eggs’, объект-модуль spam.ham должен быть использован для поиска объекта eggs. Для получения объекта Вы можете воспользоваться встроенной функцией getattr(), например:
import string
def my_import(name):
mod = __import__(name)
components = string.split(name, '.')
for comp in components[1:]:
mod = getattr(mod, comp)
return mod
abs(x)
Возвращает абсолютное значение аргумента. Для комплексных чисел возвращает x*x.conjugate(). Поведение функции abs() применительно к экземплярам определяется специальным методом __abs__() (см. раздел 11.6.3).
apply(object, args [, keywords])
Аргумент object должен быть объектом, поддерживающим вызов (см. раздел 11.4) и аргумент args должен быть последовательностью (если args не является кортежем, последовательность сначала преобразуется в кортеж). Необязательный аргумент keywords должен быть словарем, ключи которого являются строками. Возвращает результат вызова функции object с позиционными аргументами args и именованными аргументами keywords. Начиная с версии 1.6, тот же результат Вы можете получить, используя расширенную запись вызова: ‘object(*args, **keywords)’.
buffer(object [, offset[, size]])
Создает и возвращает объект buffer, который ссылается на object (см. раздел 11.2.5). object должен быть объектом, поддерживающим соответствующий интерфейс (string, unicode, array, buffer). Объект buffer представляет срез от offset (или от начала, если аргумент offset опущен) длиной size (до конца объекта object, если аргумент size опущен).
callable(object)
Возвращает истину, если аргумент object поддерживает вызов, иначе возвращает ложь (см. также раздел 11.4).
chr(i)
Возвращает строку, состоящую из одного символа, код которого равен i. Например, chr(97) возвращает строку ’a’. Аргумент i должен быть целым числом от 0 до 255 включительно, если i выходит за пределы указанного диапазона, генерируется исключение ValueError. Обратная операция выполняется функцией ord(). См. также описание функции unichr().
cmp(x, y)
Сравнивает объекты x и y и возвращает целое число: отрицательное, если x < y, ноль, если x == y, и положительное, если x > y.
coerce(x, y)
Пытается привести объекты x и y к общему типу используя такие же правила, как и для арифметических операций, и возвращает результат в виде кортежа из двух объектов. Если оба аргумента являются экземплярами класса, специальный метод __coerce__() вызывается только для первого.
compile(string, filename, kind)
Компилирует строку string и возвращает объект кода (см. раздел 11.9.1). Аргумент filename указывает имя файла, из которого создается объект кода. Используйте строку вида ’<источник>’, если исходный текст берется не из файла (например, ’<string>’). Аргумент kind указывает какого рода объект кода должен быть создан: используйте ’exec’, если string состоит из последовательности инструкций, ’eval’, если string содержит единственное выражение, или ’single’, если string содержит одну инструкцию для интерактивного режима (в последнем случае результат выполнения инструкции-выражения отличный от None будет выведен в стандартный поток вывода).
complex(real [, imag])
Преобразует аргумент числового типа real к комплексному типу, добавляет к нему imag*j (аргумент imag должен быть числового типа, по умолчанию равен нулю) или преобразует строку real в комплексное число (аргумент imag при этом игнорируется) и возвращает результат.
delattr(object, name)
Удаляет атрибут с именем name (строка) у объекта object, если объект позволяет это сделать. Например, вызов ‘delattr(x, 'foobar')’ эквивалентен инструкции ‘del x.foobar’.
dir([object])
Без аргументов, возвращает список имен, определенных в локальной области видимости (с точностью до порядка следования, эквивалентно locals().keys()). С заданным аргументом, возвращает список атрибутов объекта object. Эта информация собирается из атрибутов объекта __dict__, __methods__ и __members__, если они определены. Заметим, что функция dir() выдает список лишь тех атрибутов, которые определены непосредственно для объекта object. Так, например, применительно к классу, не включаются атрибуты, определенные для базовых классов, а применительно к экземплярам, не включаются атрибуты класса. Имена в возвращаемом списке располагаются в алфавитном порядке.
divmod(a, b)
Возвращает кортеж из двух чисел [Могут быть произвольного типа, если a или b является экземпляром класса с методом __divmod__ и __rdivmod__ соответственно.]: целой части и остатка при делении a на b. К операндам применяются обычные правила приведения к общему типу, как и при выполнении других арифметических операций. Если оба операнда целые (int или long int), результат будет равен ‘(a / b, a % b)’. Для чисел с плавающей точкой результат будет равен ‘(q, a % b)’, где q (типа float) обычно равно ‘math.floor(a / b)’, но может быть на единицу меньше. В любом случае, значение выражения ‘q * b + a % b’ очень близко к a, а ‘a % b’ (если не равно нулю) имеет тот же знак, что и b. Кроме того, всегда выполняется условие ‘0 <= abs(a % b) < abs(b)’.
eval(expression [, globals [, locals]])
Строка expression разбирается и вычисляется ее значение как выражения на языке Python, используя словари globals и locals в качестве глобального и локального пространств имен. Если опущен аргумент locals, он считается равным globals. Если опущены оба необязательных аргумента, выражение вычисляется в том окружении, из которого была вызвана функция eval(). Возвращает результат вычисления выражения. Например:
>>> x = 1 >>> eval(’x+1’) 2
Функция может быть также использована для вычисления байт-компилированного с помощью функции compile() (аргумент kind должен быть равен ’eval’) выражения. В этом случае аргумент expression должен быть объектом кода. См. также описание инструкции exec (раздел 10.3) и функций execfile(), globals() и locals().
execfile(file [, globals [, locals]])
Эта функция является аналогом инструкции exec, но обрабатывает файл вместо строки. От инструкции import она отличается тем, что не использует управление модулями — считывает файл независимо от каких-либо условий, не создает (и не использует) байт-компилированную версию файла и не создает объект-модуль.
Файл с именем file считывается, разбирается и выполняется как последовательность инструкций языка Python (аналогично модулям), используя словари globals и locals в качестве глобального и локального пространств имен. Если опущен аргумент locals, он считается равным globals. Если опущены оба необязательных аргумента, выражение вычисляется в том окружении, из которого была вызвана функция execfile().
filter(function, list)
Возвращает список из тех элементов последовательности list, для которых функция function (любой объект, поддерживающий вызов с одним аргументом, или None) возвращает истину. Если list является строкой (string) или кортежем, результат будет иметь тот же тип. В противном случае возвращаемое значение будет иметь тип list. Если аргумент function равен None, возвращаемый список будет содержать элементы последовательности list, являющиеся истиной.
float(x)
Преобразует строку или число (кроме комплексного) к вещественному типу и возвращает результат. Если аргумент является строкой, он должен содержать только десятичную запись целого или вещественного числа, заключенную, возможно, в символы пропуска (whitespace). Заметим, что ограничения, накладываемые на аргумент-строку, зависят от реализации библиотеки языка C. Экземпляры классов также могут быть преобразованы к вещественному типу, если для них определен специальный метод __float__.
getattr(object, name [, default])
Возвращает значение атрибута с именем name объекта object. Если object не имеет атрибута с именем name (строка), возвращается значение необязательного аргумента default (если он задан) или генерируется исключение AttributeError.
globals()
Возвращает словарь, представляющий глобальное пространство имен текущего модуля (внутри функции — это глобальное пространство имен модуля, в котором определена функция, а не тот, в котором она используется).
hasattr(object, name)
Возвращает 1, если объект object имеет атрибут с именем name (строка), иначе возвращает 0. Функция реализована следующим образом: производится попытка получить значение атрибута с указанным именем и, если генерируется (любое) исключение, то считается, что объект не имеет атрибута с таким именем.
hash(object)
Возвращает хэш-значение объекта object. Если для объекта не может быть получено хэш-значение, генерирует исключение TypeError. Хэш-значения используются для быстрого сравнения ключей при поиске в словарях. Равные объекты (в том числе и разного типа, например, 1 и 1.0) должны иметь равные хэш-значения.
hex(x)
Возвращает шестнадцатеричное представление целочисленного (int или long int) аргумента. Результат является правильным литеральным выражением языка Python (для длинного целого в конце будет добавлен суффикс ‘L’). Заметим, что результат всегда беззнаковый, например, на 32-разрядных платформах hex(-1) дает ’0xffffffff’. При использовании результата в качестве литерального выражения на платформе с таким же размером слова, Вы получите -1. На платформах с другим размером слова Вы можете получить большое положительное число или будет сгенерировано исключение OverflowError.
id(object)
Возвращает идентификатор объекта object — целое число (типа int или long int). Гарантируется уникальность идентификатора на всем протяжении жизни объекта. Два объекта, промежутки времени существования которых не пересекаются, могут иметь одинаковые идентификаторы. В настоящее время идентификатор является адресом объекта.
input([prompt])
Эквивалентно eval(raw_input(prompt)) (запрашивает выражение, вычисляет и возвращает его значение).
int(x [, radix])
Преобразует строку или число (любого типа, кроме комплексного) x в простое целое (int). Если аргумент x является строкой, он должен содержать только десятичную запись целого числа, заключенную, возможно, в символы пропуска (whitespace). В этом случае, начиная с версии 1.6, Вы можете задать другое основание системы счисления radix (в более ранних версиях, Вы можете воспользоваться функцией string.atoi) от 2 до 36 включительно [10 цифр плюс 26 букв латинского алфавита.] или 0. Если аргумент radix равен нулю, основание системы исчисления (8, 10 или 16) определяется автоматически исходя из записи числа аналогично тому, как обрабатываются числовые литеральные выражения. Если задан аргумент radix, а x не является строкой, генерирует исключение TypeError. Преобразование вещественных чисел зависит от реализации библиотеки языка C. Обычно число округляется в сторону нуля [Такое поведение неприятно — определение языка должно требовать округления в сторону нуля.].
intern(string)
Добавляет строку string в специальную таблицу строк (если такой строки там не было) и возвращает тот же объект-строку или возвращает строку с таким же значением, ранее помещенную в эту таблицу. Это позволяет немного повысить производительность при поиске по ключу в словарях благодаря тому, что сравнение таких строк можно производить по идентификаторам (вместо обычного лексикографического сравнения). Эта процедура выполняется автоматически для всех имен, используемых в программах на языке Python, для ускорения поиска в словарях, представляющих пространства имен модулей, классов и экземпляров классов. Строки, помещенные в специальную таблицу, никогда не уничтожаются.
isinstance(object, class)
Возвращает 1, если object является (прямо или косвенно) экземпляром класса class или является объектом типа class, иначе возвращает 0. В первом случае результат будет таким же, как и у выражения ‘issubclass(object.__class__, class)’, во втором—таким же, как и у выражения ‘type(object) is class’. Если class не является объектом-классом или объектом-типом, генерирует исключение TypeError.
issubclass(class1, class2)
Возвращает 1, если класс class1 является (прямо или косвенно) производным от класса class2. Считается, что класс также является производным от самого себя. Если какой-либо аргумент не является объектом-классом, генерируется исключение TypeError.
len(object)
Возвращает длину (количество элементов) объекта. Аргумент может быть последовательностью, отображением или экземпляром класса, для которого определен специальный метод __len__().
list(sequence)
Возвращает список, составленный из элементов последовательности sequence. Порядок следования элементов сохраняется. Если последовательность sequence уже является списком, возвращается его копия (аналогично sequence[:]). Например, list('abc') возвращает ['a', 'b', 'c'], а list((1, 2, 3)) возвращает [1, 2, 3].
locals()
Возвращает словарь, представляющий локальное пространство имен. Не следует изменять его, внесенные изменения могут не отразиться на значениях локальных переменных, используемых интерпретатором.
long(x [, radix])
Преобразует строку или число (любого типа, кроме комплексного) x в длинное целое (long int). Если аргумент x является строкой, он должен содержать только десятичную запись целого числа (сразу после последней цифры может присутствовать символ ‘l’ или ‘L’), заключенную, возможно, в символы пропуска (whitespace). В этом случае, начиная с версии 1.6, Вы можете задать другое основание системы счисления radix (в более ранних версиях, Вы можете воспользоваться функцией string.atol) от 2 до 36 включительно или 0. Если аргумент radix равен нулю, основание системы исчисления (8, 10 или 16) определяется автоматически исходя из записи числа аналогично тому, как обрабатываются числовые литеральные выражения. Если задан аргумент radix, а x не является строкой, генерирует исключение TypeError. Преобразование вещественных чисел зависит от реализации библиотеки языка C. Обычно число округляется в сторону нуля. См. также описание функции int().
map(function, seq ...)
Последовательно применяет function (любой объект, поддерживающий вызов, или None) к каждому элементу последовательности seq и возвращает список результатов. Функции map() может быть передано более одной последовательности. В этом случае количество воспринимаемых объектом function аргументов должно быть равным количеству переданных последовательностей. Если один или несколько списков окажутся короче других, недостающие элементы будут считаться равными None. Если значение аргумента function равно None, подразумевается функция, возвращающая свой аргумент (для одной последовательности) или кортеж своих аргументов (для нескольких последовательностей). Аргументы-последовательности могут быть любого типа, результат всегда будет иметь тип list.
max(seq)
max(v1, v2 ...)
С единственным аргументом seq, возвращает наибольший элемент последовательности. Если последовательность пустая, генерируется исключение ValueError. Если задано несколько аргументов, возвращает наибольший из них.
min(seq)
min(v1, v2 ...)
С единственным аргументом seq, возвращает наименьший элемент последовательности. Если последовательность пустая, генерируется исключение ValueError. Если задано несколько аргументов, возвращает наибольший из них.
oct()
Возвращает восьмеричное представление целого (int или long int) аргумента. Результат является правильным литеральным выражением языка Python (для длинного целого в конце будет добавлен суффикс ‘L’). Заметим, что результат всегда беззнаковый, например, на 32-разрядных платформах oct(-1) дает ’037777777777’. См. также описание функции hex().
open(filename [, mode [, bufsize]])
Открывает файл и возвращает соответствующий ему файловый объект (см. раздел 11.7). filename — имя файла, mode — строка, указывающая, в каком режиме файл будет открыт. Возможные режимы: ’r’ — для чтения (файл должен существовать), ’w’ — для записи (если файл не существует, он создается, в противном случае его содержимое удаляется), ’a’ — для добавления в конец файла (если файл не существует, он создается; текущее положение в файле устанавливается указывающим на его конец; на некоторых платформах метод seek() игнорируется), ’r+’, ’w+’ и ’a+’ — для чтения и записи (для открытия в режиме ’r+’ файл должен существовать, в режиме ’w+’ содержимое существующего файла удаляется). При добавлении символа ‘b’ к режиму гарантируется, что файл будет открыт в двоичном режиме. На некоторых платформах файлы по умолчанию открываются в текстовом режиме, в котором операционная система автоматически заменяет некоторые символы. Во избежание возможной порчи данных лучше всегда принудительно выставлять двоичный режим (даже на платформах, где файл по умолчанию открывается в двоичном режиме — подумайте о переносимости Ваших программ). Если файл не может быть открыт, генерируется исключение IOError. Если аргумент mode опущен, он считается равным ’r’.
Необязательный целый аргумент bufsize указывает желаемый размер буфера: 0 означает отсутствие буферизации, 1 — построчная буферизация, любое другое положительное число означает буфер (примерно) указанного размера. Если bufsize опущен или меньше нуля, используется системное значение по умолчанию [На системах, библиотека языка C которых не имеет функцию setvbuf(), размер буфера, независимо от bufsize, будет иметь значение по умолчанию.]: обычно построчная буферизация для устройств tty и довольно большое значение для других файлов.
ord(c)
Возвращает код символа. Аргумент c должен быть строкой (string или unicode), состоящей из одного символа. Например, ord('a') возвращает 97, ord(u'\u2020') возвращает 8224. Обратное преобразование может быть выполнено с помощью функций chr() для обычных символов и unichr() для символов Unicode.
pow(x, y [, z])
С двумя аргументами возвращает x в степени y (эквивалентно ‘x ** y’). С заданным третьим аргументом, результат будет такой же, как и у выражения ‘pow(x, y) % z’, однако вычисление производится более эффективно. Со смешанными типами операндов, применяются обычные правила для арифметических операций. Эффективный тип операндов также является и типом результата. Если результат не может быть выражен в рамках этого типа, генерируется соответствующее ситуации исключение. Например, pow(2, -1) генерирует исключение ValueError, а pow(2, 35000) генерирует исключение OverflowError.
range([start,] stop [, step])
Эта гибкая функция создает и возвращает арифметическую прогрессию от start (включительно; по умолчанию 0) до stop (исключая само значение stop) с шагом step (по умолчанию 1; если задан шаг, аргумент start становится обязательным). Все аргументы должны быть простыми целыми (int), если аргумент step равен нулю, генерируется исключение ValueError. Если step — положительное число, последним элементом списка будет наибольшее число из ряда start + i * step, которое меньше, чем stop (i — натуральное число или ноль). Если step — отрицательное число, последним элементом списка будет наименьшее число из ряда start + i * step, которое больше stop. Несколько примеров:
>>> 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, его значение (точнее строковое представление, полученное аналогично тому, как это делают функция str() и инструкция print) выводится на стандартный поток вывода (в отличие от инструкции print, символ новой строки в конце не добавляется). Функция считывает строку из стандартного потока ввода и возвращает ее (исключая завершающий символ перехода на новую строку). Если при считывании достигается конец файла, генерируется исключение EOFError. Например:
>>> s = raw_input('--> ')
--> Monty Python’s Flying Circus
>>> s
"Monty Python’s Flying Circus"
Если загружен модуль readline, функция raw_input() будет использовать его, предоставляя возможности редактирования строки и использования истории введенных строк (некоторые операционные системы, например Windows NT, предоставляют аналогичные возможности автоматически).
reduce(function, sequence [, initializer])
Последовательно применяет function (объект, поддерживающий вызов с двумя аргументами) сначала к двум первым элементам последовательности sequence, затем к результату и третьему элементу и т. д. Например, ‘reduce(operator.__add__, [1, 2, 3, 4, 5])’ вычисляет сумму ((((1+2)+3)+4)+5). Если задан необязательный аргумент initializer, при вычислении он помещается перед первым элементом. Если общее количество элементов (initializer, если он задан, плюс элементы последовательности sequence) равно 1, возвращается его (единственного элемента) значение, если общее количество элементов равно 0 (то есть не задан аргумент initializer и используется пустая последовательность), генерируется исключение TypeError.
reload(module)
Заново считывает и инициализирует уже импортированный модуль. Аргумент module должен быть объектом-модулем, представляющим ранее успешно импортированный модуль. Возвращает объект-модуль (тот же самый, что и module). Эта функция может быть полезна при одновременном редактировании и тестировании в интерактивном режиме (не покидая интерпретатора) модулей.
Если в исходном тексте модуля нет синтаксических ошибок, но они возникают во время его инициализации, первая инструкция import для этого модуля не создаст соответствующую ему локальную переменную, а лишь сохранит (частично инициализированный) объект-модуль в sys.modules. Для того, чтобы перезагрузить модуль, необходимо сначала повторно импортировать с помощью инструкции import (при этом создается локальная переменная, ссылающаяся на частично инициализированный объект-модуль) и лишь затем использовать функцию reload().
При перезагрузке модуля старый словарь, представляющий глобальное пространство имен модуля сохраняется. Новые определения перезаписывают старые, так что это обычно не вызывает проблем. Если новая версия не определяет какое-либо имя, для него остается прежнее значение. Эта особенность может быть использована модулем, если он поддерживает глобальную таблицу или кэш объектов: с помощью инструкции try Вы можете определить наличие таблицы и, при желании, пропустить ее инициализацию.
Перезагрузка встроенных и динамически связываемых модулей в принципе допустима (кроме модулей sys, __main__ и __builtin__), однако не настолько полезна. Некоторые дополнительные модули, однако, не приспособлены к повторной инициализации, что может привести к всевозможным ошибкам.
Если Вы импортируете объекты из модуля, используя инструкцию ‘from ... import ...’, перезагрузка модуля не приведет к переопределению этих объектов—после перезагрузки необходимо повторно выполнить инструкцию ‘from ... import ...’.
Если Вы определили экземпляры класса, перезагрузка модуля, в котором определен класс, не изменит определения методов для экземпляров — они будут продолжать использовать старые определения. То же самое верно и для производных классов.
repr(object)
Возвращает строку, содержащую представление объекта object. Тот же эффект Вы можете получить, заключив выражение object в обратные кавычки (‘object‘). По возможности функция repr() возвращает строку, пригодную для восстановления объекта с тем же значением с помощью функции eval(). См. также описание функции str().
round(x [, n])
Возвращает вещественное число, полученное округлением x до n цифр после десятичной точки. По умолчанию n считается равным нулю. То есть возвращает ближайшее к x число, кратное 10-n. Из двух одинаково близких чисел выбирается то, которое находится дальше от нуля (то есть round(0.5) дает 1.0 и round(-0.5) дает -1.0).
setattr(object, name, value)
Присваивает атрибуту с именем name (строка) объекта object значение value. name может быть именем уже существующего или нового атрибута. Например, вызов ‘setattr(x, 'foobar', 123)’ эквивалентен инструкции ‘x.foobar = 123’.
slice([start,] stop [, step])
Возвращает объект среза (см. раздел 11.8.3). Если какой-либо необязательный аргумент опущен, используется None для обозначения значения по умолчанию.
str(object)
Возвращает строковое представление, наиболее пригодное для вывода. В отличие от repr(), функция str() даже не пытается создать строку, являющуюся правильным выражением языка Python. Точно такое представление используется для объектов при выводе их с помощью инструкции print.
tuple(sequence)
Возвращает кортеж, составленный из элементов последовательности sequence. Порядок следования элементов сохраняется. Если последовательность sequence уже является кортежем, он возвращается без изменений (нет смысла создавать его копию, так как кортежи являются неизменяемыми объектами) . Например, tuple('abc') возвращает ('a', 'b', 'c'), а tuple([1, 2, 3]) возвращает (1, 2, 3).
type(object)
Возвращает тип объекта object. Возвращаемое значение является объектом типа (см. раздел 11.8.2). В стандартном модуле types определены имена для всех встроенных типов. Например:
>>> import types >>> if type(x) == types.StringType: ... print "Объект x является строкой"
unichr(i)
Возвращает строку Unicode, состоящую из одного символа, код которого равен i. Например, unichr(97) возвращает строку u'a'. Аргумент i должен быть целым числом от 0 до 65535 включительно, если i выходит за пределы указанного диапазона, генерируется исключение ValueError. Обратная операция выполняется функцией ord(). См. также описание функции chr().
unicode(string [, encoding [, errors]])
Преобразует строку string из кодировки encoding (по умолчанию ’utf-8’) в строку Unicode и возвращает результат. Поведение при возникновении ошибок определяется значением аргумента errors: ’strict’ (используется по умолчанию) означает, что при возникновении ошибки будет сгенерировано исключение UnicodeError, ’ignore’ — недопустимые символы игнорируются (удаляются), ’replace’ — недопустимые символы заменяются универсальным символом замены (“REPLACEMENT CHARACTER”, u'\uFFFD').
vars([object])
Без аргументов возвращает словарь, соответствующий локальному пространству имен. Если в качестве аргумента передан объект, представляющий модуль, класс или экземпляр класса (или любой другой объект, имеющий атрибут __dict__), возвращает словарь, соответствующий пространству имен объекта. Не следует вносить изменения в возвращаемый словарь: эффект на соответствующее пространство имен не определен [В текущих реализациях локальные переменные не могут быть изменены таким способом, а пространства имен объектов — могут. Ситуация может измениться в будущих версиях.].
xrange([start,] stop [, step])
Эта функция работает аналогично функции range(), но возвращает объект xrange (см. раздел 11.2.4) вместо списка. Этот тип последовательности позволяет получать точно такие же значения, как и соответствующий список (полученный с помощью функции range() с такими же аргументами), на самом деле не храня их. Преимущества функции xrange() над функцией range() обычно минимальны и проявляются только на очень длинных рядах чисел.
zip(seq1 ...)
Возвращает список, каждый i-й элемент которого является кортежем, составленным из i-х элементов последовательностей seq1, ..., seqN в порядке их следования в списке аргументов. Требуется как минимум один аргумент, в противном случае, генерируется исключение TypeError. Длина возвращаемого списка равна длине самой короткой из последовательностей seq1, ..., seqN. Если все последовательности имеют одинаковую длину, функция zip ведет себя аналогично функции map с None в качестве первого аргумента. Функция доступна, начиная с версии 2.0.
Исключения в языке Python могут быть экземплярами классов и строками. Поддержка строк в качестве исключений оставлена для совместимости с ранними версиями и может быть удалена в будущем. Классы встроенных исключений определены в стандартном модуле exceptions. Нет необходимости явно импортировать этот модуль — все определенные в нем классы исключений всегда доступны аналогично другим встроенным объектам (определены в пространстве встроенных имен).
Если в ветви except инструкции try указывается объект-класс C, эта ветвь будет обрабатывать любое “совместимое” с указанным классом исключение, то есть если оно является экземпляром C или производного от него класса. Например, ветвь ‘except ValueError:’ будет обрабатывать исключения UnicodeError [Здесь и далее под “исключениями SomeError” или “исключениями типа SomeError” подразумеваются “исключения, являющиеся экземплярами класса SomeError”, если речь идет о генерируемом исключении, и “исключения, являющиеся экземплярами SomeError и производных от него классов”, если речь идет о перехватываемом исключении.], но ‘except UnicodeError:’ не будет перехватывать исключения ValueError. Два класса исключений, ни один из которых не является производным (прямо или косвенно) от другого, никогда не будут эквивалентными, даже если они имеют одинаковое имя (под именем исключения подразумевается имя класса, то есть значение атрибута __name__ объекта-класса).
Описанные ниже встроенные исключения генерируются интерпретатором, встроенными функциями и методами объектов встроенных типов. Исключения могут иметь ассоциированное с ним значение (аргумент или несколько аргументов, используемые при его инициализации), описывающее причину возникновения исключительной ситуации. Если класс исключения является производным от стандартного класса Exception, аргументы, используемые при инициализации, сохраняются в атрибуте args.
Пользовательский код также может генерировать исключения встроенных типов для тестирования обработчиков ошибок, а также, если необходимо сообщить об ошибке (или другой исключительной ситуации), для которой данный встроенный класс исключений предназначен.
Ниже приведена иерархия встроенных классов исключений.
Exception
Базовый класс для всех встроенных классов исключений. Рекомендуется также использовать его для всех пользовательских классов исключений. Атрибут args его экземпляров содержит список аргументов, которые использовались при его инициализации. Встроенная функция str(), при применении к экземплярам класса Exception, возвращает строковое значение аргумента (если при инициализации использовался один аргумент), кортежа аргументов (если при инициализации использовалось более одного аргумента) или пустую строку (если конструктор вызывался без аргументов). Кроме того, Вы можете получить доступ (только для чтения) к аргументам, используя операцию получения элемента по индексу (exc[i]).
StandardError
Базовый класс исключений, предназначенных для генерации при возникновении стандартных ошибок (то есть всех ошибок, которые могут возникнуть при использовании встроенных средств языка).
ArithmeticError
Базовый класс исключений, генерируемых при возникновении арифметических ошибок.
FloatingPointError
Исключения этого класса генерируются, если возникают проблемы с выполнением операции с плавающей точкой (могут генерироваться только если Python сконфигурирован с опцией --with-fpectl или в файле ‘config.h’ определено имя WANT_SIGFPE_HANDLER).
OverflowError
Используется, когда результат арифметической операции слишком большой, чтобы его можно было представить в рамках используемого типа. Заметим, что этого не может произойти при использовании длинного целого типа (long int) — скорее будет сгенерировано исключение MemoryError. Из-за того, что обработка ошибок при операциях с плавающей точкой в языке C не стандартизована, большинство таких операций не проверяются. Для обычных целых чисел (int), все операции, которые могут привести к переполнению, проверяются, за исключением сдвига влево, так как в этом случае потеря старших бит считается предпочтительнее генерации исключения.
ZeroDivisionError
Используется, если второй операнд операторов деления и получения остатка от деления равен нулю.
AssertionError
Исключения этого класса генерируются, если не выполняется условие, указанное в инструкции assert.
AttributeError
Исключения этого класса генерируются в случаях, когда невозможно получить значение атрибута с определенным именем, удалить его или присвоить ему новое значение. Если объекты данного типа вообще не поддерживают используемый доступ к атрибутам (получение значения, удаление или присваивание), генерируется исключение TypeError.
EOFError
Исключения этого класса генерируются некоторыми встроенными функциями (input(), raw_input()), если достигается конец файла и, при этом, из него не считано ни байта информации. Обратите внимание на то, что методы read() и readline() файловых объектов при достижении конца файла возвращают пустую строку.
EnvironmentError
Базовый класс исключений, генерируемых при ошибках, возникающих за пределами интерпретатора Python. Если при инициализации исключений этого типа используются 2 или 3 аргумента, первый из них считается кодом ошибки, второй — строкой, поясняющей причину ее возникновения, и третий (необязательный) — имя файла, с которым связана возникшая ошибка. В этом случае аргументы (помимо унаследованного атрибута args) сохраняются соответственно в атрибутах errno, strerror и filename и используются для создания строкового представления (функция str()) в виде ’[Errno errno] strerror’ или ’[Errno errno] strerror: filename’.
IOError
Используется при ошибках ввода/вывода, например, если не найден файл с указанным именем или на носителе нет свободного места.
OSError
Исключения этого класса (доступного также как os.error) в основном генерируются функциями модуля os.
WindowsError
Используется при ошибках, специфичных для операционных систем Windows или код ошибки не соответствует значению errno. Значения атрибутов errno и strerror создаются из значений, возвращаемых функциями Windows API GetLastError() и FormatMessage() соответственно. Добавлен в версии 1.6.
ImportError
Исключения этого класса генерируются, если модуль с указанным в инструкции import именем не может быть импортирован или в модуле не найдено имя, указанное в инструкции from ... import ....
KeyboardInterrupt
По умолчанию, если интерпретатор получает сигнал SIGINT, например, при прерывании с клавиатуры (обычно клавишами Ctrl-C), генерируется исключение KeyboardInterrupt. Вы можете изменить реакцию на сигнал SIGINT, воспользовавшись функцией signal.signal(). Прерывание в момент ожидания ввода, при использовании функций input() и raw_input(), а также методов read(), readline() и readlines() файлового объекта, представляющего устройство tty, также генерируется исключение KeyboardInterrupt [На самом деле, поведение зависит от используемой платформы. Например, под Windows NT при прерывании в момент работы функций input() и raw_input() сначала будет сгенерировано исключение EOFError.].
LookupError
Базовый класс исключений, генерируемых, если последовательность или отображение не содержит элемента с заданным индексом или ключом. Может быть сгенерировано напрямую функцией sys.setdefaultencoding().
IndexError
Используется в случаях, когда индекс, используемый для получения элемента последовательности, выходит за пределы диапазона. Заметим, что индексы среза в этом случае считаются указывающими на конец или начало последовательности, и ошибки не возникает. Если индекс не является обычным целым числом, генерируется исключение TypeError.
KeyError
Исключения этого класса генерируются, если в отображении не найдена запись с указанным ключом. В качестве аргумента при инициализации экземпляра исключения обычно используется ключ.
MemoryError
Используется, если для выполнения операции не хватает памяти, но из сложившейся ситуации еще можно выйти, удалив некоторые объекты. Экземпляр исключения может быть инициализирован строкой, указывающей род (внутренней) операции, для выполнения которой не хватило памяти. Заметим, что лежащая в основе интерпретатора архитектура управления памятью (функция malloc() языка C) не всегда позволяет полностью восстановиться из подобных ситуаций. В любом случае генерируется исключение MemoryError и сообщение об ошибке (включая информацию о месте ее возникновения) может быть выведена в стандартный поток ошибок.
NameError
Исключения этого класса генерируются, если используемое в программе локальное или глобальное имя не найдено. Это имя используется в качестве аргумента при инициализации экземпляра исключения.
UnboundLocalError
Используется в случае, если Вы неявно ссылаетесь на глобальную переменную (не использовав предварительно инструкцию global), а затем пытаетесь удалить ее или присвоить ей новое значение. Добавлен в версии 1.6.
RuntimeError
Используется при ошибках времени выполнения, которые не попадают ни в одну из описанных выше категорий. В качестве аргумента при инициализации используется строка с информацией об ошибке. Это исключение является пережитком прошлых версий языка и в настоящее время используется не слишком часто.
NotImplementedError
Исключения этого класса следует использовать при определении абстрактных методов пользовательских классов-интерфейсов для того, чтобы показать, что метод должен быть переопределен в производных классах.
SyntaxError
Используется синтаксическим анализатором при обнаружении синтаксических ошибок. Подобные ошибки могут возникнуть при использовании инструкций import и exec, функций eval() и input(), а также при чтении инструкций из файла или стандартного потока ввода (в том числе в интерактивном режиме).
Экземпляры этого класса исключений имеют атрибуты: filename и lineno — имя файла и номер строки в которых обнаружена ошибка, text — текст строки, содержащей ошибку, offset — место в строке, где ошибка была обнаружена синтаксическим анализатором, и msg — сообщение об ошибке. Экземпляр исключения инициализируется в виде ‘SyntaxError(msg, (filename, lineno, offset, text))’. Функция str(), применительно к экземплярам исключения, возвращает только сообщение об ошибке (атрибут msg).
SystemError
Исключения этого класса генерируются в случае обнаружения внутренних ошибок. В качестве аргумента при инициализации используется строка, с подробностями (используется терминология низкого уровня). О возникновении подобных ошибок следует сообщать авторам языка.
TypeError
Исключения этого класса генерируются, какая-либо операция применяется к объекту несоответствующего типа. В качестве аргумента при инициализации исключения используется строка, указывающая на детали несоответствия типа.
ValueError
Исключения этого класса генерируются, какая-либо операция применяется к объекту правильного типа, но имеющего несоответствующее значение, и ситуация не может быть описана более точно с помощью исключения другого типа (например, IndexError).
UnicodeError
Используется при ошибках преобразования строки в определенной кодировке в строку Unicode и наоборот. Добавлен в версии 1.6.
SystemExit
Исключения этого класса генерируются функцией sys.exit(). Если исключение не обрабатывается, выполнение программы молча прерывается. В качестве аргумента при инициализации используется целое число — код ошибки, передаваемый функции exit() языка C. По умолчанию и, если используется None, код завершения считается равным 0. Если при инициализации использован аргумент другого типа или несколько аргументов, аргумент или кортеж аргументов выводится в стандартный поток ошибок. В любом случае, аргумент или кортеж аргументов сохраняется в виде атрибута code. SystemExit является производным непосредственно от Exception, а не StandardError, так как фактически исключения SystemExit не являются ошибкой.
Вызов функции sys.exit() преобразуется в генерацию исключения для того, чтобы могла быть выполнена очистка (ветвь finally инструкции try) и отладчик мог выполнить программу без потери контроля. Если все же необходимо немедленно прервать выполнение программы (например, после вызова функции os.fork() в дочернем процессе), воспользуйтесь функцией os._exit().
Перейти на главную страничку сайта (список статей, файлы для скачивания)
© 2007 http://www.script-coding.com При любом использовании материалов сайта обязательна ссылка на него как на источник информации, а также сохранение целостности и авторства материалов.