Математический практикум по Питону.
Вводятся базовые элементы питона (Python версии 3.xx) на базе ключевых библиотек относящихся к анализу данных: numpy и matplotlib.
Это предварительная версия! Любые замечания приветсвуются.
Вычисления над векторами, матрицами
Списки хороши, но над ними как мы помним нельзя выполнять нужные нами арфиметических операций. В частности, списки нельзя складывать. Точнее эта операция будет иметь иное толкование:
In [1]:
import numpy as np
In [2]:
# Один из способов, как вычислить значение от каждого элемента списка, было показано выше.
# Показанный способ (отображение) был явный. Он был реализован на чистом питоне без вспомогательных средств.
# Но можно вычислить функцию от каждого элемента списка инче, использую вспомогательные (библиотечные) функции.
a = np.sin( [1.1, 2.2, -4.4] )
a
# Полученый объект уже не будет списоком (см. слово array). Он преврятится в массив, т.е. array.
Out[2]:
Тип array с точки зрения обычных языков фактически является массивом, т.е. объектом у которого тип элементов постоянен. По суте идексируемая переменная (имеет тот же тип). Такой тип соответсвует математическим понятиям вектора, матрице. Переменая с индексом. В следующей заметке перейдем к описанию массивов.
In [3]:
[1.1, 2.2, -4.4] + [2.5, 1.9, 5.1] # Они совместяться в один список (контакенация)
Out[3]:
Создание
Для содания списоков чисел, которые можно складывать поэлементно, нужны именно вектора/массивы.
In [4]:
# Они из списка создаются так:
np.array( [1.1, 2.2, -4.4])
Out[4]:
Размер массива всегда можно запросить у самого объекта.
In [5]:
l = np.array( [1.1, 2.2, -4.4]) # Сохраняем массив в переменную l.
l.shape # Запрашиваем у переменной её размер. Он хранится в переменной shape.
Out[5]:
In [6]:
bb = [55, 22, 33] # Создаем список.
bb.shape # Размер имеют объекты array. Другие не обязаны давать значение на это поле.
Замечу, что тип размер/размерность не указывает. Последнее связано с тем, что все элементы массива должны иметь одтн и тот же тип.
In [7]:
type( l ) # Запросим и тип.
Out[7]:
In [8]:
l.dtype # Тип элементов массива.
Out[8]:
Функцией
In [9]:
l = range(3, 10) # Создаем список с 3 до 10 (не включительно) с шагом 1.
np.array( l ) # Создаем по списку массив.
Out[9]:
In [10]:
np.array(range(1,15.4,2))
Их также можно генерировать готовой функцией.
In [11]:
np.arange(2, 20, 3) # В данному слачае, это последовательность
# с первого числа (2) по последнее (20!!!), но не включая его, с шагом (3).
Out[11]:
In [12]:
np.arange(2, 20.5, 1)
Out[12]:
Существуют и другие вспомогательные функции для формирования массивов. Например функция равномерного разбиения отрезка.
In [13]:
l=np.linspace(4, 25, 5) # А эта функция создает числа с первого (4) по последнее (включительно) (25) в количестве (5).
Сложные индексы
In [14]:
l
Out[14]:
In [15]:
l[2], type(l[2]) # Считываем значение и тип элемента массива.
Out[15]:
In [16]:
l[400] # Как и со списками нельзя обарщатся к эелементу, которого нет в массиве.
In [17]:
l[-1], l[1:-1:2] # Такая же история и сложными индексами.
Out[17]:
Базовые операции
Операции над массивами по-элементны.
In [18]:
# Такие объекты, массивы, можно складывть по элементно.
np.array( [1.1, 2.2, -4.4]) + np.array( [2.5, -1.9, 5.1])
Out[18]:
In [19]:
# Размер массивов должен совпадать. Иначе система выдаст соответствующую ошибку.
np.array( [1.1, 2.2, -4.4]) + np.array( [2.5, -1.9, 5.1, 7.1])
При выводе ошибки система указала, что один массив имеет размер 3, а другой -- 4. Даже была указана их одномерность.
Упр. По массиву значений построй массив отношения текущего элемента к последующему (результирующий массив будет на один элемент меньше).
In [20]:
a0 = np.array([-1, 2, 3])
a0
Out[20]:
In [21]:
a1 = np.array([3, 5, -2])
a1
Out[21]:
In [22]:
a0 * a1 # Поэлементное умножение массивов, а не скалярное.
Out[22]:
In [23]:
# Ну или в явном виде, т.е. без создания дополнительных промежуточных переменных.
np.array([-2, 7]) * np.array([ -2 , 5])
Out[23]:
Тип элементов
In [24]:
# В отличии от списка, все элементы массива должны иметь один и тот же тип. Если объявить так:
q = np.array( [1.0, "aa"] )
q
Out[24]:
In [25]:
type(q[0]), type(q[1]) # то число тоже станет строчкой.
Out[25]:
In [26]:
np.array( [1.0, "aa"] ) + np.array( [2.0, "bb"] ) # Сложить их как раньше не получится.
Вычисления над массивами
В библиотеке есть набор функций для обработки массивов. Так, помимо поэлеметных функий наподобии np.sin
In [27]:
l = np.array(l)
l
Out[27]:
In [28]:
3*l
Out[28]:
In [29]:
np.sin( l )
Out[29]:
имеются и редуцирующие к числу. Например,
In [30]:
np.sum( l ) # Сумма элементов
Out[30]:
In [31]:
np.mean( l ), np.std( l ) # Срежнее значение и среднеквадратичное откланение.
Out[31]:
In [32]:
np.median( l ), np.max( l ), np.min( l ) # Медиана, максимальное и мимимальное значение.
Out[32]:
Упр. По массиву посчитай скользящее среднее, т.е. среднее окна из например 10 элементов. Окно скользит по массиву.
In [33]:
import matplotlib.pyplot as plt
In [34]:
# Сгенерируем именно равномерный на набор точек.
x = np.linspace(-5, 9.5, 29)
y = x*x - 2*x + 3
plt.plot( x, y, 'g.-')
Out[34]:
In [35]:
plt.plot( x, np.sin(x), 'g.-')
plt.plot(x, x*x/100, 'b*--')
plt.xlabel( "Ось абсцисс" )
plt.ylabel( "Ось ординат")
#plt.axis('equal') # Чтобы оси были одного масштаба.
plt.legend( ['sin', 'x^2'] )
Out[35]:
Произведение векторов
In [36]:
# Скаляроне произведение.
a = np.array([ 1, 2, 3])
b = np.array([ -1, 0, 2])
np.inner( a, b) # Скяларное произведение
Out[36]:
In [37]:
a * b # Поэлементное произведение векторов.
Out[37]:
In [38]:
np.sum( a * b ) # Но можно и так.
Out[38]:
In [39]:
np.dot(a, b)
Out[39]:
In [40]:
# Сопряженное скалярное произведение.
a = np.array([ 1 + 2j, 3 + 4j])
b = np.array([ 1 - 2j, 3 + 4j])
np.vdot(a, b)
Out[40]:
In [41]:
c = a * b
c
Out[41]:
In [42]:
np.dot( a.conjugate(), b )
Out[42]:
Многомерные массивы
In [43]:
# Расширение данной идеи на двумерные массивы.
a0 = np.array([[-1], [2]]) # На вторую размерность указывают вложенные скобки.
a0 # Отмечу, если раньше a0 был массивом, то теперь стал матрицей, т.е. поменялась размерность.
Out[43]:
In [44]:
b0 = np.array([ [3] , [5]])
b0
Out[44]:
In [45]:
# Размеры у матрицы a0 были:
a0.shape # т.е. две строки, в каждой из которых по одному элементу.
Out[45]:
In [46]:
a0 = np.array([[-1, 2]]) # Можно сделать матрицу наоборот (транспонирование).
a0
Out[46]:
In [47]:
b0.shape, a0.shape
Out[47]:
In [48]:
np.dot(a0,b0)
Out[48]:
In [49]:
a0.shape # Одна строка, содержащая два элемента.
Out[49]:
In [50]:
# Матрицы можно формировать из других матриц.
a0 = np.array( [ 3, -6 ] )
a1 = np.array( [ -1, 2 ] )
a = np.array( [ a0, a1] )
a
Out[50]:
In [51]:
# Размеры должны конечно должны соответствовать.
a0 = np.array( [ 3, -6, 5 ] )
a1 = np.array( [ -1, 2 ] )
aa = np.array( [ a0, a1] )
aa # Иначе это бует массив объектов. Аккуратно сравни и увидь разницу!
Out[51]:
In [52]:
np.zeros((4,6))
Out[52]:
In [53]:
# Поэлементное умножение матриц (элемент массива является одноэлементным массивом).
a0 * b0 # Не путать с матричным умножением!
Out[53]:
In [54]:
a0
Out[54]:
In [55]:
np.array([[[1],[2]],[[3],[4]]])*a0
Out[55]:
In [56]:
a0.shape,b0.shape
Out[56]:
In [57]:
#b0=np.array([1,2,3])
#a0*b0
In [58]:
# Такие матрицы тоже можно умножать по-элементно.
np.array([[-1, 2]]) * np.array([ [3 , 5]])
Out[58]:
Как было показано выше, массивы можно создавать по спискам, т.е. сначала делается список, а потом массив по нему.
In [59]:
v = np.array([-2,1])
v
Out[59]:
In [60]:
a.dot(v) # Обычное произведение вектора на матрицу.
Out[60]:
In [61]:
np.dot( a[0], v), np.dot( a[1], v)
Out[61]:
Линейные уравнения
In [62]:
# Зададим матрицу в переменной a.
a = np.array( [ [2, -1], [1, 3] ] ) # 2x -y = 9
b = np.array( [ 9, 8] ) # 1x +3y = 8
a, b # Вектор значений в b.
Out[62]:
In [63]:
# Решаем систему уравнений.
x = np.linalg.solve(a, b)
x
Out[63]:
In [64]:
np.dot(a, x) # Проверяем правильность решения.
Out[64]:
In [65]:
# Проверяем на равенство с учетом машинного эпсилон,
np.allclose(np.dot(a, x), b) # т.е. числа могуть чуть отличаться.
Out[65]:
In [66]:
# Например, должны были получить 0,
5 - np.sqrt( 5 ) ** 2 # но жизнь иначе распорядилась.
Out[66]:
In [67]:
a.shape, x.shape
Out[67]:
In [68]:
np.dot(a, x.reshape(2,1) )
Out[68]:
In [69]:
np.allclose( 5 , np.sqrt( 5 ) ** 2 )
Out[69]:
In [70]:
# Проверим, что все-таки когда нет равенства,
np.allclose( 5 - 0.1 , np.sqrt( 5 ) ** 2 ) # будет лож.
Out[70]:
In [71]:
np.allclose( 5 , (5**(0.5)) ** 2 )
Out[71]:
In [72]:
# Можно вычислить и обратную матрицу в явном виде
# a = np.array( [ [2, -1], [1, 3] ] )
ainv = np.linalg.inv( a )
ainv
Out[72]:
Решаем систему. Для этого используем произведение вектора на матрицу.
In [73]:
# Умножаем обратную матрицу на вектор значений.
ainv.dot( b ) # Получили тот же ответ, что и раньше.
Out[73]:
In [74]:
# Можно умножить и на матрицу. Тогда произведение матрицы на её обратное должно дать единичную.
np.allclose( np.dot(a, ainv), np.eye(2) )
Out[74]:
Линейная регрессия
In [75]:
x = np.linspace(-5, 9.5, 9)
y = 0.5*x - 3
plt.plot(x, y)
plt.axis('equal')
Out[75]:
In [76]:
np.random.randn() # Гауссова случайная величина. Нормальное распределение.
Out[76]:
In [77]:
# Добавим шума к данным.
yy = y + np.random.randn()
In [78]:
plt.plot(x, yy) # Нарисуем график.
plt.axis('equal') # Оси будут иметь один масштаб.
# Чего-то не видна шума.
Out[78]:
In [79]:
yy[3]-y[3], yy[1]-y[1]
# Видно, что ко всем зачениям y была добавлена одна и та же случайная величина.
Out[79]:
In [80]:
# Теперь создадим массив из случайных величин.
yy = y + np.random.randn( y.shape[0] ) # В скобках размер.
In [81]:
plt.plot(x, yy)
plt.axis('equal')
Out[81]:
In [82]:
yy = y + np.random.randn( y.shape[0] )/3 # По-меньше шум.
plt.plot(x, yy, '-b')
plt.plot(x, yy, '*r')
plt.axis('equal')
Out[82]:
In [83]:
# Создаем общую матрицу. Присваеваем её переменной A.
A = np.array( [np.ones_like(x), x ] )
A
Out[83]:
In [84]:
A = A.T # Транспонирование.
A
Out[84]:
In [85]:
# Матрица прямоугольная.
A.shape # Значит обратной не существует.
Out[85]:
In [86]:
# Вычисляем псевдо обратную матрицу от A. Метод решения обычных систем не годится.
AA = np.linalg.pinv(A)
AA.shape
Out[86]:
In [87]:
AA.dot(yy) # Домножаем на значения
# и получаем коэффициенты исходного уравнения.
Out[87]:
Упр. Нарисуй график данной прямой. Лучше поверх исходных данных.
In [ ]: