Подсказки по программированию на языке Python для начинающих

Disclaimer: подсказки написаны в помощь начинающим с надеждой, что окажутся полезными, но написаны не-специалистом в языке Python. Если что-то не работает так, как тут написано, или возникают еще какие-то трудности, сообщайте о них пожалуйста на адрес udavdasha@fbb.msu.ru.

Совет по использованию в качестве справочника: попробуйте автоматический поиск на этой странице нужного названия (<Ctrl + F> и дальше ввод). Скорее всего, вы найдете или пример с употреблением искомого, или описание этого

Содержание

1. Вводные замечания

1.1. Основные понятия

Программа на языке Python называется скриптом. Текст программы иногда называют кодом.
Скрипт состоит из строк. Некоторые строки играют служебную роль, начиная особые блоки кода (они, даже включая команды, выполняются только в определенных условиях), но большинство строк представляют собой команды. Обычно в Python работает правило "1 строка = 1 команда"; знак конца строки в данном случае играет роль завершающего символа в команде. Обратите внимание: точку с запятой в конце команды, согласно правилам синтаксиса Python, ставить не обязательно, в отличие от подавляющего большинства других языков программирования.
Если в строке требуется записать несколько команд, то они должны разделяться знаком точки с запятой (;).
Специальная программа, называемая интерпретатором, вызывается всякий раз когда Вы запускаете скрипт. Она построчно, начиная с первой строки, анализирует текст скрипта, вычленяет из него команды и так же последовательно их выполняет.
Интерпретатор игнорирует:
1. Пустые строки. Это можно и полезно использовать для того, чтобы разбивать текст скрипта на удобные для человеческого восприятия "абзацы".
2. Содержимое строки после символа решетки (#), в том числе целые строки, начинающиеся с этого символа. Такие строки называются комментариями и тоже нужны исключительно автору и пользователям скрипта.
3. Пробелы много где, в том числе:
  - между операторами и значениями, с которыми они работают: a=5 и a = 5 и a = 5 - одно и то же;
  - между именами функций и скобками: myFunc(5, 7) и myFunc (5, 7) - одно и то же;
  - в списке аргументов функций: myFunc(5,7) и myFunc( 5, 7) - одно и то же.

1.2. Отступы и уровни вложенности

Важно: обратите внимание на объяснение ниже про уровни вложенности и отступы; у многих были вопросы по этому поводу. Для тех, кому интересны подробности, могу посоветовать информацию отсюда.

В Python имеет значение, сколько пробелов (или знаков табуляции) стоит в начале строки, слева. Насколько я знаю, это единственное место, где количество пробелов важно, например a = a + 1 и a=a+1 – абсолютно одинаковые вещи. Количество пробелов (знаков табуляции) по-английски называется indent (что переводится как "отступ").
Отступы используются интерпретатором Python для опознавания тел функций, тел операторов типа if, elif, else, тел циклов for и while, классов и прочего. В особенности это становится важно при комбинации этих элементов друг с другом (например, при написании условных операторов if внутри тела функции или цикла и т.д. и т.п.). Посмотрите код примера ниже, чтобы увидеть, как используются отступы при вложении элементов.
Общее правило такое: если Вы пишете участок кода, который представляет собой не просто список выполняемых всегда одиночных команд, то в нем выделяют первую строку и последующие строки-команды, которые выполняются или не выполняются в зависимости от того, что содержит первая строка. Первая строка пишется на том же уровне отступа, что и обычные команды, а все последующие строки, относящиеся к ней, пишутся с дополнительным отступом.
Первая строка начинается с условного названия действия, которое Вы хотите описать. Оно же определяет и дальнейшее содержимое этой строки. Завершается первая строка двоеточием. Давайте разберем соответствующие строки из примера ниже:
- строка 1: слово def сразу указывает на то, что перед нами не обычная команда, а строка-заголовок функции. Следующее слово после def будет считаться именем функции, а заключенный в круглые скобки список – списком ее аргументов;
- строка 4: слово for указывает на то, что сейчас будет задан цикл, а стоящее далее – условие прохода по циклу;
- строка 6: слово if указывает на то, что перед нами оператор условия, а значит далее будет следовать выражение, дающее то или иное булево значение (True или False).
- строка 8: слово else соотносится с ближайшим словом if, расположенным с тем же отступом.
Заметьте, что после каждой из вышеперечисленных строк все команды, которые относятся к этим строкам (будь то тело функции, тело цикла, тело оператора условия), получают дополнительный отступ.

   1 def printInfo (student_list):
   2     n = 1
   3     print "List of the students:"
   4     for student in student_list:
   5         print "Student %i:" %n
   6         if student == "Lalala":
   7             print "Fake student Lalala"
   8         else:
   9             print "FBB student %s" % student
  10         n = n + 1
  11          
  12 studs = ["Alina", "Daria", "Lalala", "Sergei", "Petr"]
  13 printInfo(studs)

Единичный отступ (такой, например, какой вы используете для тела функции при ее задании через def) согласно стандарту языка Python составляет 4 пробела. Интерпретатор будет не против, если Вы будете использовать вместо этого знак табуляции, десять пробелов, 1 пробел и т.п., но стандарт придуман не просто так: он облегчает чтение кода всем, кто пишет на этом языке. Поэтому категорически рекомендуется придерживаться этого.
Отступ каждой строчки должен состоят из целого числа единичных отступов. Это, опять-таки, стандарт языка, который для Вас обязателен. Каждый блок кода имеет определенный уровень вложенности (indent level) – количество отступов до него.

2. Основные типы команд на языке Python

Основные команды в программировании применяются к переменным. Чтобы сохранить в оперативной памяти на время работы программы любую информацию, ее надо записать в ту или иную переменную (точнее, записывается информация в память, а переменная служит просто "ярлычком", за которую эту информацию можно извлечь).

Имена переменных должны отвечать нескольким требованиям:

Могут содержать только символы английского алфавита, цифры и знак подчеркивания. То есть всякие специальные символы, русские буквы, пробелы ЗАПРЕЩЕНЫ.
Не могут начинаться с цифры.
Крайне желательно выбирать имя так, чтобы оно отражало свое будущее содержимое. Имена типа foo, lalala, nya и т.п., иногда используемые в примерах, не надо использовать в своем настоящем программном коде!

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

2.0. Операция присвоения значения

   1 a = 5          # Переменной a присваивается значение 5
   2 foo = 100      # Переменной foo присваивается значение 100
   3 a = foo        # Переменной a присваивается то значение, которое было присвоено foo, то есть 100

2.1. Арифметические операции

Операция сложения: операнды складываются

   1 a = 3 + 5      # Сперва вычисляется 3 + 5, а потом присваивается результат
   2 a += 3         # К исходному значению a прибавляется 3
   3 a = a + 3      # То же самое, что и предыдущая строка

Операция вычитания: правый операнд вычитается из левого операнда

   1 foo = 5
   2 a = foo - 3    # Подставляется значение foo, вычисляется выражение справа и присваивается результат
   3 a -= 3         # От исходного значения a вычитается 3
   4 a = a - 3      # То же самое, что и предыдущая строка

Операция умножения: операнды перемножаются

   1 a = 3 * 5      # Сперва вычисляется 3 * 5, а потом присваивается результат
   2 a *= 2         # Значение а увеличивается в 2 раза
   3 a = a * 2      # То же самое, что и предыдущая строка

Операция возведения в степень: левый операнд возводится в степень правого операнда

   1 a = 2 ** 3     # Вычисляется 2 в 3 степени и присваивается переменной а
   2 a = 2 * 2 * 2  # То же самое, что и предыдущая строка

Операция деления: левый операнд делится на правый операнд. Внимание: если оба операнда целые (тип int), а результат должен получиться дробным (как в примере ниже, строчка 2), то дробная часть будет просто отброшена. Чтобы этого не случилось, хотя бы одно из чисел при делении нужно делать числом типа float, причем приводить к этому типу нужно ДО того, как совершится операция (см. строки 3 и 4 примера)

   1 a = 4 / 2        # Результат целый, а = 2
   2 a = 5 / 2        # Настоящий результат 2.5, но дробная часть отбрасывается, и выходит что a = 2
   3 a = float(5 / 2) # Приведение к типу `float` произошло уже после того, как было выполнено отбрасывание; a = 2.0
   4 a = float(5) / 2 # Приведения к типу `float` одного из чисел достаточно, чтобы результат тоже был float; a = 2.5

2.2. Операции сравнения

Операция сравнения равенства: в качестве операндов могут выступать пара чисел или пара строк. В обоих случаях операция возвращает булево значение True, если эти числа равны (или строки совпадают по всем символам), и False иначе.

   1 a = 3 == 5         # a = False
   2 a = 5 == 5         # a = True
   3 a = "Cat" == "foo" # a = False
   4 a = "foo" == "foo" # a = True

Операция сравнения на НЕравенство: в качестве операндов могут выступать пара чисел или пара строк. В обоих случаях операция возвращает булево значение True, если эти числа НЕ равны (или строки отличаются друг от друга), и False иначе.

   1 a = 3 != 5         # a = True
   2 a = 5 != 5         # a = False
   3 a = "Cat" != "foo" # a = True
   4 a = "foo" != "foo" # a = False

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

   1 a = 3 > 5           # a = False
   2 a = 5 < 5           # a = False
   3 a = 6 > 3           # a = True
   4 a = "aaaa" < "bbbb" # a = True
   5 a = "aaaa" < "BBBB" # a = False

Операции сравнения типа "больше или равно" и "меньше или равно": все то же самое, что и для операций "больше" и "меньше", но равенство сравниваемых величин будет теперь давать True. Обратите внимание, что порядок следования символов в операции важен: вы не можете написать => или =<.

   1 a = 3 >= 5           # a = False
   2 a = 5 <= 5           # a = True
   3 a = 6 >= 3           # a = True
   4 a = "aaaa" <= "bbbb" # a = True
   5 a = "aaaa" <= "BBBB" # a = False

2.3. Логические операции

Операция И (and): операндами являются два булевых значения. Возвращается булево значение True, если обе они True, и False иначе

   1 a = True and True     # a = True
   2 a = True and False    # a = False
   3 a = False and True    # a = False
   4 a = False and False   # a = False

Операция ИЛИ (or): операндами являются два булевых значения. Возвращается булево значение True, если хотя бы одна из них True, и False иначе.

   1 a = True or True     # a = True
   2 a = True or False    # a = True
   3 a = False or True    # a = True
   4 a = False or False   # a = False

Операция НЕ (not): действует на один операнд и как бы обращает его значение: если он True, то результатом будет False, и наоборот.

   1 a = not True     # a = False
   2 a = not False    # a = True

3. Функции

3.1. Что такое функция

Функция - это выделенные в отдельный блок кода команды, которые выполняются не в тот момент, когда до них доходит интерпретатор, а в ответ на последующие вызовы функции. Функция характеризуется тремя вещами:

Название. Это уникальное имя, по которому функция будет вызываться. Ваши новые функции не должны называться так же, как встроенные функции языка Python. Названия функций должны удовлетворять тем же требованиям, что и имена переменных (см. раздел 2).
Список аргументов. Аргументы функции - это переменные, принимающие значения тех чисел, строк и пр., которые пользователь передает функции при ее вызове. Функция может не содержать аргументов.
Возвращаемое значение. Некоторые функции в ходе своей работы приходят к результату, который они передают обратно в место своего вызова. Если не указано, что функция возвращает, то она возвращает величину None служебного типа NoneType.

3.2. Как задать функцию

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

В примере ниже название функции myFunc, она принимает два аргумента, первый из которых помещается в переменную x, а второй в переменную y. Далее во второй строчке вычисляется значение переменной f, которое и является возвращаемым значением для данной функции, как видно из строчки 3.

   1 def myFunc (x, y):
   2         f = 5*(x ** 2) + 3*y + 7
   3         return f

3.3. Как запустить функцию

После того, как функция задана, обратиться к ней можно по имени, указав в круглых скобках после имени те конкретные значения параметров, при которых требуется запустить функцию. Следите за тем, чтобы задание функции было по строчкам выше, чем ее вызов; иначе интерпретатор языка не сможет вызвать ее. В строках 1-3 примера ниже задана функция, а в строках 5 и 6 она вызывается.

   1 def myFunc (x, y):
   2         f = x + y
   3         return f
   4 
   5 a = myFunc (4, 5)     # а будет равно 4 + 5 = 9
   6 b = myFunc (3, 2)     # b будет равно 3 + 2 = 5

4. Основные встроенные функции в Python и их особенности

Встроенные функции языка Python описаны подробно на сайте с официальной документацией.

4.1. Приведение типов

Если нужно привести тип той или иной переменной к другому типу, для этого используются функции:

str(x) - приведение переменной x к типу str. Переменные почти любого типа можно привести к строке.
int(x) - приведение переменной x к типу int.
float(x) - приведение переменной x к типу float

Обратите внимание на то, что строчку можно привести к числу только, если в строчке написано число. Например, int("123")=123, float("3.14")=3.14. В противном случае привести строчку к числу нельзя (это вызовет ошибку скрипта), а при приведении дробного числа (тип float) к целочисленному типу int дробная часть будет просто отброшена, то есть округления по правилам математики не произойдет. Чтобы узнать тип той или иной переменной, можно применить к ней функцию type(x).

4.2. Получение ввода с клавиатуры

Для запоминания в переменной типа str ввода с клавиатуры можно пользоваться функцией raw_input(invitation) (для Python 2.7.x) или input(invitation) (для Python 3.x). Обе функции высвечивают на экране строчку, поданную на вход, ждут, пока пользователь закончит ввод и нажмет enter, а потом возвращают введенную им строку. Например:

   1 # Пример для Python 2.7
   2 username = raw_input("Please enter your name: ")
   3 password = raw_input("Please enter your password: ")
   4 print "Haha, now I have your password, %s" % username
   5 print "Your password was", password

4.3. Вывод информации на экран

Команда print, самый простой способ (это не функция в Python 2.7, а то, что называется на языке Python простым утверждением: англ. simple statement). Поэтому обратите внимание, что при запуске этой команды нельзя писать круглые скобки, они будут неправильно поняты. Обратите внимание: в Python 3.x скобки писать обязательно, так как print() - стала функцией.
- Получает на вход один или несколько параметров, разделенных запятыми.
- Все, не относящиеся к классу str будут преобразованы в него функцией str().
- Параметры будут разделены пробелами, а в конце будет поставлен знак окончания строки (\n).
Удобнее всего использовать команду print для печати одной строки, которую можно сформировать с помощью операции подстановки. В примере ниже в строке 3 команда print получается всего ОДИН аргумент: строку, которая формируется путем подстановки элементов из кортежа (name, age) в строку "My name is %s, my age is %i" по очереди на места, указанные в ней с помощью условного символа %. Между кортежем и строкой стоит знак % – это и есть операция подстановки. Ту же строчку можно сформировать отдельно, сохранить в переменную (строка 4) и напечатать (строка 5): будет напечатано то же самое, что и в строке 3.

   1 name = "Dasha"
   2 age = 26
   3 print "My name is %s, my age is %i" % (name, age)
   4 temp_str = "My name is %s, my age is %i" % (name, age) # temp_str = "My name is Dasha, my age is 26"
   5 print temp_str

4.4. Открытие файла для чтения, проход по строкам файла и закрытие файла

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

Рассмотрите следующий код примера. Он открывает файл с именем, заданным в переменной name (строка 2), задает переменную n, которая будет считать строчки файла (строка 3), а затем инициирует цикл for (строка 4). При этом каждая новая строка файла будет помещаться в переменную temp_str, и в строчке 5 эта переменная будет перезаписываться, дабы удалить из нее лишние символы конца строки. Функция strip(), которая для этого используется, принимает в качестве аргумента перечисление символов, которые нужно "откусить" от строки с начала и с конца. Если запустить ее без параметров, то в качестве этих символов будут символы пробела, табуляции \t, конца строки \n и возврата каретки \r (собирательно называются "whitespace characters" - пустые символы, показывающиеся при печати или отображении как пустые места). Далее в строке 6 результат выводится на экран (обратите внимание на подстановку в строку кортежа значений), а потом в строке 7 счетчик \n увеличивается на 1. После выхода из цикла (строчка 8) будет напечатано общее количество прочитанных строк в файле. Наконец, строчка 9 закрывает файл.

   1 name = "Dibrova_YP_0000001.fasta"
   2 foofile = open (name)
   3 n = 1
   4 for temp_str in foofile:
   5     temp_str = temp_str.strip("\n")
   6     print "String %i: %s" % (n, temp_str)
   7     n = n + 1
   8 print "Found %i strings in file!" % n
   9 foofile.close()

4.5. Получение списка целых чисел в нужном интервале и с нужным шагом

Для этого используется функция range(). Эта функция может работать с одним, двумя или тремя аргументами, все они должны быть целыми числами (тип int). На выходе в любом случае - список (list) из требуемых элементов (в Python 2.7.x) или объект специального типа, который можно превратить в нормальный список подав его на вход функции list() (в Python 3.x) Начнем с трех аргументов, так как все остальные варианты являются частными случаями этого:
- Первый аргумент - это то число, с которого список будет начинаться;
- Второй аргумент - то первое число, которое в список включено НЕ будет;
- Третий аргумент - шаг, с которым будут перебираться числа.
Обратите внимание, что если первый аргумент сразу больше или равен второму, то вернется пустой список.
В строке 1 примера задается список, начинающийся с числа 2. Следующий элемент списка получается прибавлением к предыдущему величины шага: в нашем случае это будет 5. Далее проверяется, что 5 меньше 8, предельного значения: поскольку это так, 5 включается в список. А вот следующий элемент, 5 + 3 = 8, уже не включается.
Частный случай двух аргументов: если подать на вход только 2 аргумента, то шаг по умолчанию считается равным 1.
Частный случай одного аргумента: если подать на вход 1 аргумент, то шаг по умолчанию считается равным 1, а начальное число - нулем.
Проверьте сами, что будет при отрицательных аргументах

   1 list1 = range(2, 8, 3)  #list1 будет [2, 5]
   2 list2 = range(2, 8)     #list2 будет [2, 3, 4, 5, 6, 7]
   3 list3 = range(8)        #list3 будет [0, 1, 2, 3, 4, 5, 6, 7]

4.6. Вычисление длины чего-то, имеющего длину

Длину имеют такие встроенные типы Python, как строки (str), списки (list) и кортежи (tuple). Для выяснения длины строки, списка или кортежа используется функция len(). Попытка вычислить длину чего-то, у чего длины нет (например, целого или дробного числа, булевого значения) приведет к ошибке. Пример:

   1 foo = ["Cat", True, 8.9, 15, "Lalala"]  #list
   2 boo = ("Mouse", "Dog", 13)              #tuple
   3 koo = "Learn programming or die trying" #str
   4 
   5 f = len(foo) #f = 5
   6 b = len(boo) #b = 3
   7 k = len(koo) #k = 31

4.7. Командная строка и получение аргументов из командной строки

Командная строка (англ. command line) – это один из самых "топорных", базовых интерфейсов, с помощью которого можно давать команды операционной системе компьютера. FAR – интерфейс на один уровень выше, это уже графический интерфейс, так называемый GUI (Graphical User Interface). Более продвинутые версии интерфейса – это уже окошки Windows с перетаскиванием и щелчками мышью, камера, улавливающая движения пользователя и передающая команды компьютеру, и т.д. и т.п. Подробнее - в Википедии.
В FAR командная строка встроена в окошко; через нее Вы запускали свои скрипты. Помимо запуска скрипта, командная строка очень важна и полезна при подаче аргументов скрипту (да и любым системным командам тоже).
Если после имени файла скрипта написать несколько последовательностей символов, разделенных пробелами (например, слова), то скрипт будет иметь возможность получить эти последовательности, записать их в переменные и работать с ними. В таком случае они называются аргументами скрипта.
Чтобы получить в скрипте Python список из аргументов, нужно импортировать модуль с названием sys. Этот модуль можно считать одним большим классом с кучей функций и переменных (см. подробнее в документации), но нам из него нужно только одно: переменная с именем argv, в которой и содержится список аргументов (тип list).
Обратите внимание, что все аргументы в Python считаются сперва строками (тип str), аналогично тому, как строками считается результат ввода пользователя (см. раздел 4.2)! Поэтому, если какой-то из аргументов Вы хотите сделать числом, его сперва нужно привести к типу соответствующего числа (раздел 4.1).
Также важно помнить, что нулевой элемент (т.е. sys.argv[0]) – это всегда полный путь к самому скрипту.

Пусть, например, скрипт называется my_script.py, и содержит следующий код:

   1 import sys
   2 for i in range(1, len(sys.argv)):
   3     print "Argument %i is %s" % (i, sys.argv[i])

Этот скрипт в первой строке импортирует модуль sys, а потом во второй строке запускает цикл, где мы проходим по всем элементам списка аргументов, пропуская нулевой, и печатаем на экран. Введем следующее в командную строку: myscript.py lalala.fasta 10 356. Скрипт напечатает на экране:

Argument 1 is lalala.fasta
Argument 2 is 10
Argument 3 is 356

4.8. Выход из скрипта по команде

Модуль sys может использоваться не только для получения аргументов командной строки. С его помощью можно в нужном месте скрипта завершить его работу. Этой функцией лучше не злоупотреблять по тем же причинам, по которым следует быть аккуратными с командами "насильственного" прокручивания циклов continue и break (см. раздел 7). Опять-таки, польза этого состоит в том, чтобы избежать лишних уровней вложенности в скрипте.

Пусть, например, скрипт должен проверить, получил ли он ровно 2 аргумента от пользователя; если получил, то работать как обычно, а если не получил – то выдать на экран предупреждение и ничего не делать, завершить работу. Теоретически можно сделать гигантскую пару операторов условий if и else, в одном из которых будут все команды скрипта. Но это неудобно. В примере ниже показана альтернатива.

   1 import sys
   2 
   3 if len(sys.argv) != 3:
   4     print "Script should receive 2 arguments:"
   5     print "First: name of the file"
   6     print "Second: # of residues on a line"
   7     sys.exit()
   8 
   9 filename = sys.argv[1]
  10 number = sys.argv[2]

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

4.9. Открытие файла для записи и запись в файл

Выводить все результаты работы скрипта на экран очень неудобно. Обычно на экран выводятся приглашения для пользователя ввести какие-то данные, или предупреждения о том, как работает скрипт, или другие сообщения, докладывающие пользователю о текущих действиях скрипта. Всю же содержательную информацию, полученную при выполнении скрипта, обычно сохраняют в одном или нескольких выходных файлах (англ. output files).
Прежде чем печатать что-то в файл, его нужно открыть для записи. Использование функции open() с одним аргументом (именем файла), описанное в разделе 4.4, открывает файл только для чтения, а чтобы открыть его для записи – нужно подать этой функции второй аргумент. Этот второй аргумент задает режим работы с файлом. Значение второго аргумента "w" (от англ. write – запись) позволяет как раз открыть файл для записи. Значение "r" второго аргумента функции – это значение по умолчанию, оно указывает на открытие для чтения (от англ. read – чтение). В строке 1 примера мы создаем переменную newfile и через нее будем обращаться к новому файлу. Имя этого файла указывается в кавычках, как обычно.
ВНИМАНИЕ! Файл, имя которого Вы укажете в кавычках, будет создан пустым. Если указать имя уже существующего файла, он будет мгновенно перезаписан без какого-либо предупреждения!
Вывод сообщений в файл принципиально ничем не отличается от их вывода на экран с помощью команды print, однако при этом используется функция write() объекта файла. Аргумент этой функции (в простейшем случае) – строка. Как видно из строчки 2 примера ниже, эта строка может формироваться сложным образом, например с помощью операции подстановки. Заметьте, что функция write() вызывается объектом файла, то есть, в отличие от функции open(), она не является встроенной функцией языка Python.
Как и всегда, строка может быть сохранена в переменной ранее (строки 3 и 4); тогда аргументом функции будет эта переменная (строки 5 и 6).
Обратите внимание: функция write(), в отличие от команды print, не дописывает к строке символа конца строки, поэтому, если Вы хотите его вставить, об этом следует позаботиться самостоятельно. Символ конца строки \n присутствует в той строке, которую мы подали функции write() в строке 2, поэтому вторая напечатанная в файл строчка будет начинаться с новой строки. Но в ней (см. переменную str1) символа конца строки нет – поэтому третий вызов функции write приведет к тому, что содержимое переменной str2 просто прилепится к ранее напечатанному содержимому файла.
Обязательно закрывайте свои файлы с помощью функции close() (строка 7)! Если забыть это сделать, то какая-то часть информации может не записаться в файл, и потом будет очень трудно найти ошибку!

   1 newfile = open("AnyFileName.txt", "w")
   2 newfile.write ("This is my file! My name is %s, my age is %s\n" % ("Dasha", 26))
   3 str1 = "This string will be next"
   4 str2 = "And this text will merge with the previous =("
   5 newfile.write (str1)
   6 newfile.write (str1)
   7 newfile.close()

В этом случае вот такой текст будет напечатан в файл с именем AnyFileName.txt, которых будет создан в той же директории, где лежит скрипт:

This is my file! My name is Dasha, my age is 26
This string will be nextThis string will be next

Обратите внимание! Если в файл записывается информация в виде таблицы, то часто впоследствии она обрабатываются другими программами, в том числе Microsoft Excel, с которым Вы будете работать в следующем блоке. И для удобства последующей обработки, и для удобства чтения и проверки самого файла, поля таблицы обычно разделяют не пробелами, а знаком табуляции. Он вставляется так же просто, как символ конца строки – с помощью обозначения \t.

5. Операторы условий (if, elif, else)

Некоторые фрагменты кода нужно выполнить только если выполнено определенное условие. Для этого используется оператор if и дополняющие его операторы elif и else. Обратите внимание, что по-английски if будет называться не operator, а statement: такие особенности перевода =)

Давайте разберем первый пример. Данный скрипт просит пользователя ввести сперва его имя, а потом его возраст (строчки 1 и 2). Заметьте, что во второй строчке результат действия функции raw_input() приводится к типу int, чтобы сохранить его как число, а не как строчку. Строчка 3 начинается с названия оператора if, а заканчивается двоеточием. Все что между ними - это то условие, которое проверяется. Условие при исполнении кода всегда – какое-то конкретное булево значение (то есть True или False), но обычно оно задается неявно, через операцию сравнения (как в нашем примере) или через результат нескольких логических операций над булевыми значениями.

Строки 4-5 – это те команды, которые будут выполнены только если булево значение в строке 3 будет равно True. Заметьте, что они начинаются со стандартного отступа. Строка 6 уже отступа не содержит, и поэтому уже не принадлежит условию: она будет выполняться в любом случае.

Пример 1. Условие и оператор if

   1 name = raw_input("Enter your name, please: "))
   2 age = int(raw_input("How old are you? "))
   3 if age < 16:
   4     print "Oh, %s! You are a child, darling!" % name
   5     print "You don't need python, go play!"
   6 print "%s is %s years old" % (name,age)

Часто бывает так, что требуется развилка в алгоритме: если выполнено некоторое условие, то нужно сделать что-то одно, а если не выполнено, то сделать что-то другое. Бывает что вариантов даже несколько. Для реализации такой развилки можно использовать дополнения оператора if (а можно и не использовать: просто писать несколько операторов if подряд или вложенными друг в друга). Разберем пример 2 с использованием дополняющих операторов.

В строках 1-3 задаются три булевые переменные. Строчка 4 начинает оператор if; заметьте, что в качестве условия в нем стоит логическая комбинация двух булевых величин. Строка 5, соответственно, будет выполнена только если условие будет иметь значение True. В строке 6 задается следующий вариант, который будет проверен программой, если условие имеет значение False. Используется оператор elif, сокращение от else if. В нашем примере этого не случится, потому что оно True, но погода может и поменяться Таких вариантов может быть несколько. Соответственно, строка 7 - то действие, которое надо выполнить в этом случае. Строка 8 задает последний оператор else, который, заметьте, не содержит никакого условия: команды внутри тела этого оператора будут выполнены если ни одно из условий, описанных в операторах выше, не выполнилось. Как оператор elif, так и else могут отсутствовать.

Пример 2. Дополнения оператора if: elif и else

   1 rain = True
   2 happy = False
   3 sun = True
   4 if rain and sun:
   5     print "Gribnoi dogd'! ^_^"
   6 elif rain and happy:
   7     print "Sweet rain :)"
   8 else:
   9     print "Gloomy rain :("

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

Пример 3. Код без использования else

   1 rain = True
   2 sun = True
   3 if rain and sun:
   4     print "Gribnoi dogd'! ^_^"
   5 if not (rain and sun):
   6     print "Gloomy rain :("

6. Списки, кортежи и строки

Список –- это переменная особого типа list: она содержит несколько значений (одного или разных типов). Список является изменяемым, так как после задания списка можно менять значения, добавлять новые и удалять существующие.
Кортеж –- это переменная особого типа tuple: она, как и список, содержит несколько значений (одного или разных типов), но при этом кортеж является НЕизменяемым, так как после задания кортежа менять значения, добавлять новые и удалять существующие нельзя.
Строка – это переменная типа str, которая содержит от одного до нескольких символов: букв, чисел и т.п. Как и кортеж, строка НЕизменяема: менять буквы в уже созданной строке нельзя.
Эти три типа данных сближает следующее:
- у них есть длина, то есть к ним применима функция len();
- к их отдельным элементам можно обращаться через проставление пары квадратных скобок после имени переменной и указание номера конкретного элемента;
- ВАЖНО: нумерация элементов начинается с нуля!
Рассмотрите пример задания списка, строки и кортежа, а также обращения к их элементам.

   1 stud_list = ["Anna", "Victor", "Sergei"]   # Список (list)
   2 a = stud_list[1]                           # a = "Victor"
   3 l = len(stud_list)                         # l = 3
   4 stud_list[1] = "Dasha"                     # Список теперь ["Anna", "Dasha", "Sergei"]
   5 
   6 stud_tuple = ("Anna", "Victor", "Sergei")  # Кортеж (tuple)
   7 a = stud_tuple[1]                          # a = "Victor"
   8 l = len(stud_tuple)                        # l = 3
   9 
  10 foostring = "Students will learn or die"   # Строка (str)
  11 a = foostring[7]                           # a = "s"
  12 l = len(foostring)                         # l = 26

7. Циклы

Цикл for
- Как правило, используется для выполнения какой-то операции над всеми элементами строки, списка или кортежа, хотя может использоваться и просто для выполнения определенного количества операций.
- Синтаксис: после названия оператора цикла for ставится имя переменной, в которую на протяжении цикла будут последовательно записываться значения из списка (строки, кортежа), далее ставится ключевое слово in, а затем подается сам список (строка, кортеж). Завершается строчка двоеточием. Список, как обычно, может быть задан явно, как в примере 1 ниже, а может подаваться через переменную.
- Тело цикла записывается с отступом (как всегда после двоеточия): в нем перечисляются команды, которые следует выполнить для каждого элемента заданного списка.
- Разберем как работает цикл из примера 1. В первой строчке создается переменная temp_var со значением "Sasha", далее выполняются команды из тела цикла (печать этой переменной и печать еще одной строчки). После выполнения третьей строчки программа не переходит к четвертой, а возвращается к первой, к началу цикла, и в ней переменная temp_var создается заново, в нее записывается уже следующий элемент "Cat". Когда цикл закончит выполнение операций для последнего элемента 15, он вернется к первой строке, убедится, что больше элементов в цикле не осталось, и перейдет к четвертой строке.
- Цикл for можно использовать просто для выполнения одного и того же набора операций много раз. Тогда он используется в комбинации с функцией range() (см. ее описание в секции про встроенные функции языка Python). Код из примера 2 выдаст на экран 117 строк текста.

Пример 1. Реализация цикла for для списка

   1 for temp_var in ["Sasha", "Cat", True, 15]:
   2     print temp_var
   3     print "Taking next..."
   4 print "Now the cycle is over!"

Пример 2. Реализация цикла for для выполнения определенного количества операций

   1 for n in range(117):
   2     print "I love programming, I will do all my tasks in time"

Цикл while
- Более привычный для тех, кто раньше программировал на других языках. Цикл while очень похож на оператор if, у него тоже есть заданное пользователем условие выполнения, но разница в том, что оператор if выполняет команды из своего тела один раз, а while после последней команды в теле возвращается к первой своей строчке и заново проверяет выполнение условия. Если оно True, то он пойдет на второй виток, а если False - перейдет к следующей команде, пропустив тело цикла.
- В примере 3 приведен код, который сделает то же самое, что код в примере 2, т.е. выведет на экран 117 строк.
- Обратите внимание, что цикл while при неправильном использовании может вызвать так называемое зацикливание программы. Если условие выполнения цикла всегда будет оставаться True (например, так бы случилось, если мы забыли бы написать строчку 4), то цикл будет крутиться вновь и вновь до бесконечности, т.е. станет бесконечным циклом.

Пример 3. Реализация цикла while

   1 n = 0
   2 while (n < 117): 
   3     print "I love programming, I will do all my tasks in time"
   4     n = n + 1

Команда continue
- Бывает, что внутри тела цикла хочется сразу перейти к следующему витку. Для этого можно использовать команду continue: сразу после него программа вернется к первой строке цикла и начнет новый пробег.
- В примере 4 на экран будут выведены числа от 0 до 6, 8 и 9, а число 7 будет пропущено, т.к. при n равном 7 выполнилось условие оператора if и была вызвана команда continue.
- Использование команды continue может затруднить понимание кода, и как следствие (для сложных циклов) привести к неожиданному (и нежеланному) поведению программы. Поэтому используйте его с умом: в простом цикле вроде того что в примере 4 беды от этого не будет, а вот если тело цикла занимает два экрана – лучше найти другой способ, например использовать условия иначе (сравните примеры 4 и 5).

Пример 4. Использование командыcontinue

   1 for n in range(10):
   2     if (n == 7):
   3         continue
   4     print n

Пример 5. То же самое, что в примере 4, но без команды continie

   1 for n in range(10):
   2     if (n != 7):
   3         print n

Команда break
- Работает сходным образом с командой continue, только выполняя ее программа мгновенно прерывает выполнение цикла и переходит к следующим командам после его тела.
- В примере 6 на экран будут выведены только числа от 0 до 6.
- Все те предосторожности, которые упоминались в связи с командой continue, применимы и к команде break.

Пример 6. Использование команды break

   1 for n in range(10):
   2     if (n == 7):
   3         break
   4     print n

8. Классы

8.1. Что такое класс

Класс – это способ упорядочивания и представления некоторого типа данных, с которым работает программа. Применительно к объектам реального мира (например, кошкам, белкам, геномам) класс – всегда вещь абстрактная, т.е. не описывающая объект полностью, а также устраняющая незначительные для работы программы отличия у разных представителей класса. Можно сказать, что класс представляет собой совокупность данных, описывающих объекты заданного типа, а также совокупность методов, которые доступны всем этим объектам.
Обычно в программировании принято писать название класса с большой буквы, чтобы не перепутывать его с названиями функций и переменных. Соответственно, названия функций и переменных (в том числе и членов класса) обычно пишутся с маленькой буквы.
Название атрибутов и методов класса, которые создает программист, могут быть любыми (с соблюдением обычных правил именования переменных и функций). Однако старайтесь всегда-всегда делать их понятными и прозрачными, это очень важно и очень поможет в дальнейшем! НЕ НАЗЫВАЙТЕ АТРИБУТЫ И МЕТОДЫ КЛАССА НАЗВАНИЯМИ ТИПА foo, koo, myFunc!!! Эти названия используются в примерах просто для того, чтобы показать, что конкретное имя тут не важно, что в имени переменной или функции нету магии, оно само по себе ничего не определяет!
Когда класс описан, становится возможным создание экземпляров (англ. instances) этого класса, то есть конкретных "кошек", "белков", "геномов" со своими конкретными значениями всех атрибутов. Их также называют объектами.

8.2. Примеры классов: кошка, белок

Давайте для примера опишем, что могло бы быть включено в класс Cat (кошка).
- Атрибуты (свойства) кошки будут сохраняться в наборе так называемых переменных-членов класса. Перечислять все бесконечные свойства кошек (цвет глаз, количество пятен, список видов глистов-паразитов...) не требуется, нужно ограничиться той информацией, которая необходима для работы программы. Итак, выбор сохраняемой в переменных-членах класса информации определяется нуждами программы. Пусть для примера нас интересуют три свойства кошек: имя (name), возраст (age) и длина хвоста (tale_length).
- Методы кошек, т.е., говоря просто, доступные им, согласно коду программы, действия, также определяются нашими нуждами. Их иногда называют также функциями-членами класса. Пусть нам нужно, чтобы кошка умела мяукать и потом сообщать свое имя (фантазировать разрешается :)). За это будет отвечать метод miau().
Давайте также опишем, какие атрибуты и методы могут быть у белка (Protein), прочитанного из файла в fasta-формате:
- Атрибуты: идентификатор белка в базе данных RefSeq (id_RefSeq), описание белка (description) и аминокислотная последовательность (sequence).
- Методы: отдельным методом класса может быть метод, печатающий на экран информацию о белке в fasta-формате (printFasta()).

8.3. Как задать простой класс

Прежде чем задавать класс, выпишите куда-нибудь себе список атрибутов этого класса и список методов этого класса. Подумайте, что будет храниться в каждой переменной, какого она будет типа. Еще раз продумайте названия переменных и убедитесь, что эти названия представляют собой названия на английском языке, кратко описывающие содержание той или иной переменной или функции. Если Вы не знаете, как что-то называется по-английски, можете воспользоваться словарем Lingvo для перевода.
Теоретически класс можно задать абсолютно в любом месте Вашего кода, хоть на десятом уровне вложенности. Но старайтесь избегать этого, и выписывайте определения классов в начале скрипта, чтобы не запутаться и не стать жертвой ошибок.
Синтаксис: сперва пишется слово class, затем через пробел – имя класса, которое завершается двоеточием. Как и при задании функций, оператора if или циклов, все относящиеся к классу строки должны начинаться с отступа. Переменные задаются как обычно. Например, в примере 1 задается класс Cat, который содержит три переменные.

Пример 1. Класс без методов

   1 class Cat:
   2     name = "Noname"
   3     age = 0
   4     tale_len = 0

! Важное замечание: при создании функций-членов класса обращайте внимание на то, что первым аргументом у всех них должна стоять условно названная переменная, содержащая тот объект, который вызвал функцию. Это сперва может показаться непривычным. Например, если мы хотим модифицировать класс Cat, добавив к нему метод, которому никакие аргументы не нужны, то мы все равно прописываем эту условную переменную. Назвать ее можно как угодно, но стандартным названием в Python считается self ("я сам").

Пример 2. Класс с методом

   1 class Cat:
   2     name = "Noname"
   3     age = 0
   4     tale_len = 0
   5     def miau(self):
   6         print "Miaaaoooo!"
   7         print "My name is %s" % self.name

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

8.4. Как создать объект класса. Инициализирующая функция

Когда мы создавали переменную, мы просто присваивали ее значение через операцию =. Однако, в случае объекта все немного сложнее. При создании объекта класса Cat из примера 2 выше, мы написали бы такую строку:

   1 y = Cat()

Заметьте, что явно вызывается функция с названием таким же, как название класса – Cat(). Однако, мы нигде не задавали функцию с таким именем. Это название используется для удобства, а реально при создании нового объекта вызывается особая функция-член класса, которая имеет имя __init__ (от англ. initialize, инициализация). Обратите внимание, что слово init заключено в два знака подчеркивания с обеих сторон: это явное указание на то, что имя этой функции не взято "с неба", а является чем-то вроде системного имени в Python, как слова if, def, for. Т.е. инициализирующая функция должна всегда называться так.
Если инициализирующая функция Вами не задана, как в примере 2, то она все равно вызывается, только пустая, ничего не делающая: она только возвращает объект со значениями всех атрибутов по умолчанию, т.е. так, как мы прописали их.
Давайте добавим инициализирующую функцию в наш класс; тогда мы сможем задавать нужные нам параметры кошки сразу же при создании. Строка 8 в примере 3 – это первая строка с заданием функции, обратите внимание, что ее имя должно быть __init__. Строки 9, 10 и 11 – самое обычное тело функции. Заметьте, что в этих строках мы присваиваем атрибутам объекта self.name, self.age и self.tale_len поданные функции переменные n, a и t.
Будем считать, что класс Cat задан так, как в примере 3. Тогда, чтобы записать в переменную y кошку с именем "Murka", возрастом 7 и длиной хвоста 11, нужно выполнить команду из строки 13.

Пример 3. Класс с методом и инициализирующей функцией

   1 class Cat:
   2     name = "Noname"
   3     age = 0
   4     tale_len = 0
   5     def miau(self):
   6         print "Miaaaoooo!"
   7         print "My name is %s" % self.name
   8     def __init__(self, n, a, t):
   9         self.name = n
  10         self.age = a
  11         self.tale_len = t
  12 
  13 y = Cat("Murka", 7, 11)

8.5. Как обращаться к атрибутам и методам класса

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

   1 y.name = "Kitty"
   2 y.miau()

! Обратите внимание: при вызове метода miau() мы НЕ подали ему на вход сам вызывающий его объект y, как это требовалось бы сделать в соответствии с объявлением функции в строчке 5. Это делается просто для удобства.

...скоро раздел будет дополнен

9. Стандартные классы Python и некоторые полезные методы этих классов

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

Обращение к методам класса происходит через знак точки после имени переменной, относящейся к данному классу. Например, класс int содержит встроенный метод добавления числа к переменной, конкретному экземпляру класса. Поскольку этот метод практически никогда не используется пользователем (вместо него все пользуются интуитивно понятной арифметической операцией сложения), у него "страшное" имя: оно начинается и заканчивается двумя символами подчеркивания. Давайте рассмотрим пример ниже: в строчке 2 переменная a создается заново со значением 10 понятным образом. Строка 3 делает абсолютно то же самое, но при этом объект a вызывает метод класса int с названием __add__(), на вход которому требуется подать число, которое нужно прибавить.

   1 a = 5
   2 a = a + 5
   3 a = a.__add__(5)

9.1 int (англ. integer) - целое число

9.2 float(англ. floating point value, число с плавающей точкой) - десятичная дробь

9.3 bool (англ. boolean) - булево значение (True или False)

9.4 str (англ. string) - строка

Метод strip() – без параметров удаляет из начала и конца строки так называемые "незначащие символы" (англ. whitespace characters): пробелы, символы конца строки, символы табуляции и т.п., и возвращает результат. Если же подать на вход ей строку, то она удалит только те символы из начала и конца строки, которые встречаются в этой строке. ! Обратите внимание, что эта функция сама по себе НЕ изменяет содержимое строки, которая ее вызвала; если нужно его изменить, то нужно присвоить результат функции той же переменной.

   1 string = "aaaaaabbbbbMy actual string is hereabbbab"
   2 string.strip("ab")                 #string не изменилось
   3 string = string.strip("ab")        #string сейчас изменилось и стало "My actual string is here"

Метод split() – без параметров разбивает строчку, которая его вызвала, по позициям незначащих символов (пробелы, символы конца строки, символы табуляции и т.п.). При этом количество символов, следующих подряд друг за другом, не важно.
- Если подать на вход функции строку, то эта строка целиком будет считаться разделителем. Метод возвращает список. В примере ниже список list1 представляет собой список из четырех элементов-строк, а список list2, созданный с другим разделителем, будет содержать только два элемента.
- ! Если подать на вход помимо строки-разделителя второй параметр (целое число), то будет произведено равное этому числу количество "разрезов". В примере list3 будет содержать 2 элемента, поскольку был подан второй параметр.

   1 string = "My   name is Daria"
   2 list1 = string.split()           #list1 - это ["My", "name", "is", "Daria")
   3 list2 = string.split("is")       #list2 - это ["My   name ", " Daria")
   4 list3 = string.split(" ", 1)     #list3 - это ["My", "name is Daria")

Метод replace() – позволяет заменить подстрочку, указанную в первом аргументе, на подстрочку, указанную во втором. Если третьего аргумента нет, метод заменяет все вхождения в той строке, которая вызвала метод. Если третий аргумент подается, то он указывает количество замен, которые надо сделать от начала строки. Если второй аргумент – пустая строка "", то по сути вхождения первого аргумента будут удалены из результирующей строки.

   1 string = "The sky is blue; the sun is yellow"
   2 new_string1 = string.replace("is", "was") # newstring1 - это "The sky was blue; the sun was yellow"
   3 new_string2 = string.replace(" ", "_", 2) # newstring2 - это "The_sky_is blue; the sun is yellow"
   4 new_string3 = string.replace(" ", "")     # newstring3 - это "Theskyisblue;thesunisyellow"

Метод count() – позволяет подсчитать количество вхождений подстрочки, указанной в первом аргументе, в ту строку, которая вызывает метод. Если второй и третий аргументы опущены, поиск осуществляется по всей строке, а если указаны - то между соответствующими позициями.

   1 string = "Kitty played with Tom. Their play was nice"
   2 a = string.count("play")        # a = 2
   3 b = string.count("play", 5, 10) # b = 1
   4 c = string.count (" ")          # c = 7

Методы upper() и lower() – позволяют изменить регистр всех символов строки, сделав (в случае первой функции) все буквы в строке прописными (большими) или наоборот.

   1 string = "This is a SiMpLe sentence"
   2 large_letters = string.upper() # large_letters содержит "THIS IS A SIMPLE SENTENCE"
   3 small_letters = string.lower() # small_letters содержит "this is a simple sentence"

Метод translate() – позволяет делать замены в строке. Пока мы будем применять его для удаления символов из строки. Если первым параметром подать None (заметьте, без кавычек – это не строка, а значение специального типа, вроде True и False, только не типа bool, а типа NoneType), а вторым - строчку из нескольких символов, то в строке-результате все вхождения этих символов будут удалены. Обратите внимание на отличие от использования метода replace(): там заменяется вся поданная подстрока целиком, а тут – вхождения каждого отдельного символа.

   1 str1 = "Dasha"
   2 str2 = str1.translate(None, "ah") # str2 будет "Ds"

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

   1 a = "abcdefghij"
   2 b = a[2:6]    # b = "cdef"
   3 c = a[2:6:2]  # c = "ce"
   4 d = a[::2]    # d = "acegi"
   5 e = a[::-1]   # e = "jihgfedcba"

9.5 list - список

Метод append(x) – добавляет в конец списка элемент, содержащийся в переменной x.
Метод extend(list) – добавляет в конец списка набор элементов, содержащихся в списке list.
Метод insert(i, x) – добавляет в i-ую позицию элемент, содержащийся в переменной x. При этом insert(0, x) вставит элемент в начало списка.
Метод pop() – при вызове без параметров удаляет из списка последний элемент и возвращает его. Если подать методу номер элемента, который нужно удалить, то он удалит и вернет его.
Метод remove(value) – удаляет из списка первый элемент, значение которого равно value.
Метод reverse() – разворачивает список, делая первый элемент последним, второй - предпоследним и т.д.

Давайте рассмотрим пример использования этого инструментария. Список foo будет содержать студентов, которые приходят и уходят. В первой строчке задается список, во второй в него добавляется в конец один элемент. В третьей строчке создается новый список, который дописывается в четвертой к нашему списку. Еще один способ вставки информации в список показан в строке 5: указывается номер, после которого нужно вставить новый элемент. Строчка 6 показывает, как удалить самый концевой элемент, строчка 7 – как удалить элемент с номером 2. В строчке 8 для удаления используется поиск: первый элемент списка с поданным значением будет удален. Наконец, строчка 9 обращает список.

   1 foo = ["Vasya", "Lena", "Sasha", "Petr", "Genya"] # ["Vasya", "Lena", "Sasha", "Petr", "Genya"]
   2 foo.append ("Dima")                               # ['Vasya', 'Lena', 'Sasha', 'Petr', 'Genya', 'Dima']
   3 new_list = ["Alex", "Maria"]                      
   4 foo.extend (new_list)                             # ['Vasya', 'Lena', 'Sasha', 'Petr', 'Genya', 'Dima', 'Alex', 'Maria']
   5 foo.insert (3, "Dasha")                           # ['Vasya', 'Lena', 'Sasha', 'Dasha', 'Petr', 'Genya', 'Dima', 'Alex', 'Maria']
   6 foo.pop()                                         # ['Vasya', 'Lena', 'Sasha', 'Dasha', 'Petr', 'Genya', 'Dima', 'Alex']
   7 foo.pop(2)                                        # ['Vasya', 'Lena', 'Dasha', 'Petr', 'Genya', 'Dima', 'Alex']
   8 foo.remove("Alex")                                # ['Vasya', 'Lena', 'Dasha', 'Petr', 'Genya', 'Dima']
   9 foo.reverse()                                     # ['Dima', 'Genya', 'Petr', 'Dasha', 'Lena', 'Vasya']

9.6 tuple - кортеж

to be written...

9.7 dict - словарь

Что такое словарь
- Словарь (англ. dictionary) – это специальный тип данных, приспособленный для хранения величин под определенными уникальными именами. Если Вы программировали раньше на другом языке, то скорее всего знакомы с этим типом данных как с хэшем.
- Элемент словаря – это пара объектом, один из которых называется ключом (англ. key), а другой – значением (англ. value). В пределах одного словаря ключ однозначно связан со значением, т.е. по ключу в словаре можно мгновенно вычислить значение. С чем-то подобным Вы сталкивались при создании списков: к каждому элементу списка можно обратиться по его порядковому номеру, который, в некотором смысле, тоже является для него ключом.
- Таким образом, тип данных dict очень похож на самый обычным словарь: в нем, зная слово, Вы можете легко (и, что немаловажно, быстро) обнаружить статью, соответствующую слову, или же убедиться, что ее там нет.
- Для наших нужд, как правило, в качестве ключей используют строки или числа. Вообще говоря, ключом словаря может быть не любой объект, но строки или числа подходят.
- Значением в словаре может быть абсолютно что угодно: число, строка, список, объект Вашего собственного класса и т.п.
Как создать словарь
- Пустой словарь создается с помощью присваивания переменной значения, возвращаемого методом dict() (строка 1 примера 1); эквивалентен и способ записи как в строке 2, с помощью пары фигурных скобок.
- Можно сразу задать ключи и значения словаря; для этого между фигурными скобками через запятую указывают пары ключ-значение. Ключ пишется первым и отделяется от своего значения двоеточием. Пример такого задания приведен в строке 3 примера 1. В этом случае в словарь были помещены две пары: по ключу "Alex" будет извлекаться значение 21, а по ключу "Victor" – 15.

Пример 1. Создание нового словаря

   1 foo = dict()
   2 boo = {}
   3 age = {"Alex" : 21, "Victor" : 15}

Обращение к элементам словаря и добавление новых элементов
- Обращение к элементам словаря происходит через квадратные скобки и имя словаря, т.е. также, как и обращение к элементам списка по номеру. Например, в строчке 2 примера 2 переменной a будет присвоено значение 21, извлеченное из словаря.
- Если нужно дописать новый элемент в словарь, это можно сделать напрямую так, как показано в строчке 3 примера 2. Теперь в словаре появляется третий элемент, с ключом "Anna" и значением 25.
- Обратите внимание, что если попытаться напрямую обратиться к элементу словаря, которого в нем нет (строка 4), то это вызовет ошибку скрипта.

Пример 2. Обращение к элементам словаря

   1 age = {"Alex" : 21, "Victor" : 15}
   2 a = age["Alex"] # a = 21
   3 age["Anna"] = 45
   4 b = age["Dasha"] # Ошибка!

Проверка наличия ключа в словаре
- Самый простой способ проверки – использование оператора in. Если слева от него написать ключ, а справа – словарь, то результат будет булевым значением True, если ключ к словаре присутствует, и False – иначе. В комбинации с оператором if это позволяет действовать по-разному.
- Проверка наличия ключа в словаре – очень важная вещь на практике; она позволяет не только избежать ошибок при обращении, но и заполнять словари. Рассмотрим, как это делается (пример 3). В строке 1 задается нуклеотидная последовательность, в строке 2 – создается пустой словарь. Пусть мы хотим посчитать, сколько раз в этой последовательности встретился каждый нуклеотид; в строке 3 начинается цикл, проходящий по всем буквам последовательности. Если буква, сохраненная в переменной x, уже встречалась раньше, то мы хотим, чтобы соответствующее ей значение увеличилось на 1 (условие if, строки 4 и 5). Если же эта буква встретилась в первый раз, то установим ей значение, равное 1 (условие else, строки 6 и 7). Результат можно вывести на экран (строка 8) и убедиться, что все посчитано верно.

Пример 3. Использование словаря для подсчета числа нуклеотидов каждого типа в гене

   1 gene = "AAAAATCTACTCATTGGTCCA"
   2 nucleotide_count = dict()
   3 for x in gene:
   4     if x in nucleotide_count:
   5         nucleotide_count[x] = nucleotide_count[x] + 1    
   6     else:
   7         nucleotide_count[x] = 1
   8 print nucleotide_count # Будет выведено {'A': 8, 'C': 5, 'T': 6, 'G': 2}

Основные методы класса dict
- keys() – возвращает список ключей словаря. По этому списку, как и по любому другому, можно пройти с помощью цикла for. Это очень широко используется, если нужно обратиться поочередно ко всем элементам словаря (например, произвести с ними какое-то действие, вывести их на экран и т.п.)
- clear() – удаляет все элементы из словаря.
- pop(k) – возвращает элемент, соответствующий ключу k, и удаляет его из словаря.

Рассмотрим в примере 4 использование этих методов. Пусть мы храним оценки студентов в виде словаря marks (строка 1). Поскольку marks.keys() возвращает список ключей, по нему можно пройти с помощью обычного цикла for (строки 2 и 3) Кстати, обратите внимание, что порядок выдаваемых этим методом ключей не будет соответствовать порядку, в котором элементы помещались в словарь. В строке 5 мы решаем избавиться от элемента, с ключом "Dasha". Это можно сделать с помощью метода pop() (строки 5-8). Можно и сразу очистить словарь (строка 10).

Пример 4. Применение некоторых методов класса dict

   1 marks = {"Anna" : 5, "Sasha" : 5, "Dima": 3, "Dasha": 2, "Stas": 4}
   2 for foo_key in marks.keys():
   3     print "Student: %s, mark: %i" % (foo_key, marks[foo_key])
   4 
   5 bad_stud = "Dasha"
   6 m = marks.pop(bad_stud)
   7 print "%s was expelled, mark is %i" % (bad_stud, m) # Dasha was expelled, mark is 2
   8 print marks                                         # {'Dima': 3, 'Stas': 4, 'Anna': 5, 'Sasha': 5}
   9 
  10 marks.clear()
  11 print marks                                         # {}

10. Советы по использованию комментариев

10.1. Общие советы

Целые строки-комментарии или закомментированный конец строки можно использоваться для того, чтобы пояснить, что именно делает та или иная команда, тот или иной фрагмент программного кода. Прояснить, опять-таки, для самого себя.
В Pyton 2.7 нельзя вставлять комментарии на русском языке, поэтому придется с самого начала писать их на английском (постарайтесь никогда не делать этого на транслите). Заодно и потренируетесь
Наконец, если некоторый фрагмент кода пока не хочется удалять совсем, но временно его хочется выключить, проще всего сделать это с помощью закомментирования этого участка, т.е. внесения в начало строк символов #.

10.2. Оформление "шапки" скрипта

Принято оформлять первые несколько строчек скрипта в так называемую шапку (от англ. header). В этом разделе, не имеющем каких-то формальных ограничений или общих правил, обычно помещают ту информацию, которая может оказаться полезной любому пользователю скрипта (прежде всего самому автору, который, как Вы скоро убедитесь, склонен через полгода после написания скрипта совершенно забыть, зачем вообще он был написан). Правильно оформлять это следует так же, как оформляется комментарий к функции (см. следующий раздел): т.е. в первой строчке написать три кавычки """, затем начиная со второй строчки писать саму "шапку", а после ее завершения на отдельной строчке поставить еще три кавычки """. Я советую прописывать в любом своем скрипте следующие данные:
- Краткое описание назначения скрипта;
- Условный номер версии. Например, 1.0 для нового скрипта, а при незначительном изменении, улучшении можно сменить номер версии на 1.1. Если же скрипт бы преобразован радикально, то новая версия может называться 2.0, и т.д. Это нужно исключительно для Вас, чтобы не потеряться в версиях впоследствии. Внимание: тут важно не переусердствовать. Не надо менять версию скрипта после написания каждой новой строчки. Под "изменением" понимается редактирование по прошествии определенного времени или в ответ на исправление преподавателя.
- Основные изменения от версии к версии (лог изменений). Вначале может показаться, что это лишняя работа, но в действительности прописать это – дело пяти минут, а потом при разборе своих скриптов это сэкономит намного больше времени. Например, при смене версии скрипта с 1.0 на 1.1 можно указать, что конкретно было изменено, какая функциональность добавлена.
Например, можно делать это так:

   1 """
   2 Term 1, block 2, practicum X
   3 Fasta Reader 1.0
   4 This script reads fasta-format file with a single sequence and
   5 prints it to STDOUT with different cut-off of the sequence string
   6 Author: Dibrova DV
   7 Last modified: 05.10.2013
   8 """

10.3. Правильное комментирование функций в Python

Python позволяет оставлять комментарии к работе любых Ваших функций специальным образом, так, чтобы потом по имени функции любой пользователь мог обратиться к ним без рытья в Вашем коде. Да и Вам будет проще
Все, что Вы поместите между двумя наборами из трех кавычками (т.е. между одним """ и другим), будет считаться Вашей аннотацией данной функции, которую можно будет увидеть наряду с именем функции и списком аргументов. Помещайте аннотацию сразу за строкой с определением функции, как в примере ниже.
Важной частью аннотации функции является тщательный подбор ясных но коротких названий для аргументов, отражающих их назначение, а также ясное и короткое название самой функции. Избегайте длинных названий функций, вроде function_for_creating_an_integer_value и длинных имен переменных и аргументов, в которых пространно объясняется их назначение. Это почти также плохо, как называть свою функцию myF15, а ее аргументы gygygygyg и d. Найдите золотую середину!

   1 def int_round(value):
   2     """
   3     value - float value (integer is allowed but senceless)
   4     return - integer closest to the given value
   5     """
   6     result = ...
   7     return result

Kodomo

Пользователь