Язык программирования Python - Роман Сузи 3 стр.

Взятие элемента по индексу и срезы

Здесь же следует сказать несколько слов об индексировании последовательностей и выделении подстрок (и вообще - подпоследовательностей) по индексам. Для получения отдельного элемента последовательности используются квадратные скобки, в которых стоит выражение, дающее индекс. Индексы последовательностей в Python начинаются с нуля. Отрицательные индексы служат для отсчета элементов с конца последовательности (-1 - последний элемент). Пример проясняет дело:

>>> s = [0, 1, 2, 3, 4]

>>> print s[0], s[-1], s[3]

0 4 3

>>> s[2] = -2

>>> print s

[0, 1, -2, 3, 4]

>>> del s[2]

>>> print s

[0, 1, 3, 4]

Примечание:

Удалять элементы можно только из изменчивых последовательностей и желательно не делать этого внутри цикла по последовательности.

Несколько интереснее обстоят дела со срезами. Дело в том, что в Python при взятии среза последовательности принято нумеровать не элементы, а промежутки между ними. Поначалу это кажется необычным, тем не менее, очень удобно для указания произвольных срезов. Перед нулевым (по индексу) элементом последовательности промежуток имеет номер 0, после него - 1 и т.д.. Отрицательные значения отсчитывают промежутки с конца строки. Для записи срезов используется следующий синтаксис:

последовательность[нач:кон:шаг]

где нач - промежуток начала среза, кон - конца среза, шаг - шаг. По умолчанию нач=0, кон=len(последовательность), шаг=1, если шаг не указан, второе двоеточие можно опустить.

А теперь пример работы со срезами:

>>> s = range(10)

>>> s

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> s[0:3]

[0, 1, 2]

>>> s[-1:]

[9]

>>> s[::3]

[0, 3, 6, 9]

>>> s[0:0] = [-1, -1, -1]

>>> s

[-1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> del s[:3]

>>> s

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Как видно из этого примера, с помощью срезов удобно задавать любую подстроку, даже если она нулевой длины, как для удаления элементов, так и для вставки в строго определенное место.

Тип dict

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

d = {1: 'one', 2: 'two', 3: 'three', 4: 'four'}

d0 = {0: 'zero'}

print d[1] # берется значение по ключу

d[0] = 0 # присваивается значение по ключу

del d[0] # удаляется пара ключ–значение с данным ключом

print d

for key, val in d.items(): # цикл по всему словарю

print key, val

for key in d.keys(): # цикл по ключам словаря

print key, d[key]

for val in d.values(): # цикл по значениям словаря

print val

d.update(d0) # пополняется словарь из другого

print len(d) # количество пар в словаре

Тип file

Объекты этого типа предназначены для работы с внешними данными. В простом случае - это файл на диске. Файловые объекты должны поддерживать основные методы: read(), write(), readline(), readlines(), seek(), tell(), close() и т.п.

Следующий пример показывает копирование файла:

f1 = open("file1.txt", "r")

f2 = open("file2.txt", "w")

for line in f1.readlines():

f2.write(line)

f2.close()

f1.close()

Стоит заметить, что кроме собственно файлов в Python используются и файлоподобные объекты. В очень многих функциях просто неважно, передан ли ей объект типа file или другого типа, если он имеет все те же методы (и в том же смысле). Например, копирование содержимого по ссылке (URL) в файл file2.txt можно достигнуть, если заменить первую строку на

import urllib

f1 = urllib.urlopen("http://python.onego.ru")

О модулях, классах, объектах и функциях будет говориться на других лекциях.

Выражения

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

Приоритет операций показан в нижеследующей таблице (в порядке уменьшения). Для унарных операций x обозначает операнд. Ассоциативность операций в Python - слева–направо, за исключением операции возведения в степень (**), которая ассоциативна справа налево.

Таким образом, порядок вычислений операндов определяется такими правилами:

1. Операнд слева вычисляется раньше операнда справа во всех бинарных операциях, кроме возведения в степень.

2. Цепочка сравнений вида a < b < c ... y < z фактически равносильна: (а < b) and (b < c) and ... and (y < z).

3. Перед фактическим выполнением операции вычисляются нужные для нее операнды. В большинстве бинарных операций предварительно вычисляются оба операнда (сначала левый), но операции or и and, а также цепочки сравнений вычисляют такое количество операндов, которое достаточно для получения результата. В невычисленной части выражения в таком случае могут даже быть неопределенные имена. Это важно учитывать, если используются функции с побочными эффектами.

4. Аргументы функций, выражения для списков, кортежей, словарей и т.п. вычисляются слева–направо, в порядке следования в выражении.

В случае неясности приоритетов желательно применять скобки. Несмотря на то, что одни и те же символы могут использоваться для разных операций, приоритеты операций не меняются. Так, % имеет тот же приоритет, что и *, а потому в следующем примере скобки просто необходимы, чтобы операция умножения произошла перед операцией форматирования:

print "%i" % (i*j)

Выражения могут фигурировать во многих операторах Python и даже как самостоятельный оператор. У выражения всегда есть результат, хотя в некоторых случаях (когда выражение вычисляется ради побочных эффектов) этот результат может быть "ничем" - None.

Очень часто выражения стоят в правой части оператора присваивания или расширенного присваивания. В Python (в отличие, скажем, от C) нет операции присваивания, поэтому синтаксически перед знаком = могут стоять только идентификатор, индекс, срез, доступ к атрибуту или кортеж (список) из перечисленного. (Подробности в документации).

Имена

Об именах (идентификаторах) говорилось уже не раз, тем не менее, необходимо сказать несколько слов об их применении в языке Python.

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

>>> import keyword

>>> keyword.kwlist

['and', 'assert', 'break', 'class', 'continue', 'def', 'del',

'elif', 'else', 'except', 'exec', 'finally', 'for', 'from',

'global', 'if', 'import', 'in', 'is', 'lambda', 'not', 'or',

'pass', 'print', 'raise', 'return', 'try', 'while', 'yield']

Имена, начинающиеся с подчеркивания или двух подчеркиваний, имеют особый смысл. Одиночное подчеркивание говорит программисту о том, что имя имеет местное применение, и не должно использоваться за пределами модуля. Двойным подчеркиванием в начале и в конце обычно наделяются специальные имена атрибутов - об этом будет говориться в лекции по объектно–ориентированному программированию.

В каждой точке программы интерпретатор "видит" три пространства имен: локальное, глобальное и встроенное. Пространство имен - отображение из имен в объекты.

Для понимания того, как Python находит значение некоторой переменной, необходимо ввести понятие блока кода. В Python блоком кода является то, что исполняется как единое целое, например, тело определения функции, класса или модуля.

Локальные имена - имена, которым присвоено значение в данном блоке кода. Глобальные имена - имена, определяемые на уровне блока кода определения модуля или те, которые явно заданы в операторе global. Встроенные имена - имена из специального словаря __builtins__.

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

Так как переменную можно связать с объектом в любом месте блока, важно, чтобы это произошло до ее использования, иначе будет возбуждено исключение NameError. Связывание имен со значениями происходит в операторах присваивания, for, import, в формальных аргументах функций, при определении функции или класса, во втором параметре части except оператора try–except.

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

1. Всегда следует связывать переменную со значением (текстуально) до ее использования.

2. Необходимо избегать глобальных переменных и передавать все в качестве параметров. Глобальными на уровне модуля должны остаться только имена–константы, имена классов и функций.

3. Никогда не следует использовать from модуль import * - это может привести к затенению имен из других модулей, а внутри определения функции просто запрещено.

Предпочтительнее переделать код, нежели использовать глобальную переменную Конечно, для программ, состоящих из одного модуля, это не так важно: ведь все определенные на уровне модуля переменные глобальны.

Убрать связь имени с объектом можно с помощью оператора del. В этом случае, если объект не имеет других ссылок на него, он будет удален. Для управления памятью в Python используется подсчет ссылок (reference counting), для удаления наборов объектов с зацикленными ссылками - сборка мусора (garbage collection).

Стиль программирования

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

Стиль программирования затрагивает практически все аспекты написания кода:

• именование объектов в зависимости от типа, назначения, области видимости;

• оформление функций, методов, классов, модулей и их документирование в коде программы;

• декомпозиция программы на модули с определенными характеристиками;

• способ включения отладочной информации;