При программировании на питоне первые полезные результаты начинают получаться минут через 5 после начала работы над проектом. Не надо изобретать никаких велосипедов: всё, что может понадобиться, доступно или в стандартной библиотеке, или в одном из многочисленных дополнительных пакетов. Программы получаются элегантные и лаконичные, их легко и приятно писать и читать. Имеется широкий выбор высококачественных инструментов программиста: интегрированные среды разработки, отладчики и средства тестирования и т.д. Питон прекрасно приспособлен для написания больших и сложных программных комплексов. И всё это совершенно не зависит от железа и операционной системы (конечно, если не вызывать низкоуровневых системно-зависимыех библиотек).
Главный минус - питон, мягко говоря, не славится потрясающим быстродействием. Писать программы сложных вычислений на питоне, конечно, глупо. Но есть ряд способов обойти это ограничение. Если программа занимается регулярной обработкой больших массивов чисел с плавающей точкой, то использование numpy радикально повышает её быстродействие. Пакет numpy и его расширение scipy фактически делают matlab ненужным - дают ту же функциональность с более приятным языком программирование. Есть ряд пакетов для построения высококачественных графиков, например, matplotlib. Другое средство повышения быстродействия - cython. Пишется программа, выглядящая почти как питонская, но со вставленными статичестими декларациями типов. cython транслирует её в исходный код на C, что часто даёт быстродействие, сравнимое с вручную написанным C. Программа на cython-е может свободно вызывать функции из библиотек на C; её можно использовать из обычного питона. Ну и наконец можно написать критически важные для быстродействия системы в целом вычисления на другом языке (C например), и вызывать эти внешние программы из питона. Питон при этом выполняет роль клея - реализует логику высокого уровня, системно-независимый GUI и т.д.
Питон - сильно типизированный язык с динамической типизацией. Всё, с чем работает программа - объекты; каждый из них принадлежит определённому типу. Если программа пытается выполнить какую-то операцию над объектом такого типа, который не поддерживает эту операцию, произойдёт ошибка времени выполнения. Описаний переменных в питоне нет. Одна и та же переменная может в разные моменты иметь значения - объекты разных типов. Ошибка в типах может проявиться много времени спустя после того, как программа сдана в эксплуатацию, особенно если она происходит в редко используемом участке кода. Язык допускает ситуацию, когда мы сначала присвоим какой-то переменной целое число, потом строку, потом ещё что-то, но это плохой стиль. Переменная заводится для одного конкретного использования, и естественно, чтобы её значения в любой момент подходили для этого использования и имели одинаковый тип. В исходный текст на питоне 3.5 можно включить (необязательные) аннотации типов переменных и функций, и прогнать её через программу статической проверки типов.
В этом курсе мы познакомимся с основными конструкциями языка питон и наиболее часто используемыми функциями из стандартной библиотеки. Мы не будем пытаться охватить всё - если потребуется, недостающие факты всегда легко найти в справочной документации. Затем мы рассмотрим основные пакеты, используемые в научных вычислениях - numpy и scipy, matplotlib, пакет символьных вычислений sympy. Мы также обсудим использование cython-а для повышения быстродействия критических участков программы и для написания интерфейсов к библиотекам на C.
Каждая лекция представляет собой Jupyter-блокнот, см. http://jupyter.org/. Блокнот содержит последовательность ячеек. Некоторые из них содержат текст (включая картинки, формулы и т.д.), а некоторые - код. Кодовая ячейка состоит из поля ввода, помеченного In
[$n$], и поля вывода, помеченного Out
[$n$] (поле вывода может отсутствовать). Встав в поле ввода и нажав shift-enter
, Вы пошлёте этот код интерпретатору питона; результат появится в поле вывода. Вы можете изменять примеры, приведённые в лекциях, и смотреть, что получится. Можно вставлять новые ячейки.
Некоторые полезные ссылки
Арифметические операции имеют ожидаемые приоритеты. При необходимости используются скобки.
1+2*3
(1+2)*3
Возведение целого числа в целую степень даёт целое число, если показатель степени $\ge0$, и число с плавающей точкой, если он $<0$. Так что тип результата невозможно определить статически, если значение переменной n
неизвестно.
n=3
2**n
n=-3
2**n
Арифметические операции можно применять к целым и числам с плавающей точкой в любых сочетаниях.
n+1.0
Деление целых чисел всегда даёт результат с плавающей точкой, даже если они делятся нацело. Операторы //
и %
дают целое частное и остаток.
7/4
7//4
7%4
4/2
Если Вы попытаетесь использовать переменную, которой не присвоено никакого значения, то получите сообщение об ошибке.
x
x+=1
означает x=x+1
, аналогично для других операций. В питоне строго различаются операторы (например, присваивание) и выражения, так что таких операций, как ++
в C, нет. Хотя вызов функции в выражении может приводить к побочным эффектам.
x=1
x+=1
print(x)
x*=2
print(x)
del x
x
x=4
Любопытная особенность питона: можно использовать привычные из математики сравнения вроде $x
1<2<=2
1<2<2
Логические выражения можно комбинировать с помощью and
и or
(эти операции имеют более низкий приоритет, чем сравнения). Если результат уже ясен из первого операнда, второй операнд не вычисляется. А вот так выглядит оператор if
.
if 1<2 and x<3:
print('T')
else:
print('F')
if 1<2 or x<3:
print('T')
else:
print('F')
После строчки, заканчивающейся :
, можно писать последовательность операторов с одинаковым отступом (больше, чем у строчки if
). Никакого признака конца такой группы операторов не нужно. Первая строчка после else:
, имеющая тот же уровень отступа, что и if
и else:
- это следующий оператор после if
.
Оператора, аналогичного case
или switch
, в питоне нет. Используйте длинную последовательность if
... elif
... elif
... else
.
n=4
if n==1:
print('один')
elif n==2:
print('два')
elif n==3:
print('три')
else:
print('много')
Есть и условные выражения:
(0 if x<0 else 1)+1
Обычно в начале пишется основное выражение, оно защищается условием в if
, а после else
пишется исключительный случай.
В питоне немного встроенных функций. Большинство надо импортировать. Элементарные функции импортируют из модуля math
. Заниматься импортозамещением (писать свою реализацию синуса) не нужно.
from math import sin,pi
pi
sin(pi/6)
Любой объект имеет тип.
type(2)
type(int)
type(2.1)
type(True)
Имена типов по совместительству являются функциями, преобразующими в этот тип объекты других типов (если такое преобразование имеет смысл).
float(2)
int(2.0)
int(2.9)
int(-2.9)
Преобразование числа с плавающей точкой в целое производится путём отбрасывания дробной части, а не округления.
Питон хорошо приспособлен для работы с текстовой информацией. В нём есть много операций для работы со строками, несколько способов записи строк (удобных в разных случаях). В современных версиях питона (3.x) строки юникодные, т.е. они могут содержать одновременно русские и греческие буквы, немецкие умляуты и китайские иероглифы.
s='Какая-нибудь строка \u00F6 \u03B1 \u2230 \u342A'
print(s)
'Эта строка может содержать " внутри'
"Эта строка может содержать ' внутри"
s='Эта содержит и \', и \"'
print(s)
s="""Строка,
занимающая
несколько
строчек
"""
print(s)
s=="Строка,\nзанимающая\nнесколько\nстрочек\n"
Несколько строковых литералов, разделённых лишь пробелами, слипаются в одну строку. Подчеркнём ещё раз: это должны быть литералы, а не переменные со строковыми значениями. Такой способ записи особенно удобен, когда ружно передать длинную строку при вызове функции.
s='Такие ' 'строки ' 'слипаются'
print(s)
print('Такие\n'
'строки\n'
'слипаются')
В питоне нет специального типа char
, его роль играют строки длины 1. Функция ord
возвращает (юникодный) номер символа, а обратная ей функция chr
возвращает символ (строку длины 1).
n=ord('а')
n
chr(n)
Функция len
возвращает длину строки. Она применима не только к строкам, но и к спискам, словарям и многим другим типам, про объекты которых разумно спрашивать, какая у них длина.
s='0123456789'
len(s)
Символы в строке индексируются с 0. Отрицательные индексы используются для счёта с конца: s[-1]
- последний символ в строке, и т.д.
s[0]
s[3]
s[-1]
s[-2]
Можно выделить подстроку, указав диапазон индексов. Подстрока включает символ, соответствующий началу диапазона, но не включает соответствующий концу. Удобно представлять себе, что индексы соответствуют положениям между символами строки. Тогда подстрока s[n:m]
будет расположена между индексами n
и m
.
s[1:3]
s[:3]
s[3:]
s[:-1]
s[3:-2]
Если не указано начало диапазона, подразумевается от начала строки; если не указан его конец - до конца строки.
Строки являются неизменяемым типом данных. Построив строку, нельзя изменить в ней один или несколько символов. Операции над строками строят новые строки - результаты, не меняя своих операндов. Сложение строк означает конкатенацию, а умножение на целое число (с любой стороны) - повторение строки несколько раз.
s='abc'; t='def'
s+t
s*3
Операция in
проверяет, содержится ли символ (или подстрока) в строке.
'a' in s
'd' in s
'ab' in s
'b' not in s
У объектов типа строка есть большое количество методов. Метод lstrip
удаляет все whitespace-символы (пробел, tab
, newline
) в начале строки; rstrip
- в конце; а strip
- с обеих сторон. Им можно передать необязательный аргумент - символы, которые нужно удалять.
' строка '.lstrip()
' строка '.rstrip()
' строка '.strip()
lower
и upper
переводят все буквы в маленькие и заглавные.
'СтРоКа'.lower()
'СтРоКа'.upper()
Проверки: буквы (маленькие и заглавные), цифры, пробелы.
'АбВг'.isalpha()
'абвг'.islower()
'АБВГ'.isupper()
'0123'.isdigit()
' \t\n'.isspace()
Строки имеют тип str
.
type(s)
s=str(123)
s
n=int(s)
n
int('123x')
x=float('123.456E-7')
x
Метод format
особенно полезен для вывода.
'str: {} int: {} float: {}'.format(s,n,x)
Ширина поля 5 (больше, если не влезет); десятичный, шестнадцатиричный и двоичный форматы.
print('''{:5d}
{:5x}
{:5b}'''.format(n,n,n))
Ширина поля 10 (больше, если не влезет); после десятичной точки 5 цифр; формат с фиксированной точкой или экспоненциальный.
print('''{:10.5f}
{:10.5e}
{:10.5f}
{:10.5e}'''.format(x,x,1/x,1/x))
Списки могут содержать объекты любых типов (в одном списке могут быть объекты разных типов). Списки индексируются так же, как строки.
l=[0,1,2,3,4,5,6,7,8,9]
l
len(l)
l[0]
l[3]
l[10]
l[-1]
l[-2]
l[1:3]
Обратите внимание, что l[:3]+l[3:]==l
.
l[:3]
l[3:]
l[3:3]
l[3:-2]
l[:-2]
Списки являются изменяемыми объектами. Это сделано для эффективности. В списке может быть 1000000 элементов. Создавать его копию каждый раз, когда мы изменили один элемент, слишком дорого.
l[3]='три'
l
Можно заменить какой-нибудь подсписок на новый список (в том числе другой длины).
l[3:3]=[0]
l
l[3:3]=[10,11,12]
l
l[5:7]=[0,0,0,0]
l
l[3:]=[]
l
l[len(l):]=[3,4]
l
Некоторые из этих операций могут быть записаны в другой форме.
l=[0,1,2,3,4,5,6,7]
del l[3]
l
del l[3:5]
l
l.insert(3,0)
l
l.append(8)
l
l.extend([9,10,11])
l
Элементы списка могут быть разных типов.
l=[0,[1,2,3],'abc']
l[1][1]='x'
l
Когда мы пишем m=l
, мы присваиваем переменной m
ссылку на тот же объект, на который ссылается l
. Поэтому, изменив этот объект (список) через l
, мы увидим эти изменения и через m
- ведь список всего один.
l=[0,1,2,3,4,5]
m=l
l[3]='три'
m
Операция is
проверяет, являются ли m
и l
одним и тем же объектом.
m is l
Если мы хотим видоизменять m
и l
независимо, нужно присвоить переменной m
не список l
, а его копию. Тогда это будут два различных списка, просто в начальный момент они состоят из одних и тех же элементов. Для этого в питоне есть идиома: l[:]
- это подсписок списка l
от начала до конца, а подсписок всегда копируется.
m=l[:]
Теперь m
и l
- два независимых объекта, имеющих равные значения.
m is l
m==l
Их можно менять независимо.
l[3]=0
l
m
Как и для строк, сложение списков означает конкатенацию, а умножение на целое число - повторение списка несколько раз. Операция in
проверяет, содержится ли элемент в списке.
[0,1,2]+[3,4,5]
2*[0,1,2]
l=[0,1,2]
l+=[3,4,5]
l
2 in l
Простейший вид цикла в питоне - это цикл по элементам списка.
for x in l:
print(x)
Можно использовать цикл while
. В этом примере он выполняется, пока список l
не пуст. Этот цикл гораздо менее эффективен, чем предыдущий - в нём на каждом шаге меняется список l
. Он тут приведён не для того, чтобы ему подражали, а просто чтобы показать синтаксис цикла while
.
while l:
print(l[0])
l=l[1:]
l
Очень часто используются циклы по диапазонам целых чисел.
for i in range(4):
print(i)
Функция range(n)
возвращает диапазон целых чисел от 0 до $n-1$ (всего $n$ штук) в виде специального объекта range
, который можно использовать в for
цикле. Можно превратить этот объект в список функцией list
. Но этого делать не нужно, если только такой список не нужен для проведения каких-нибудь списковых операций. Число n
может быть равно 1000000. Зачем занимать память под длинный список, если он не нужен? Для написания цикла достаточно короткого объекта range
, который хранит только пределы.
r=range(4)
r
list(r)
Функции range
можно передать первый параметр - нижний предел.
for i in range(2,4):
print(i)
r=range(2,4)
r
list(r)
Функция list
превращает строку в список символов.
l=list('абвгд')
l
Как написать цикл, если в его теле нужно использовать и номера элементов списка, и сами эти элементы? Первая идея, которая приходит в голову по аналогии с C - это использовать range
.
for i in range(len(l)):
print(i,' ',l[i])
Можно поступить наоборот - устроить цикл по элементам списка, а индексы вычислять.
i=0
for x in l:
print(i,' ',x)
i+=1
Оба этих способа не есть идиоматический питон. Более изящно использовать функцию enumerate
, которая на каждом шаге возвращает пару из индекса i
и i
-го элемента списка.
for i,x in enumerate(l):
print(i,' ',x)
Про такие пары мы поговорим в следующем параграфе.
Довольно часто удобно использовать цикл while True:
, то есть пока рак на горе не свистнет, а выход (или несколько выходов) из него устраивать в нужном месте (или местах) при помощи break
.
while True:
print(l[-1])
l=l[:-1]
if l==[]:
break
Этот конкретный цикл - отнюдь не пример для подражания, он просто показывает синтаксис.
Можно строить список поэлементно.
l=[]
for i in range(10):
l.append(i**2)
l
Но более компактно и элегантно такой список можно создать при помощи генератора списка (list comprehension). К тому же это эффективнее - размер списка известен заранее, и не нужно много раз увеличивать его. Опытные питон-программисты используют генераторы списков везде, где это возможно (и разумно).
[i**2 for i in range(10)]
[[i,j] for i in range(3) for j in range(2)]
В генераторе списков могут присутствовать некоторые дополнительные элементы, хотя они используются реже. Например, в список-результат можно включить не все элементы.
[i**2 for i in range(10) if i!=5]
Создадим список случайных целых чисел.
from random import randint
l=[randint(0,9) for i in range(10)]
l
Функция sorted
возвращает отсортированную копию списка. Метод sort
сортирует список на месте. Им можно передать дополнительный параметр - функцию, указывающую, как сравнивать элементы.
sorted(l)
l
l.sort()
l
Аналогично, функция reversed
возвращает обращённый список (точнее говоря, некий объект, который можно использовать в for
цикле или превратить в список функцией list
). Метод reverse
обращает список на месте.
list(reversed(l))
l
l.reverse()
l
Метод split
расщепляет строку в список подстрок. По умолчанию расщепление производится по пустым промежуткам (последовательностям пробелов и символов tab
и newline
). Но можно передать ему дополнительный аргумент - подстроку-разделитель.
s='abc \t def \n ghi'
l=s.split()
l
Чтобы напечатать элементы списка через запятую или какой-нибудь другой символ (или строку), очень полезен метод join
. Он создаёт строку из всех элементов списка, разделяя их строкой-разделителем. Запрограммировать это в виде цикла было бы существенно длиннее, и такую программу было бы сложнее читать.
s=', '.join(l)
s
s.split(', ')