sem07_numpy/sem_numpy_sol.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Семинар про Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Зачем нужен этот пакет? \n",
    "\n",
    "`numpy` — библиотека, позволяющая удобно работать с многомерными массивами и матрицами, содержащая математические функции. Кроме того, `numpy` позволяет векторизовать многие вычисления и пригождается в анализе данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n",
      "[1, 2, 3, 1, 2, 3, 1, 2, 3]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = [1, 2, 3]\n",
    "y = [4, 5, 6]\n",
    "\n",
    "print(x + y) # списки объединились вмесссте\n",
    "print(3 * x) # список продублировался трижды \n",
    "type(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5 7 9]\n",
      "[3 6 9]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2, 3])\n",
    "y = np.array([4, 5, 6])\n",
    "\n",
    "print(x + y) # в случае numpy поэлементное сложение\n",
    "print(3 * x) # каждый элемент умножился на число\n",
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Работает более быстро."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10**7)\n",
    "x[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = list(x)\n",
    "y[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13 s ± 46.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit \n",
    "sum(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6.03 ms ± 721 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit \n",
    "np.sum(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Вектора и матрицы\n",
    "\n",
    "Посмотрим на основы работы с матрицами и векторами подробнее!\n",
    "\n",
    "## 1.1 Вектора"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Векторно работает не только сложение, но и все другие операции. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1, 75])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1,-10,3,0,1,75,3])\n",
    "x[3:6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  1, 75,  3])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[x > 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 1, 3])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[(x > 0)&(x <= 70)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 75])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[[2,5]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть много сопособов создать в `numpy` вектор. Можно сделать это перечислением элементов, как выше для вектора `x`. А можно с помощью различных специальных функций."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.arange(start=10, stop=20, step=2) # последнее значение не включается!\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1.])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.ones(5) # вектор длины 5 из единиц\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0.])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.zeros(4) # вектор длины 4 из нулей\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.08300865, 0.72974462, 0.75087135, 0.66142326, 0.04489368])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.random.rand(5)  # случайный вектор, равномерное распределение на [0;1] \n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.ones_like(x) # вектор из единиц такой же длины как вектор x\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По сути вектор в `numpy` является одномерным массивом, что соответствует интуитивному определению вектора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(7,)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.shape # размерность вектора"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, как создавать векторы в `NumPy`, \n",
    "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.1/user/basics.creation.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Матрицы\n",
    "\n",
    "Можно создать матрицу!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [2, 5, 6],\n",
       "       [6, 7, 4]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [2, 5, 6], [6, 7, 4]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape # размерность"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 7, 4])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2]    # вторая строка матрицы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5, 7])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:,1]  # первый столбец матрицы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2][1] # можно срезать сначала строку, потом столбец"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,1]  # либос разу обе размерности"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6],\n",
       "       [7, 4]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[1:,1:] # можно найти срез"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о различных способах индексирования в массивах\n",
    "см. [документацию](http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False,  True],\n",
       "       [ True,  True, False]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 6, 7])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[A > 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 2, 2]), array([2, 0, 1]))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(A > 5)  # номера строк и столбцов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 6, 7])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "idx = np.where(A > 5)\n",
    "A[idx]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно создавать специальные матрицы разными функциями, по аналогии с векторами. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,3)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0.],\n",
       "       [0., 0., 0.],\n",
       "       [0., 0., 0.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,3)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.0361256 ,  0.43559029,  1.50079402],\n",
       "       [ 0.2742143 , -0.8604755 , -0.16980162],\n",
       "       [-0.78596025,  1.75187966, -0.92504816]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(size=(3,3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0., 0.],\n",
       "       [0., 1., 0., 0., 0.],\n",
       "       [0., 0., 1., 0., 0.],\n",
       "       [0., 0., 0., 1., 0.],\n",
       "       [0., 0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(5) # единичная матрица"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно изменять размерности, если число элементов позволяет это сделать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18, 20, 22])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.arange(0, 24, 2)\n",
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12,)"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4,  6],\n",
       "       [ 8, 10, 12, 14],\n",
       "       [16, 18, 20, 22]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.reshape((3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 12 into shape (3,6)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-a31d52b074a5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 12 into shape (3,6)"
     ]
    }
   ],
   "source": [
    "v.reshape((3, 6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4,  6],\n",
       "       [ 8, 10, 12, 14],\n",
       "       [16, 18, 20, 22]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.reshape((3, -1)) # -1 => если возможно, найди размерность второй оси автоматически"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3, 3)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = np.random.normal(size=(3,3,3))\n",
    "D.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[-0.33258426,  0.51560963,  1.51220033],\n",
       "        [ 0.2561937 , -0.83646691,  1.52926473],\n",
       "        [ 1.62069317, -1.03074117, -0.16747828]],\n",
       "\n",
       "       [[-0.13419933, -0.64552509, -0.4405012 ],\n",
       "        [-1.60217588, -0.55219259, -0.25367737],\n",
       "        [ 0.35185851,  0.81382537,  1.17123809]],\n",
       "\n",
       "       [[ 0.40575706, -0.24288298, -0.02642558],\n",
       "        [ 0.95152404,  0.58450746, -1.49231671],\n",
       "        [ 0.92225737, -2.1344927 , -1.25928176]]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D  # Вектор из матриц"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Массивы можно объединять:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 0., 0.],\n",
       "       [3., 4., 0., 0.]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [3, 4]])\n",
    "np.hstack((A, np.zeros(A.shape)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2.],\n",
       "       [3., 4.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack((A, np.zeros(A.shape)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, как создавать массивы в `numpy`, \n",
    "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.1/user/basics.creation.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Векторы, вектор-строки и вектор-столбцы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([[1], [2], [3]])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ _вектор_ (одномерный массив) и _вектор-столбец_ или _вектор-строка_ (двумерные массивы) являются различными объектами в `numpy`, хотя математически задают один и тот же объект. В случае одномерного массива кортеж `shape` состоит из одного числа и имеет вид `(n,)`, где `n` — длина вектора. В случае двумерных векторов в `shape` присутствует еще одна размерность, равная единице. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В большинстве случаев неважно, какое представление использовать, потому что часто срабатывает приведение типов. Но некоторые операции не работают для одномерных массивов. Например, транспонирование:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.4  Умножение матриц и векторов-столбцов\n",
    "\n",
    "Матрицы можно умножать!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 1],\n",
       "       [2, 2]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 0], [0, 1]])\n",
    "B = np.array([[4, 1], [2, 2]])\n",
    "A@B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 1],\n",
       "       [2, 2]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([6, 6])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([1, 2])\n",
    "B@x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ операция __`*`__ производит над матрицами покоординатное умножение, а не матричное!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 0],\n",
       "       [0, 2]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A * B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о матричном умножении в `numpy`\n",
    "см. [документацию](http://docs.scipy.org/doc/numpy-1.10.0/reference/routines.linalg.html#matrix-and-vector-products)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.5 Другие операции над матрицами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8, 10]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 10]])\n",
    "A  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  7],\n",
       "       [ 2,  5,  8],\n",
       "       [ 3,  6, 10]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.T  # Транспонирование"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.9999999999999996"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.det(A) # Определитель"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.matrix_rank(A) # Ранг матрицы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  5, 10])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(A) # главная диагональ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.66666667, -1.33333333,  1.        ],\n",
       "       [-0.66666667,  3.66666667, -2.        ],\n",
       "       [ 1.        , -2.        ,  1.        ]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.linalg.inv(A) # обратная матрица\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.00000000e+00, 0.00000000e+00, 1.11022302e-16],\n",
       "       [0.00000000e+00, 1.00000000e+00, 2.22044605e-16],\n",
       "       [8.88178420e-16, 0.00000000e+00, 1.00000000e+00]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A@B # Единичная матрица"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0830858278492343e-30"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum((A@B - np.eye(3))**2) # невязка между элементами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У некоторых функций бывает параметр `axis`, который позволяет применить эту функцию по разным осям. Если речь о матрицах, то по строкам или столбцам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3],\n",
       "       [ 4,  5,  6],\n",
       "       [ 7,  8, 10]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 10]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "46"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 15, 19])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6, 15, 25])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(A, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Решаем задачи\n",
    "\n",
    "В будущем вы будете учить анализ данных. Там неожиданно выяснится, что любые данные - это матрица. Там-то вы и увидите впервые всю мощь numpy. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 1:\n",
    "\n",
    "Реализуйте функцию, возвращающую максимальный элемент в векторе $x$ среди элементов, перед которыми стоит нулевой. \n",
    "\n",
    "Например, для `x = np.array([6, 2, 0, 3, 0, 0, 5, 7, 0])` ответом является `5`. Если нулевых элементов нет, функция должна возвращать `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Случайный вектор:\n",
      "[1 5 8 6 6 1 7 4 4 0]\n",
      "Максимальный элемент:\n",
      "None\n",
      " \n",
      "Случайный вектор:\n",
      "[1 6 6 8 7 4 4 2 4 0]\n",
      "Максимальный элемент:\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 5, 8, 6, 6, 1, 7, 4, 4, 0])\n",
    "y = np.random.randint(9, size=10)\n",
    "\n",
    "def max_element_before_zero(x):\n",
    "    shift_by_one = np.hstack((1, x))\n",
    "    bool_array = (shift_by_one == 0)[:np.size(shift_by_one) - 1]\n",
    "    if np.size(x[bool_array]) == 0:\n",
    "        return None\n",
    "    else:\n",
    "        return np.max(x[bool_array])\n",
    "    \n",
    "print('Случайный вектор:', x, 'Максимальный элемент:', max_element_before_zero(x), sep='\\n')\n",
    "print(' ')\n",
    "print('Случайный вектор:', y, 'Максимальный элемент:', max_element_before_zero(y), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Зачем?__ \n",
    "\n",
    "К вам в голову тут должна была прийти мысль: \"Зачем? Можно же использовать цикл!\". Да, можно. Но векторные вычисления работают на порядок быстрее. Часто сделать их намного удобнее, чем написать цикл."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 2:\n",
    "\n",
    "Есть матрица $X$. Нужно отнормировать её столбцы к отрезку $[0;1]:$\n",
    "\n",
    "$$\n",
    "x^{*} = \\frac{x−min(x)}{max(x)−min(x)}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.29573891, -0.84997366,  0.7969028 ,  0.20269066,  0.68969439],\n",
       "       [ 1.45096032,  0.05462041,  0.27125423,  0.52689547, -1.00156592],\n",
       "       [-0.42142528, -0.94736649, -0.42823488, -0.98346175, -0.34705659],\n",
       "       [-0.71608479, -1.05511298, -0.92022325,  0.26592516, -0.45338546],\n",
       "       [-0.04518416, -0.45219597,  1.02574257,  0.0253482 , -1.46770858]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.random.normal(size=(5,5))\n",
    "X"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.19397191, 0.18485459, 0.88240298, 0.78534561, 1.        ],\n",
       "       [1.        , 1.        , 0.61228078, 1.        , 0.21606657],\n",
       "       [0.13597294, 0.09709222, 0.25282477, 0.        , 0.51944491],\n",
       "       [0.        , 0.        , 0.        , 0.82721286, 0.47015932],\n",
       "       [0.30959237, 0.54329897, 1.        , 0.66792805, 0.        ]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(X - X.min(axis=0))/(X.max(axis=0) - X.min(axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Зачем?__ \n",
    "\n",
    "К вам в голову тут должна была прийти мысль: \"Зачем вообще делать это?\". \n",
    "\n",
    "Обычно в машинном обучении по строчкам записывают наблюдения, по столбцам разные признаки. Часто между объектами надо считать расстояния. Представим, что у нас в выборке два наблюдения. Петя, который весит $50$ кг при росте $1$ метр. И Вася, который вести $75$ кг при росте в $1.5$ метра. То есть Петя описывается вектором $(50, 1)$, а Вася $(75, 1.5)$. \n",
    "\n",
    "Если нам надо вычислить между парнями расстояние, мы будем делать это так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "625\n",
      "0.25\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "625.25"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print((50 - 75) ** 2)\n",
    "print((1 - 1.5) ** 2)\n",
    "(50 - 75) ** 2 + (1 - 1.5) ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Намного больше внимания уделяется весу. Чтобы такого не возникало, надо отнормировать все признаки к одной шкале. Например, отрезку $[0;1]$. \n",
    "\n",
    "> Если хотите узнать о том как линал используется в машинном обучении больше, смотрите небольшой видос про рекомендательные системы [\"От матрицы до больших данных\"](https://www.youtube.com/watch?v=Or119IXozCM)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 3:\n",
    "\n",
    "Реализуйте функцию, принимающую на вход матрицу $X$ и некоторое число $a$ и возвращающую ближайший к числу элемент матрицы. А потом перепишите её так, чтобы она возвращала самый дальний элемент. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "Число:\n",
      "3.6\n",
      "Ближайший к числу элемент матрицы:\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "def nearest_value(X, v):\n",
    "    Y = np.abs(X - v)\n",
    "    m = np.min(Y)\n",
    "    inds = np.where(Y == m)\n",
    "    return X[inds[0][0], inds[1][0]]\n",
    "\n",
    "X = np.arange(0,10).reshape((2, 5))\n",
    "v = 3.6\n",
    "print ('Матрица:', X, 'Число:', v, 'Ближайший к числу элемент матрицы:', nearest_value(X, v), sep='\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Матрица:\n",
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "Число:\n",
      "3.6\n",
      "Ближайший к числу элемент матрицы:\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Решение в одну строку\n",
    "def get_nearest_value(X, v):\n",
    "    return X.reshape(1, -1)[0][np.argmin(np.abs(X - v))]\n",
    "\n",
    "print ('Матрица:', X, 'Число:', v, \n",
    "       'Ближайший к числу элемент матрицы:', get_nearest_value(X, v), sep='\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание 4:\n",
    "\n",
    "Усложним предыдущую задачу! Дана матрица $X$ и вектор $v$. Нужно найти в матрице $X$ строку, которая будет ближе всего к вектору $v$. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0.46, 0.56, 0.42],\n",
       "        [0.48, 0.43, 0.64],\n",
       "        [0.49, 0.45, 0.48],\n",
       "        [0.54, 0.58, 0.43],\n",
       "        [0.49, 0.47, 0.55]]),\n",
       " array([[0.68375326],\n",
       "        [0.21737854],\n",
       "        [0.26845901],\n",
       "        [0.43438965],\n",
       "        [0.16611799]]))"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = np.random.binomial(100, 0.5, size=(5,3))/100\n",
    "v = np.random.uniform(size=(5,1))\n",
    "X, v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5.00655218e-02, 1.53148696e-02, 6.95657827e-02],\n",
       "       [6.89700296e-02, 4.52078839e-02, 1.78608896e-01],\n",
       "       [4.90804103e-02, 3.29571311e-02, 4.47495905e-02],\n",
       "       [1.11535455e-02, 2.12023733e-02, 1.92690481e-05],\n",
       "       [1.04899555e-01, 9.23442745e-02, 1.47365396e-01]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "R = (X - v)**2\n",
    "R"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.5330751 , 0.45500168, 0.66355778])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.sqrt(np.sum(R, axis=0))\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.56, 0.43, 0.45, 0.58, 0.47]]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:, np.where(z == np.min(z))].T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Зачем?__ \n",
    "\n",
    "Зачем вообще кому-то нужны задания 3 и 4?! В машинном обучения всюду вектора! Например, есть волшебная технология __word2vec__. В ней все слова превращают в вектора так, чтобы в них был закодирован смысл слова. В итоге неожиданно оказывается, что эти вектора можно складывать и вычитать. Если взять вектор _король_, вычесть из него _мужчина_ и добавить _женщина_, внезапно получится вектор, самым близким к которому является _королева_. \n",
    "\n",
    "Все эти вычисления удобно делать в `numpy`, написанными нами функциями. Поиграться с такой моделью и калькулятором слов можно [на сайте resvectores](https://rusvectores.org/ru/calculator/#)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Больше заданий для практики можно найти: \n",
    "\n",
    "- В [необязательном контесте](https://official.contest.yandex.ru/contest/25960/enter/) вас ждут простые и не очень задачи на numpy\n",
    "- В сборнике [100 упражнений на `numpy`](https://github.com/rougier/numpy-100/blob/master/100_Numpy_exercises_with_solutions.md), там же [вариант без решения с подсказками.](https://github.com/rougier/numpy-100) Некоторые упражнения странные и бесполезные. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Бонус-трек: линейная алгебра\n",
    "\n",
    "> Эту часть тетрадки мы __НЕ будем__ делать на семинаре. Её можно помотреть после него. Внутри много полезного функционала. Но ясное дело далеко не весь. Если хочется больше линала, да ещё и с python, добро пожаловать [курс по линал от ББ Демешева](https://www.coursera.org/learn/lineinaya-algebra) \n",
    "\n",
    "В этой части тетрадки мы поглубже поссмотим на функционал пакета. Далее нам понабится модуль `numpy.linalg`, реализующий некоторые приложения линейной алгебры."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Нормы векторов \n",
    "\n",
    "Вспомним некоторые нормы, которые можно ввести в пространстве $\\mathbb{R}^{n}$, и рассмотрим, с помощью каких библиотек и функций их можно вычислять в `numpy`.  Для вычисления различных норм мы используем функцию `numpy.linalg.norm(x, ord=None, ...)`, где `x` — исходный вектор, `ord` — параметр, определяющий норму (мы рассмотрим два варианта его значений — 1 и 2). \n",
    "\n",
    "### $\\ell_{2}$ норма\n",
    "\n",
    "$\\ell_{2}$ норма (также известная как евклидова норма)\n",
    "для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n",
    "\n",
    "$$\n",
    " \\left\\Vert x \\right\\Vert_{2} = \\sqrt{\\sum_{i=1}^n \\left( x_{i} \\right)^2}.\n",
    "$$\n",
    "\n",
    "Ей в функции `numpy.linalg.norm(x, ord=None, ...)` соответствует параметр `ord=2`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.linalg import norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.7416573867739413"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, -3])\n",
    "norm(a, ord=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### $\\ell_{1}$ норма\n",
    "\n",
    "$\\ell_{1}$ норма \n",
    "(также известная как [манхэттенское расстояние](https://ru.wikipedia.org/wiki/%D0%A0%D0%B0%D1%81%D1%81%D1%82%D0%BE%D1%8F%D0%BD%D0%B8%D0%B5_%D0%B3%D0%BE%D1%80%D0%BE%D0%B4%D1%81%D0%BA%D0%B8%D1%85_%D0%BA%D0%B2%D0%B0%D1%80%D1%82%D0%B0%D0%BB%D0%BE%D0%B2))\n",
    "для вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ вычисляется по формуле:\n",
    "\n",
    "$$\n",
    " \\left\\Vert x \\right\\Vert_{1} = \\sum_{i=1}^n \\left| x_{i} \\right|.\n",
    "$$\n",
    "\n",
    "Ей в функции `numpy.linalg.norm(x, ord=None, ...)` соответствует параметр `ord=1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.0"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, -3])\n",
    "norm(a, ord=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, какие еще нормы (в том числе матричные) можно вычислить, см. [документацию](http://docs.scipy.org/doc/numpy-1.10.0/reference/generated/numpy.linalg.norm.html). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2   Расстояния между векторами\n",
    "\n",
    "Для двух векторов $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ и $y = (y_{1}, \\dots, y_{n}) \\in \\mathbb{R}^{n}$ $\\ell_{1}$ и $\\ell_{2}$ раccтояния вычисляются по следующим формулам соответственно:\n",
    "\n",
    "$$\n",
    " \\rho_{1}\\left( x, y \\right) = \\left\\Vert x - y \\right\\Vert_{1} = \\sum_{i=1}^n \\left| x_{i} - y_{i} \\right|\n",
    "$$\n",
    "\n",
    "$$\n",
    " \\rho_{2}\\left( x, y \\right) = \\left\\Vert x - y \\right\\Vert_{2} = \n",
    " \\sqrt{\\sum_{i=1}^n \\left( x_{i} - y_{i} \\right)^2}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2, -3])\n",
    "b = np.array([-4, 3, 8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.0"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm(a - b, ord=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.12435565298214"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm(a - b, ord=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также расстояние между векторами можно посчитать с помощью функции  `scipy.spatial.distance.cdist(XA, XB, metric='euclidean', p=2, ...)` из модуля `scipy`, предназначенного для выполнения научных и инженерных расчётов. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.spatial.distance import cdist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`scipy.spatial.distance.cdist(...)` требует, чтобы размерность `XA` и `XB` была как минимум двумерная. По этой причине для использования этой функции необходимо преобразовать _векторы_, которые мы рассматриваем в этом ноутбуке, к _вектор-строкам_ с помощью способов, которые мы рассмотрим ниже. \n",
    "\n",
    "Параметры `XA, XB` — исходные вектор-строки, а `metric` и `p` задают метрику расстояния\n",
    "(более подробно о том, какие метрики можно использовать, см. [документацию](http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.spatial.distance.cdist.html))."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Первый способ из _вектора_ сделать _веткор-строку (вектор-столбец)_ — это использовать _метод_ `array.reshape(shape)`, где параметр `shape` задает размерность вектора (кортеж чисел)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор a: [ 6  3 -5]\n",
      "Его размерность: (3,)\n",
      "Вектор b: [-1  0  7]\n",
      "Его размерность: (3,)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([6, 3, -5])\n",
    "b = np.array([-1, 0, 7])\n",
    "\n",
    "print('Вектор a:', a)\n",
    "print('Его размерность:', a.shape)\n",
    "print('Вектор b:', b)\n",
    "print('Его размерность:', b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "После применения метода reshape:\n",
      "\n",
      "Вектор-строка a: [[ 6  3 -5]]\n",
      "Его размерность: (1, 3)\n",
      "Вектор-строка b: [[-1  0  7]]\n",
      "Его размерность: (1, 3)\n"
     ]
    }
   ],
   "source": [
    "a = a.reshape((1, 3))\n",
    "b = b.reshape((1, 3))\n",
    "\n",
    "print('После применения метода reshape:\\n')\n",
    "print('Вектор-строка a:', a)\n",
    "print('Его размерность:', a.shape)\n",
    "print('Вектор-строка b:', b)\n",
    "print('Его размерность:', b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Манхэттенское расстояние между a и b (через cdist): [[22.]]\n"
     ]
    }
   ],
   "source": [
    "print('Манхэттенское расстояние между a и b (через cdist):', cdist(a, b, metric='cityblock'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что после применения этого метода размерность полученных вектор-строк будет равна `shape`. Следующий метод позволяет сделать такое же преобразование, но не изменяет размерность исходного вектора.  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `numpy` к размерностям объектов можно добавлять фиктивные оси с помощью `np.newaxis`. Для того, чтобы понять, как это сделать, рассмотрим пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор d: [  3   0   8   9 -10]\n",
      "Его размерность: (5,)\n"
     ]
    }
   ],
   "source": [
    "d = np.array([3, 0, 8, 9, -10])\n",
    "\n",
    "print('Вектор d:', d)\n",
    "print('Его размерность:', d.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Вектор d с newaxis --> вектор-строка:\n",
      " [[  3   0   8   9 -10]]\n",
      "Полученная размерность: (1, 5)\n",
      " \n",
      "Вектор d с newaxis --> вектор-столбец:\n",
      " [[  3]\n",
      " [  0]\n",
      " [  8]\n",
      " [  9]\n",
      " [-10]]\n",
      "Полученная размерность: (5, 1)\n"
     ]
    }
   ],
   "source": [
    "print('Вектор d с newaxis --> вектор-строка:\\n', d[np.newaxis, :])\n",
    "print('Полученная размерность:', d[np.newaxis, :].shape)\n",
    "print(' ')\n",
    "print('Вектор d с newaxis --> вектор-столбец:\\n', d[:, np.newaxis])\n",
    "print('Полученная размерность:', d[:, np.newaxis].shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Важно, что `np.newaxis` добавляет к размерности ось, длина которой равна 1 (это и логично, так как количество элементов должно сохраняться). Таким образом, надо вставлять новую ось там, где нужна единица в размерности. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь посчитаем расстояния с помощью `scipy.spatial.distance.cdist(...)`, используя `np.newaxis` для преобразования векторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Евклидово расстояние между a и b (через cdist): [[14.2126704]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([6, 3, -5])\n",
    "b = np.array([-1, 0, 7])\n",
    "\n",
    "print('Евклидово расстояние между a и b (через cdist):', cdist(a[np.newaxis, :], \n",
    "                                                               b[np.newaxis, :], \n",
    "                                                               metric='euclidean'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эта функция также позволяет вычислять попарные расстояния между множествами векторов. Например, пусть у нас имеется матрица размера $m_{A} \\times n$. Мы можем рассматривать ее как описание некоторых $m_{A}$ наблюдений в $n$-мерном пространстве. Пусть также имеется еще одна аналогичная матрица размера $m_{B} \\times n$, где  $m_{B}$ векторов в том же $n$-мерном пространстве. Часто необходимо посчитать попарные расстояния между векторами первого и второго множеств. \n",
    "\n",
    "В этом случае можно пользоваться функцией `scipy.spatial.distance.cdist(XA, XB, metric='euclidean', p=2, ...)`, где в качестве `XA, XB` необходимо передать две описанные матрицы. Функция возаращает матрицу попарных расстояний размера $m_{A} \\times m_{B}$, где элемент матрицы на $[i, j]$-ой позиции равен расстоянию между $i$-тым вектором первого множества и $j$-ым вектором второго множества. \n",
    "\n",
    "В данном случае эта функция предподчительнее `numpy.linalg.norm(...)`, так как она вычисляет попарные расстояния быстрее и эффективнее. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.3 Скалярное произведение и угол между векторами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([0, 5, -1])\n",
    "b = np.array([-4, 9, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Скалярное произведение в пространстве $\\mathbb{R}^{n}$ для двух векторов $x = (x_{1}, \\dots, x_{n})$ и $y = (y_{1}, \\dots, y_{n})$ определяется как:\n",
    "\n",
    "$$\n",
    "\\langle x, y \\rangle = \\sum_{i=1}^n x_{i} y_{i}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Скалярное произведение двух векторов можно вычислять помощью функции `numpy.dot(a, b, ...)` или _метода_ `vec1.dot(vec2)`, где `vec1` и `vec2` — исходные векторы. Также эти функции подходят для матричного умножения, о котором речь пойдет в следующем уроке. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(a, b) # через функцию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.dot(b) # через метод"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a@b # через матричное умножение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Длиной вектора $x = (x_{1}, \\dots, x_{n}) \\in \\mathbb{R}^{n}$ называется квадратный корень из скалярного произведения, то есть длина равна евклидовой норме вектора:\n",
    "\n",
    "$$\n",
    "\\left| x \\right| = \\sqrt{\\langle x, x \\rangle} = \\sqrt{\\sum_{i=1}^n x_{i}^2} =  \\left\\Vert x \\right\\Vert_{2}.\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь, когда мы знаем расстояние между двумя ненулевыми векторами и их длины, мы можем вычислить угол между ними через скалярное произведение:\n",
    "\n",
    "$$\n",
    "\\langle x, y \\rangle = \\left| x \\right| | y | \\cos(\\alpha)\n",
    "\\implies \\cos(\\alpha) = \\frac{\\langle x, y \\rangle}{\\left| x \\right| | y |},\n",
    "$$\n",
    "\n",
    "где $\\alpha \\in [0, \\pi]$ — угол между векторами $x$ и $y$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8000362836474323"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cos_angle = np.dot(a, b) / norm(a) / norm(b)\n",
    "cos_angle  # косинус угла"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6434406336093618"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arccos(cos_angle) # сам угол"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более подробно о том, как вычислять скалярное произведение в `numpy`, \n",
    "см. [документацию](http://docs.scipy.org/doc/numpy/reference/routines.linalg.html#matrix-and-vector-products)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.4 Системы линейных уравнений\n",
    "\n",
    "__Системой линейных алгебраических уравнений__ называется система вида $Ax = b$, где $A \\in \\mathbb{R}^{n \\times m}, x \\in \\mathbb{R}^{m \\times 1}, b \\in \\mathbb{R}^{n \\times 1}$. В случае квадратной невырожденной матрицы $A$ решение системы единственно.\n",
    "\n",
    "В `numpy` решение такой системы можно найти с помощью функции `numpy.linalg.solve(a, b)`, где первый аргумент — матрица $A$, второй — столбец $b$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 3.])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[3, 1], [1, 2]])\n",
    "b = np.array([9, 8])\n",
    "x = np.linalg.solve(A, b)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Убедимся, что вектор $x$ действительно является решением системы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9., 8.])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.dot(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Бывают случаи, когда решение системы не существует. Но хотелось бы все равно \"решить\" такую систему. Логичным кажется искать такой вектор $x$, который минимизирует выражение $\\left\\Vert Ax - b\\right\\Vert^{2}$ — так мы приблизим выражение $Ax$ к $b$.\n",
    "\n",
    "В `numpy` такое псевдорешение можно искать с помощью функции `numpy.linalg.lstsq(a, b, ...)`, где первые два аргумента такие же, как и для функции `numpy.linalg.solve()`. \n",
    "\n",
    "Помимо решения функция возвращает еще три значения, которые нам сейчас не понадобятся."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-108-d65c3da0d5d9>:3: FutureWarning: `rcond` parameter will change to the default of machine precision times ``max(M, N)`` where M and N are the input matrix dimensions.\n",
      "To use the future default and silence this warning we advise to pass `rcond=None`, to keep using the old, explicitly pass `rcond=-1`.\n",
      "  x, res, r, s = np.linalg.lstsq(A, b)\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[0, 1], [1, 1], [2, 1], [3, 1]])\n",
    "b = np.array([-1, 0.2, 0.9, 2.1])\n",
    "x, res, r, s = np.linalg.lstsq(A, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [1, 1],\n",
       "       [2, 1],\n",
       "       [3, 1]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1. ,  0.2,  0.9,  2.1])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.  , -0.95])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.5 Собственные числа и собственные вектора матрицы\n",
    "\n",
    "Для квадратных матриц определены понятия __собственного вектора__ и __собственного числа__.\n",
    "\n",
    "Пусть $A$ — квадратная матрица и $A \\in \\mathbb{R}^{n \\times n}$. __Собственным вектором__ матрицы $A$ называется такой ненулевой вектор $x \\in \\mathbb{R}^{n}$, что для некоторого $\\lambda \\in \\mathbb{R}$ выполняется равенство $Ax = \\lambda x$. При этом $\\lambda$ называется __собственным числом__ матрицы $A$. Собственные числа и собственные векторы матрицы играют важную роль в теории линейной алгебры и ее практических приложениях.\n",
    "\n",
    "В `numpy` собственные числа и собственные векторы матрицы вычисляются с помощью функции `numpy.linalg.eig(a)`, где `a` — исходная матрица. В качестве результата эта функция выдает одномерный массив `v` собственных чисел и двумерный массив `w`, в котором по столбцам записаны собственные вектора, так что вектор `w[:, i]` соотвествует собственному числу `v[i]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[-1, -6], [2, 6]])\n",
    "w, v = np.linalg.eig(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 3.])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.89442719,  0.83205029],\n",
       "       [ 0.4472136 , -0.5547002 ]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Обратите внимание:__ у вещественной матрицы собственные значения или собственные векторы могут быть комплексными."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.6  Комплексные числа в питоне\n",
    "\n",
    "__Комплексными числами__ называются числа вида $x + iy$, где $x$ и $y$ — вещественные числа, а $i$ — мнимая единица (величина, для которой выполняется равенство $i^{2} = -1$). Множество всех комплексных чисел обозначается буквой $\\mathbb{C}$ (подробнее про комплексные числа см. [википедию](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81%D0%BD%D0%BE%D0%B5_%D1%87%D0%B8%D1%81%D0%BB%D0%BE)).\n",
    "\n",
    "В питоне комплескные числа можно задать следующим образом ( $j$ обозначает мнимую единицу):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3+2j)"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 3 + 2j\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1j"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = 1j\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5+12j)"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a * a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.0487804878048781+0.5609756097560976j)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a / (4 - 5j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.605551275463989"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.605551275463989"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(3**2 + 2**2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}