Перейти на главную страничку сайта (список статей, файлы для скачивания)
Г. Россум, Ф.Л.Дж. Дрейк, Д.С. Откидач, Язык программирования 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.
Если д