Введение в научный Python-1. Введение в научный Python

• Название: Введение в научный Python
• Дата: 09.01.2020
• Размер: 6.2 Mb.
• Имя файла: Введение в научный Python-1.pdf
• Тип: Документы; #103229
• страница: 12 из 22

Комбинированный (многоярусный, пакетный, этажерочный, штабельный)
график (stackplot) набора функций
     
 
x
f
x
f
x
f
x
f
n
...,
,
,
,
3 2
1
состоит из кривых построенных таким образом, что точки i+1 – ой кривой находятся выше i – ой на величину
 
x
f
i
. Т.о. уравнение k – ой кривой имеет вид
 
 



k
i
i
k
x
f
x
y
1
. Функция plt.stackplot(X,A[,...]) строит такой график.
Она принимает одномерный массив X горизонтальных координат, и двумерный массив A, строки которого используются при построении графика. Каждая строка массива A содержит y координаты узлов ломаных
i
f , которые используются для построения пакетного графика. Количество столбцов массива
A должно совпадать с количеством элементов массива X. aa=np.array([1,2,3])
A=np.array([[1,0.1,0.2],[0.4,0.5,0.6],[0.7,0.8,0.9]],dtype=float) plt.stackplot(aa,A)

131
Вторая строка массива A интерпретируется как добавки к значениям первого массива, третья – как добавки к результату суммирования двух первых строк и так далее.
Вместо двумерного массива A можно использовать любое количество одномерных массивов такой же длины как и массив X. x=np.linspace( -2*np.pi,2*np.pi,100) y1=1/(1+x**2) y2=np.cos(x)**2 y3=np.exp( -x**2/10) z=y1+y2+y3 plt.stackplot(x,y1,y2,y3) plt.plot(x,z,'k',linewidth=4) plt.xlim( -2*np.pi, 2*np.pi) plt.grid(True)
Здесь для сравнения мы еще построили график кривой z=y1+y2+y3, показанный на рисунке черным цветом.
Контурные графики. Функции plt.contour() и plt.contourf() рисуют контурные графики функции двух переменных. Первая – рисует линии постоянного значения, а вторая – залитые области между линиями постоянного значения. Начнем с примера построения линий уровня функции
 
1 2
2
,
2 4
2 4





y
y
x
x
y
x
f
. Вначале создадим массивы. import numpy as np import matplotlib.pyplot as plt def f(x,y): return x**4-2*x**2+y**4 -2*y**2+1 n=101 x = np.linspace( -2, 2, n) y = np.linspace( -2, 2, n)
X, Y = np.meshgrid(x, y)
Z=f(X,Y)
В формате contour(Z) функция строит контурный график массива Z. Значения линий уровня выбираются автоматически.

132 fig = plt.figure(facecolor='white') ax1 = fig.add_subplot(1,2,1) ax1.contour(Z)
# линии уровня ax2 = fig.add_subplot(1,2,2) ax2.contourf(Z)
# залитые области между линиями уровня
Рисунок (объект Figure) в matplotlib представляет графическое окно
(автономное или внедренное в документ). Внутри окна (рисунка) может быть создано несколько графических областей (subplots), в каждой из которых может быть построен свой график.
В нашем примере команда fig.add_subplot(1,2,1) создает графическое окно и определяет, на какое количество графических областей оно будет разбито. В качестве первых двух аргументов функция принимает количество строк (numrows) и количество колонок (numcols), которые образуют графические области. Третьим аргументом указывается номер активной области, в которую будет направляться графический вывод. Если numrows×numcols<10, то запятые между этими аргументами ставить необязательно. Например, последнюю инструкцию можно записать в виде fig.add_subplot(121).
В первой графической области мы строим график линий уровня, а во второй – залитые различным цветом области между линиями уровня.
Обратите внимание на отметки координатных осей. По осям X и Y отложены индексы элементов в массиве Z. Чтобы по осям были отложены координаты X и Y, следует использовать формат contour(X,Y,Z). Количество линий уровня на графике можно задать четвертым аргументом contour(X,Y,Z,N). Массивы X и Y обычно являются двумерными такого же размера, как массив Z. fig = plt.figure(facecolor='white') ax1 = fig.add_subplot(1, 2, 1) ax1.contour(X,Y,Z,40); locs =np.linspace( -2,2,5) ax1.set_xticks(locs, minor = False); ax1.set_yticks(locs, minor = False); ax2 = fig.add_subplot(1, 2, 2) ax2.contourf(X,Y,Z,40); ax2.set_xticks(locs, minor = False); ax2.set_yticks(locs, minor = False);

133
Элементы оформления графических областей создаются аналогично тому, как это делается в случае одной графической области.
Можно задавать не количество линий уровня, а массив значений, для которых рисуются линии постоянного значения. Добавьте перед первой строкой предыдущего кода инструкцию vals=np.array([-1.5,-0.9,-0.6,-0.36,-0.18,-0.05,0,0.05,0.25,0.5,0.75,
0.95,1.5, 2.5,3.5,5,7]) и замените строки ax1.contour(X,Y,Z,40) и ax2.contourf(X,Y,Z,40) следующими командами ax1.contour(X,Y,Z,vals); и ax2.contourf(X,Y,Z,vals);
Выполните блок нового кода и получите следующие графики.
Вместо массива значений линий уровня vals можно использовать опцию levels=список_значений.
С помощью функции clabel(cs[,массив_значений,...]) на контурных линиях можно отобразить значения, которым они соответствуют.
Здесь cs – ссылка на объект, который возвращает функция contour(). При задании аргумента массив_значений, метки будут рисоваться только на линиях, перечисленных в этом массиве. vals=np.array([-1.5,-0.9,-0.6,-0.36,-0.18,-0.05,0,0.05,0.25,0.5,0.75,
0.95, 1.5,2.5,3.5,5,7]) fig = plt.figure(facecolor='white') ; ax=fig.gca() cs=ax.contour(X,Y,Z,vals);
v=np.array([-0.6,-0.18,0,0.5,0.75, 1.5,5]) ax.clabel(cs, v)
locs =np.linspace( -2,2,5) ax.set_xticks(locs, minor = False); ax.set_yticks(locs, minor = False); plt.colorbar(cs)

134
Функция plt.colorbar(cs) рисует палитру цветов, которая использована графическим объектом cs.
У функции contour() также имеются опции linewidths (толщина линий уровня), linestyles (стиль линий уровня с допустимыми значениями
None | „solid‟ | „dashed‟ | „dashdot‟ | „dotted‟). Если опции colors присвоить значение фиксированного цвета, то кривые постоянных положительных значений изображаются сплошными линиями, а отрицательных
– пунктирыми.
Часто удобно накладывать контурный график на залитый контурный график. def f(x, y): return (1-x/4 + x**3 + y** 3) * np.exp( -x**2 - y**2)*(x**2-y-x)
t = np.linspace( -3, 3, 121);
X, Y = np.meshgrid(t, t);
Z= f(X, Y); plt.contourf(X, Y, Z, 16, alpha=0.9, cmap='jet'); plt.contour(X, Y, Z, 16, colors='black', linewidth=.5); plt.gcf().set_facecolor('w'); plt.gcf().gca().axis('image');
Матрицу Z можно представить графически с помощью функции imshow(). В результате получается изображение близкое к залитому контурному графику, но по–другому ориентированное. plt.figure() plt.imshow(Z);
# следующий рисунок слева plt.gcf().set_facecolor('w');

135 plt.gcf().gca().axis('image'); plt.axis('off')
Мы отключили отображение меток на осях командой plt.axis('off'), поскольку функция imshow(Z) относит график к индексам элементов матрицы
Z. Следует помнить, что при отображении матрицы Z функцией imshow(Z) начало (точка [0,0]) расположено в левом верхнем углу и оси направлены вправо и вниз. На контурном же графике, оси направлены вправо вверх. Чтобы сравнить полученное изображение матрицы с контурным графиком, можно преобразовать матрицу Z подходящим образом. В данном случае ее нужно перевернуть сверху вниз. Это можно сделать функцией numpy.flipud(Z). plt.figure() img=plt.imshow(np.flipud(Z));
# предыдущий рисунок справа plt.gcf().set_facecolor('w'); plt.gcf().gca().axis('image'); plt.axis('off')
Заметим, что контурный график и изображение матрицы Z использовали одинаковую палитру цветов. Если палитры будут разными, то графики будет трудно сравнивать. Например, добавьте в конец предыдущего кода инструкцию plt.gray()
, которая устанавливает серую палитру, и выполните код. Вы получите следующее изображение.
На контурном графике, если пожелаете, можно построить только одну нулевую линию уровня функции
 
y
x
f
,
. В таком случае она (линия) будет представлять кривую, заданную неявным уравнением
 
0
,

y
x
f
. В следующем примере мы строим гиперболу и эллипс по их неявным уравнениям:
0 1
2 2



y
x
и
0 1
2 3
2 2
2 2



y
x
t=np.linspace( -3,3,41)
X,Y=np.meshgrid(t,t) plt.figure()

136 plt.contour(X, Y, X**2 -Y**2-1, [0], linewidths=3,colors='b') plt.contour(X, Y, X**2/9+Y**2/4 -1, [0], linewidths=3,colors='r') plt.gcf().set_facecolor('w'); plt.gcf().gca().axis('image'); plt.gcf().gca().grid(True)
Константу, которую мы использовали в левой части неявного уравнения, можно перенести в список значений линий уровня, т.е. в этом списке вместо нуля написать другое числовое значение. В результате будет построена та же кривая.
В команде plt.contour(X,Y,Z[,...]) оба массива X и Y могут быть одномерными. При этом количество столбцов в двумерном массиве Z должно равняться количеству элементов в X, а количество строк в Z равняться количеству элементов в Y. x = np.linspace( -2., 2.,41) y = np.linspace( -2., 2.,41) fig = plt.figure(facecolor='white'); ax=fig.gca() plt.contour(x, y, 3*x + 2*y[:, None], [1],linewidths=3, colors='r'); plt.contour(x, y, x**2 - y[:, None]**2, [1],linewidths=3, colors='g') plt.contour(x, y, x**2 + y[:, None]**2, [ 1],linewidths=3,colors='b') ax.axis('image') locs =np.linspace( -2,2,5) ax.set_xticks(locs, minor = False); ax.set_yticks(locs, minor = False);
Вот еще один пример. x=np.linspace(-1,1,101); y=x; z=np.outer(x,y); vals=np.linspace( -1,1,11); fig = plt.figure(facecolor='white') ax1 = fig.add_subplot(121)

137 curves=ax1.contour(x,y,z,vals,cmap='jet'); ax1.clabel(curves); ax2 = fig.add_subplot(122) ax2.contourf(x,y,z,vals,cmap='jet'); plt.suptitle(r'$z=xy$',fontsize=20)
Здесь функция plt.suptitle() печатает единый заголовок рисунка.
Для построения двумерных векторных полей используется функция plt.quiver()
, а для построения линии тока векторного поля – функция plt.streamplot().
Функция plt.quiver() строит график двумерных векторных полей.
Допустимы следующие варианты вызова этой функции. quiver(U, V[,...]) quiver(U, V, C[,...]) quiver(X, Y, U, V[,...]) quiver(X, Y, U, V, C[,...])
Массивы U и V представляют x и y компоненты векторного поля. Массивы X и Y задают положение стрелок (по умолчанию хвостов). Массив C определяет цвет стрелок. Обычно все эти массивы двумерные одинакового размера. Если массивы X и Y отсутствуют, то они соответствуют узлам регулярной координатной сетки.
Рассмотрим пример. Вначале подготовим массивы X, Y, U, V, C. n = 4
X, Y = np.mgrid[ -n:n+1, -n:n+1]
U=X; V=Y
C = np.sqrt(X ** 2 +Y ** 2)
Теперь введите и выполните следующий блок кода. fig = plt.figure(facecolor='white') ax=fig.gca() ax.quiver(X, Y, U, V)
# следующий рисунок слева.
Замените последнюю строку следующей инструкцией, и снова выполните пример. ax.quiver(X, Y, U, V, clr, alpha=.85)
# следующий рисунок справа

138
Опять замените последнюю строку инструкцией, и снова выполните пример. ax.quiver(X, Y, U, V, edgecolor='k', facecolor='None', linewidth=.5)
Результат показан на следующем рисунке слева. Затем выполните код, который выполняет две последние инструкции сразу. fig = plt.figure(facecolor ='white') ax=fig.gca() ax.quiver(X, Y, U, V, clr, alpha=.85) ax.quiver(X, Y, U, V, edgecolor='k', facecolor='None', linewidth=.5)
Результат показан на следующем рисунке справа.
Похожий синтаксис имеет функция plt.streamplot(X,Y,U,V[,...]), которая рисует линии тока векторного поля. fig = plt.figure(facecolor='white') x=np.linspace( -4,4,81) y=np.linspace( -4,4,81)
X, Y = np.meshgrid(x, y) ln = np.sqrt(X**2 + Y**2)
U=Y/ln; V= -X/ln plt.streamplot(X, Y, U, V, color=ln,
# массив цветов linewidth=1,
# толщина линий arrowstyle ='->',
# вид стрелок arrowsize =1.5)
# размер стрелок plt.colorbar()
# палитра цветов ax=fig.gca() ax.grid(True) ax.axis('image')

139
Кроме цвета, можно управлять толщиной линий, используя опцию linewidth=массив_толщин. fig = plt.figure(facecolor='white') x=np.linspace( -2,2,81) y=np.linspace( -2,2,81)
X, Y = np.meshgrid(x, y) ln = np.sqrt(X ** 2 +Y ** 2)
U=Y; V=-Y+X-X**3 lw = (1+2*np.cos(np.pi*X*Y/4)**2) plt.streamplot(X, Y, U, V, color=ln, linewidth=lw,
# толщина линий тока arrow, arrowsize=1.5) plt.colorbar()
# палитра цветов ax=fig.gca() ax.grid(True) fig.autofmt_xdate(rotation=90) ax.axis('image');
Столбчатые диаграммы дают визуальное представление об одномерном векторе/массиве данных.
Каждому элементу вектора соответствует прямоугольник, высота которого зависит от значения этого элемента. Для построения столбчатой диаграммы используется функция pyplot.bar(locs,vals[,width,...])
. Она принимает последовательность
(вектор) координат locs левых краев столбцов, вектор значений vals, и ширину прямоугольников width, которая по умолчанию равна 0.8. locs=np.arange(8) data=[8,2,5,3,6,1,4,7] plt.bar(locs, data, width=0. 5,color='blue')

140
На одной диаграмме можно отобразить несколько векторов. fig = plt.figure(facecolor='white') n=8 data1=10*np.random.rand(n) data2=10*np.random.rand(n) data3=10*np.random.rand(n) locs = np.arange(1,n+1) wid = 0.3 plt.bar(locs, data1, width=wid,color='blue') plt.bar(locs+wid, data2, width=wid, color='red') plt.bar(locs+2*wid, data3, width=wid, color='green') fig.gca().grid(True)
Кроме рассмотренной здесь функции plt.bar(), имеются другие функции построения диаграмм: plt.barh(), plt.barbs() и broken_barh(). С ними вы можете познакомиться самостоятельно по справочной системе.
Круговая диаграмма показывает вклада каждой компоненты вектора в итоговый результат (равный сумме всех компонент). Для построения круговой диаграммы используется функция pyplot.pie(vals,labels[,...]). Она принимает последовательность (вектор) значений vals, и их метки labels. fig = plt.figure(facecolor='white') data=[8,2,5,3,6,4] lbls = ['apple', 'pear', 'orange', 'lem on', 'cherries', 'currants'] plt.pie(data, labels = lbls);
# следующий рисунок слева fig.gca().axis('image')

141
Имеются различные аргументы, предназначенные для оформления таких диаграмм. Опция explode, если задается, является последовательность того же размера, что и вектор vals, и содержит значения радиального сдвига секторов круговой диаграммы. Опция autopct определяет форматирование числовых меток, которые по умолчанию показывают долю каждой компоненты вектора vals в процентах. fig = plt.figure(facecolor ='white') data=[8,2,5,3,6,4] epd = [0, 0, 0, 0, 0, 0.2] lbls = ['apple', 'pear', 'orange', 'lemon', 'cherries', 'currants'] plt.pie(data, labels = lbls,explode = epd, autopct = '%2.2f%%',shadow=True); fig.gca().axis('image')
# предыдущий рисунок справа
Гистограммы.
Гистограммой в дискретном анализе называется геометрическое изображение дискретной функции (массива), которое строится следующим образом. Сначала множество значений разбивается на несколько примыкающих интервалов (корзин), которые откладываются на горизонтальной оси. Затем подсчитывается количество элементов массива, попавшее в каждую корзину. Над каждым интервалом рисуется прямоугольник, высота которого пропорциональна этим числам.
Для построения гистограмм в matplotlib используется функция pyplot.hist(вектор, n)
, где n – количество корзин.
В следующем примере мы строим гистограмму двумерного массива Z, изображение которого показано на следующем рисунке слева. Двумерный массив перед передачей в функцию hist() преобразуется в одномерный.
Множество значений массива Z (функции f(x,y)) разбито на 128 интервалов
(корзин). Сама гистограмма показана справа. def f(x, y): return 1/(1+x**2+y**2) t = np.linspace( -2, 2, 401);
X, Y = np.meshgrid(t, t);
Z= f(X, Y); fig = plt.figure(facecolor='white') ax=fig.gca() img=ax.imshow(Z); ax.axis('image');

142 ax.axis('off')
G=Z.flatten();
fig = plt.figure(facecolor='white') plt.hist(G, 128); fig.gca().grid(True)
Заметим, что имеются еще функции построения гистограмм: plt.hist2d() и plt.hlines().
В модуле matplotlib.pyplot, кроме рассмотренных выше функций, имеется много других графических функций. С ними мы предлагаем вам познакомиться самостоятельно.
В завершении, приведем еще несколько функций, которые управляют графиками.
Функция matplotlib.pyplot.cla() очищает графическую область
(clear axes). Функция matplotlib.pyplot.clf() очищает рисунок от всех графических объектов (clear figure).
Функция matplotlib.pyplot.clim(vmin=v1,vmax=v2) устанавливает диапазон изменения цвета на текущем изображении.
4.2 Трехмерные графики matplotlib
Пакетом, предназначенным для работы с трехмерными графиками, является mpl_toolkits.mplot3d. В основном нам будут требоваться объекты и функции из его подмодуля Axes3D. Кроме импортирования этого модуля, нам почти всегда нужно будет импортировать пакет numpy и, конечно, модуль matplotlib и его подмодуль matplotlib.pyplot.
Договоримся, что будем строить графики в IPython Console Spyder. Чтобы трехмерные графики можно было свободно вращать мышкой, такие графики следует строить в графическом окне matplotlib, а не отображать их в документе.
Для этого нам потребуется выполнить магическую команду %matplotlib qt.
В результате, в начале каждой сессии IPython Console Spyder, в которой предполагается строить трехмерную графику, следует выполнить следующие инструкции.
%matplotlib qt import numpy as np

143 import matplotlib as mpl import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D
Будем полагать, что перед построением любого графика этого параграфа, эти команды уже выполнены.
Для построения трехмерного графика надо создать трехмерные оси с помощью экземпляра класса mpl_toolkits.mplot3d.Axes3D.
Его конструктор ожидает экземпляр класса Figure, который, в свою очередь, можно создать вызовом функции matplotlib.pyplot.figure().Т.о., в начале каждого примера мы будем вызывать две команды: fig = plt.figure()
# создаем пустое графическое окно ax=Axes3D(fig
)
# создаем в нем трехмерные оси
Фактически функция figure() создает пустое графическое окно, а результатом выполнения второй команды является изображение в этом окне трехмерной системы координат.
Для экономии места мы не показываем рамку и панель управления этого окна.
Кроме того, это изображение может быть встроенным в IPython документ.
Тогда рамки и панели вообще не будет.
При создании графического окна (объекта Figure) с помощью функции figure(...)
, ей можно передавать аргументы, которые управляют оформлением. Например, fig = plt.figure(num=номер)
# номер окна
Если рисунок с этим номером существует, то команда активирует его и возвращает на него ссылку; если рисунка с таким номером нет, то он создается и возвращается ссылка на него. Если аргументу num передается строка, то создается графическое окно с этим заголовком. fig = plt.figure(num='Hello Univer!')
# заголовок окна
По команде plt.figure() (без аргумента num) создается новый рисунок с номером, большим на 1, чем последний.
Еще одним необязательным аргументом является figsize, которому можно передавать кортеж из двух целых чисел, задающих размер графического окна в дюймах. Например, fig = plt.figure(figsize=(8,8))
# размер в дюймах
Необязательный аргумент facecolor задает цвет фона окна. Например, fig = plt.figure(facecolor='white')
# белый фон рисунка
Команда fig.clear() очищает графическое окно вместе с объектом
Axes3D
, если он был создан.

144
Команда plt.close(fig) закрывает окно, на которое ссылается переменная fig. Инструкция plt.close() закрывает окно текущего рисунка.
Инструкция plt.close(num) закрывает окно рисунка с номером num. Команда plt.close('all') закрывает окна всех рисунков.
После создания окна рисунка и графического объекта Axes3D дальнейшие действия зависят от функции, которую предполагается использовать для построения трехмерного графика.