Переменная¶
— Что за странная фантазия: назвать собаку именем жены?
— А что ты хочешь от Шульца, он вообще… фантазер. Знаешь, как он называет жену? Киса.
— Вы представляете, как жизнь у него началась?! Сидит, например, Шульц дома, ему скучно, он хочет позвать жену. И, естественно, он кричит: «Эмма, Эмма!» И что же происходит?! Собака думает, что зовут жену, и не двигается с места, а жена думает, что зовут собаку и тоже не двигается с места! Шульцу это надоело и он решил назвать собаку Гектором.
— Но Гектор — это мужское имя!
— Да… мужское, мужское… Но ведь как Шульц рассуждал?! (— Да, как рассуждал Шульц?) Характер у него тяжёлый — жена может от него уйти, собака — ни-ког-да. С другой стороны, человек он молодой и может жениться во второй раз. Где гарантия, что его новая жена не окажется тоже Альмой, м? Где гарантия? Поэтому он и дал собаке новое мужское имя. Собака, очевидно, этого не выдержала и… сдохла. Сдохла Гектором, будучи по… существу Эммой.
@Летучая мышь
Условные инструкции¶
# Не запускать, просто пример
if condition:
do_smth1
else:
do_smth2
a = input()
a = int(a)
if a > 10:
print("a is greater than 10")
else:
if a == 10:
print("a is equal to 10")
else:
print("a is less than 10")
a = input()
a = int(a)
if a > 10:
print("a is greater than 10")
elif a == 10: # else if = elif
print("a is equal to 10")
else:
print("a is less than 10")
a = input()
a = int(a)
if a % 2 != 0:
a = a - 1
print(a)
Замечание 1. Двоеточие после условия (в конце строки if) обязательно!¶
Замечание 2. После if и после else!¶
Замечание 3:¶
В питоне группы команд определяются ОТСТУПАМИ! За отступами нужно ВНИМАТЕЛЬНО следить! Отступами могут служить и пробелы и знаки табуляции, причём в любом количестве, главное, чтобы команды из одной группы находились на одном уровне.¶
Замечание 4:¶
В Питоне нет операторных скобок {¶
if условие1:
команда1
команда2
else:
команда3from __future__ import brackets
Жена¶
В свое время Сократ мне сказал: «Женись непременно. Попадется хорошая жена — станешь счастливым. Плохая — станешь философом.» Не знаю, что лучше. @Тот самый Мюнхгаузен
Написать в следующей ячейке код, которые, если значение переменной wife равно "плохая", печатает "Философ", а если равно "плохая" - "Счастливый". Если переменная wife содержит другое значение, то напечатать "Оригинальный"
wife = "good"
# писать здесь
if wife == "good":
print("Happy")
elif wife == "bad":
print("Philosopher")
else:
print("Original")
wife = input("Describe your wife?")
# писать здесь
if wife == "good":
print("Happy")
elif wife == "bad":
print("Philosopher")
else:
print("Weird")
Циклы. For¶
Используем, когда хотим сделать определенное действие определенное число раз.
Например, отжаться 10 раз
for i in range(100): # делать 100 раз, i примет значения от 0 до 99
if i % 17 == 0:
print(i)
for i in range(10, 100):
# делать 100 раз, i примет значения от 10 до 99
if i % 5 == 0:
print(i)
for i in range(10, 100, 2):
# i от 10 до 98
if i % 17 == 0:
print(i)
Два важных соуса к for - это операторы break и continue
break позволяет досрочно выйти из цикла
# Проверка того, что число простое
a = input()
a = int(a)
if a > 1:
is_prime = True
for i in range(2, a): # итерироваться, начиная с 2 и заканчивая a - 1
if a % i == 0: # если число делится на что-то из этого без остатка,
# то оно не простое
is_prime = False
break # можем досрочно завершить цикл,
# у нас нет смысла что-либо проверять дальше
else:
is_prime = False
print(is_prime)
continue позволяет досрочно перейти к следующей итерации цикла
for i in range(5):
if i == 2 or i == 3:
continue
print(i)
Циклы. While¶
- Мы уже приехали?
- Нет.
- Уже приехали?
- Нет.
- Уже приехали?
- Нет.
- А теперь?
- Да.
- Честно?
- НЕТ!
© Шрек 2
До данного момента мы с вами разобрали цикл for. Этот цикл является наиболее часто используемым в питоне, однако иногда он все же неудобен. Например, если вы не знаете, сколько раз вам необходимо будет совершить определенное действие. Для такого рода проблем существует цикл while.
while не замена for
# Это пример НЕПРАВИЛЬНОГО использования while,
# тут намного правильнее делать цикл for
a = 0
while a < 10:
print (a)
a += 1
for a in range(0, 10):
print(a)
Допустим, вы ведете диалог с пользователем и выполняете какое-то действие, пока он не введет "stop". Вот здесь без while обойтись сложно
answer = input("Input number: ")
while answer != "stop":
answer = int(answer)
if answer % 2 == 0:
print("even")
else:
print("odd")
answer = input("Input number: ")
answer = input("Input number: ")
while answer != "stop":
answer = int(answer)
if answer % 2 == 0:
print("even")
else:
print("odd")
# answer = input("Input number: ")
Базовые типы¶
Целые числа
Числа с плавающей запятой
Логический тип
Строковый тип (строго говоря, уже коллекции, т.к хранят последовательность символов)
Пример логического типа
a = 5
b = a == 5
print (b, type(b))
Числа с плавающей запятой хранят вещественные числа не с абсолютной точностью!
10 / 7 - 1 - 3/7
10 / 7 - 1 - 3/7 == 0
10 / 7 - 1 - 3/7 < 10 ** (-7)
Коллекции¶
Коллекции - это какие-то наборы объектов разного или одного типа. 100 кошек, 10 собак, набор - [арбуз, тыква, голый землекоп], - все это является коллекцией.
В Python существует несколько разных типов, которые помогают вам хранить коллекции объектов в удобном для вас виде. Одним из базовых является список
Списки¶
Список - последовательность значений. В этом он похож на строки, но строки всегда являются набором символов, а в случае списка его элементами могут выступать любые типы в любой комбинации.
Есть несколько способов создать список, самым простым из них является просто заключить элемненты, из которых вы хотите создать список, в скобки
my_lst1 = ['apple', 5, True]
Можно даже положить список внутрь списка, такой список будет называться вложенным
my_lst2 = ['apple', ['tomato', 'fish'], 5]
Можно создать и пустой список, то есть список без элементов
empty_lst = []
Индексация¶
Как и строки, списки можно индексировать, как и в случае строк, индексация начинается с 0. Возможно брать отрицательные индексы
z = [3, 7, 4, 2]
z[3]
z[-1]
z[len(z) - 1]
my_lst2 = ['apple', ['tomato', 'fish'], 5]
el = my_lst2[1]
el[0]
my_lst2[-1]
len(my_lst2)
Напоминание для строк:
Срезы¶
Точно так же, как и для строк, можно брать срезы
my_lst2
my_lst2[0:-1]
my_lst2[0:0]
my_lst2[10:6]
my_lst2[-1:]
my_lst2[-1]
x = my_lst2[1]
x[0]
my_lst2
my_lst2[1:]
Можно указать шаг, через который брать элементы
my_lst2[1::1]
my_lst2[0::2]
my_lst2[::-1]
my_lst2[0:2:2]
Проход по элементам списка (итерация)¶
Можно пройтись по списку, просто по очереди обращаясь к каждому из его элементов по индексу. Для этого полезна функция len, которая, как и в случае строки, возвращает длину списка.
my_lst3 = [1, 7, -5, 0, 32]
for i in range(len(my_lst3)):
print(i, my_lst3[i])
Однако в случае списков (и вообще всех коллекций в Python), можно использовать цикл for напрямую!
Именно этот путь рекомендуется использовать, а первый путь говорит о том, что автор кода, вероятнее всего, новичок
for elem in my_lst3:
print(elem)
for можно применить и для строк. В этом случае вы будете итерироваться по символам строки
s = "Hello, world"
for c in s:
print(c)
Операции над списками
Списки можно складывать (называется уже известным вам умным словом конкатенация)
a = [2, 3, 4]
b = [-5, 10]
a + b
a - b # Я не могу понять, а чего кто-то ожидал:)
a * b # аналогично
Однако, список можно повторить несколько раз, умножив его на число, однако это не рекомендуется к использованию кроме самых очевидных случаев (чуть позже разберем, почему)
[0] * 5 # так делают
Можно проверить, есть ли элемент в списке с помощью ключевого слова in
a = [1, 3, 10]
if 5 in a:
print ("5 is in a")
else:
print ("5 is not in a")
Для строк работает аналогично
n = input()
if n in "ATGCUatgcu":
print("nucleotide")
else:
print("not")
n = input()
# перевести в верхний регистр
if n.upper() in "ATGCU":
print("nucleotide")
else:
print("not")
Проверка списка на пустоту¶
Работает не только для списка, а для всех коллекций/контейнеров
if not a: # if a is empty
print("HI")
b = [1]
if b: # if b is not empty
print("HI")
if len(a) == 0: # if a is empty
print("HI")
if [False]:
print("Wow!")
Изменяемость списков¶
В случае со строками, если вы попробуете изменить какой-то символ, то выскочит ошибка
a = "Hello, world!"
a[-1] = "?"
Приходится делать, например, так:
a = "Hello, world!"
b = a[0:-1] + "?"
print(a)
print(b)
b = a[:-1] + "?"
print(b)
В случае со списками все намного проще. Они являются изменяемыми объектами
a = [1, -3, 10, 6]
a[-1] = 5
a
a
Изменяемые объекты. Проблемы.¶
a = [10, 5, 4]
b = a
a[-2] = 7
Что лежит в b?
b
Если вспомнить аналогию про кошку, то вы назвали одну кошку разными именами. От этого кошка не раздвоилась.
Потому, дразня кошку в переменной a, вы рискуете получить поцарапанные руки и в переменной b
colors = ['red', 'blue', 'green']
b = colors
Чтобы бороться с таким поведением Python, вам придется заставить его скопировать список!
a = [10, 5, 4]
b = a[:] # берем срез всего списка - это его скопирует
a[-2] = 7
print ("a", a)
print ("b", b)
Также можно использовать встроенную функцию Python - list
a = [10, 5, 4]
b = list(a)
a[-2] = 7
print ("a", a)
print ("b", b)
list("ATGCGAGCCG")
list()
Также можно использовать метод изменяемых объектов Python - copy
a = [10, 5, 4]
b = a.copy()
a[-2] = 7
print("a", a)
print("b", b)
После обычной процедуры копирования изменения в списках будут разнесены, если мы не берем вложенные в них измененяемые объекты (например, списки). Однако если менять вложенный список, то изменения коснутся обеих списков
lst1 = ['a', 'b', ['ab', 'ba']]
lst2 = lst1.copy()
lst1[-1][0] = 5
lst2[-1][1] = "d"
lst2[0] = "c";
print(lst1)
print(lst2)
Для вложенных списков и просто изменяемых объектов в изменяемых объектов - deepcopy
from copy import deepcopy
lst1 = ['a','b',['ab','ba']]
lst2 = deepcopy(lst1)
lst2[2][1] = "d"
lst2[0] = "c";
print(lst1)
print(lst2)
Методы списка¶
Список, как и многие другие встроенные типы в Python, имеет набор функций, предназначенных для работы с ним и вызываемых с помощью конструкции вида lst.method_name
append - Добавление в список
Хочется уметь достраивать список в ходе работы программы. Например, можем создать список всех нечетных чисел до 20
lst = []
for i in range(21):
if i % 2 == 1:
lst.append(i)
print (lst)
extend - хотим добавить в конец нашего списка все элементы из другого
a = [1,4]
b = [1, 2, 7]
c = a + b
print(a, b, c)
a[1] = 5
print(a, b, c)
lst = [1, 4]
lst.extend([1,2,7])
lst
count - подсчитать число вхождений элемента в список
lst = [1, 7, -5, 6, 0, 1]
lst.count(1)
sort - отсортировать список на месте
lst.sort()
lst
Файлы¶
Люди делятся на два типа:¶
И¶
Информация хранится на компьютерах в файлах.
Работа с файлами -- неотделимая часть жизни биоинформатика. До 90% работы среднестатистического биоинформатика уходит на парсинг файлов и их конвертацию между форматами.
Файл -- это данные, которые хранятся на некотором носителе, например, на жестком диске.
Чтение из файла¶
Для того, чтобы открыть новый файл на чтение служит команда open(filename, "r")
f = open('spring1.txt', "r")
f имееет имеет интересный тип, название которого не то чтобы много говорит, но этот тип объектов позволяет читать из себя данные.
type(f)
Можно прочитать весь файл разом
print(f.read())
Открытый файл после окончания работы НАДО закрыть командной close
f.close()
Из файла также можно читать построчно:
f = open("spring2.txt", "r")
print(f.readline())
print(f.readline())
f.close()
print("\n\n\n")
Заметим, что прочитанная строка возвращается с "\n" на конце. Какую функцию надо использовать, чтобы его убрать?
f = open("spring2.txt", "r")
print(f.readline().strip())
print(f.readline().strip())
Когда файл дочитан до конца, функция readline возвращает пустую строку (без "\n" на конце)
print ("Returning empty string : |", f.readline(), "|", sep="")
f.close()
Казалось бы, можно организовать чтение всего файла следующим образом:
infile = open("spring3.txt", "r")
line = infile.readline()
while line != "":
print(line.strip())
line = infile.readline() # why not to strip line right here:?
infile.close()
Однако в Python есть два механизма, которые помогают упростить код, написанный выше. Во-первых, для чтения файла можно использовать цикл for
Если вам нужно обработать все строки из файла одинаковым способом, то этот способ наиболее предпочтителен - он не только компактнее и соответствует стилю Python, но он еще и быстрее.
infile = open("spring4.txt", "r")
for line in infile:
print(line.strip())
infile.close()
Важно
Один раз пройдя по файлу, при попытке пройти по нему второй раз, вы ничего не прочитаете нового - вы уже в конце файла.
infile = open("tab.txt", "r")
for line in infile:
print(line.strip())
for line in infile: #won't be executed
print(line.strip())
infile.close()
Аналогично, если из файла уже что-то читалось - второй раз оно прочитано не будет
Запись в файл¶
Открытие файла на запись - open(filename, "w") (это команда создает новый пустой файл)
Запись в файл осуществляется методов write
infile = open("Munchhausen1.txt", "w")
phrase = '''avsvsvsv''' # write doesn't append \n at the of string
infile.write(phrase)
infile.close()
f = open("Munchhausen1.txt", 'r')
print (f.read())
f.close()
Можно также записать в конец уже существующего файла, открыв его в append-mode ("a")
f = open("Munchhausen.txt", 'a')
s = '''saddsa\n'''
f.write("\n")
f.close()
f = open("Munchhausen.txt", 'a')
f.write(s)
f.write("@asdsa\n")
f.close()
f = open("Munchhausen.txt", 'r')
print (f.read())
f.close()
Почему важно закрывать файлы?¶
Все открытые файлы автоматически закрываются, когда программа заканчивает работу.
И потому все будет прекрасно работать, пока вы не решите создавать в своей программе промежуточные файлы, информация из которых затем используется в программе.
cat = "cat.txt"
f = open(cat, "w")
f.write("Hello,")
f.write("world\n")
g = open(cat, "r")
print (g.read())
cat = "cat.txt"
f = open(cat, "w")
f.write("Hello,")
f.write("world\n")
f.close()
g = open(cat, "r")
print (g.read())
Тут внезапно выяснится, что вы что-то записали в файл, не закрыв его, этого там не оказалось, ваша программа не нашла, чего искала, и упала.
Дело в том, что операции чтения/записи с жесткого диска не являются самыми быстрыми в мире. Потому система предпочитает записывать на жесткий диск не каждый раз, когда вы указали ей это сделать, а ждать, пока не наберется достаточно большой кусок данных. Потому в незакрытый файл вполне возможно запись произведена до конца работы программы и не будет.
А вот если его все же закрыть, то:
Более того, часто в биоинформатике вам приходится писать программы, работающие долгое время, возможно, отвечая на тысячи задач. Если так случится, что вы забываете на каждый запрос закрыть файл, то в какой-то момент вы не сможете открыть новый файл и ваша программа завершится аварийно. По-умному такая ситуация называется "утечка файловых дескрипторов".
Демонстрация того, что будет, если открыть слишком много файлов (допустим, на запись, но это верно и для чтения):
# не запускайте этот код, если не готовы перезагружать тетрадь
opened_files = []
for i in range(1, 10000):
fl = open(str(i), "w")
opened_files.append(fl)