4_Numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Введение в numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Создание массивов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Импорт библиотеки для доступа к ней через сокращение с помощью ключевого слова as\n",
    "import numpy as np\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "Тип: int64\n"
     ]
    }
   ],
   "source": [
    "# Из списка\n",
    "a = np.array([1, 2, 3])\n",
    "print(a)\n",
    "print('Тип:', a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n",
      "Тип: float64\n"
     ]
    }
   ],
   "source": [
    "# С определением типа\n",
    "a = np.array([1, 2, 3], dtype=float)\n",
    "print(a)\n",
    "print('Тип:', a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "Тип: uint8\n",
      "[1. 2. 3.]\n",
      "Тип: float32\n"
     ]
    }
   ],
   "source": [
    "# Встроенные типы\n",
    "a = np.array([1, 2, 3], dtype=np.uint8)  # Unsigned int\n",
    "print(a)\n",
    "print('Тип:', a.dtype)\n",
    "a = np.array([1, 2, 3], dtype=np.float32)\n",
    "print(a)\n",
    "print('Тип:', a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2]\n",
      " [ 3  4]\n",
      " [ 9 10]]\n",
      "Форма: (3, 2)\n",
      "Размер: 6\n",
      "Размерность: 2\n"
     ]
    }
   ],
   "source": [
    "# Создание многомерного массива\n",
    "a = np.array([[1, 2], [3, 4], [9, 10]])\n",
    "print(a)\n",
    "print('Форма:', a.shape)\n",
    "print('Размер:', a.size)\n",
    "print('Размерность:', a.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[list([1, 2, 5]) list([3, 4]) list([9, 10])]\n",
      "\n",
      "[[ 1.+0.j  1.+2.j]\n",
      " [ 3.+0.j  4.+0.j]\n",
      " [ 9.+0.j 10.+0.j]]\n",
      "\n",
      "[['1' '2']\n",
      " ['3' '4']\n",
      " ['9' '10']]\n"
     ]
    }
   ],
   "source": [
    "# При разной размерности списков создаётся массив из списков\n",
    "b = np.array([[1, 2, 5], [3, 4], [9, 10]])\n",
    "print(b)\n",
    "print()\n",
    "# При разных типах элементов списков данные приводятся к общему типу\n",
    "b = np.array([[1, 1+2j], [3, 4], [9, 10]])\n",
    "print(b)\n",
    "print()\n",
    "b = np.array([[1, '2'], [3, 4], [9, 10]])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 2. 0.]\n",
      " [0. 0. 0.]]\n",
      "\n",
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "[1.  1.5 2.  2.5 3.  3.5 4.  4.5 5.  5.5 6.  6.5 7.  7.5 8.  8.5 9.  9.5]\n",
      "\n",
      "[ 1.   1.6  2.2  2.8  3.4  4.   4.6  5.2  5.8  6.4  7.   7.6  8.2  8.8\n",
      "  9.4 10. ]\n"
     ]
    }
   ],
   "source": [
    "# Создание пустого массива (только выделяется память)\n",
    "a = np.empty((2, 3))\n",
    "print(a)\n",
    "print()\n",
    "# Создание массива из нулей\n",
    "a = np.zeros((2, 3))\n",
    "print(a)\n",
    "print()\n",
    "# Создание массива из ряда чисел\n",
    "a = np.arange(1, 10)\n",
    "print(a)\n",
    "# Создание массива из ряда чисел с шагом\n",
    "a = np.arange(1, 10, 0.5)\n",
    "print(a)\n",
    "print()\n",
    "# Создание массива из ряда чисел с указанным количеством элементов\n",
    "a = np.linspace(1, 10, num=16)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 3.]\n",
      " [2. 5.]\n",
      " [4. 7.]]\n"
     ]
    }
   ],
   "source": [
    "# Задание из функции\n",
    "def fun(x, y):\n",
    "    return x * 2 + y * 3\n",
    "\n",
    "a = np.fromfunction(fun, (3, 2))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [1 2 3] b: [1 2 3]\n",
      "\n",
      "Без копирования\n",
      "a: [1 5 3] b: [1 5 3]\n",
      "\n",
      "С копированием\n",
      "a: [1 5 7] b: [1 5 3]\n"
     ]
    }
   ],
   "source": [
    "# Переменные в Python представляют собой указатели, \n",
    "# потому для копирования массивов необходимо указывать это явно с помощью метода copy()\n",
    "a = np.array([1, 2, 3])\n",
    "b = a\n",
    "print('a:', a, 'b:', b)\n",
    "a[1] = 5\n",
    "print()\n",
    "print('Без копирования')\n",
    "print('a:', a, 'b:', b)\n",
    "b = a.copy()\n",
    "a[2] = 7\n",
    "print()\n",
    "print('С копированием')\n",
    "print('a:', a, 'b:', b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Основные операции\n",
    "Операции, такие как сложение, умножение, и т.п. являются поэлементными. Возможны операции массива и числа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4] [15 14 13 12 11]\n",
      "\n",
      "[15 15 15 15 15]\n",
      "[ 0 14 26 36 44]\n",
      "[    1    14   169  1728 14641]\n",
      "\n",
      "[0.   0.25 0.5  0.75 1.  ]\n",
      "[30 28 26 24 22]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "b = np.arange(15, 10, -1)\n",
    "print(a, b)\n",
    "print()\n",
    "print(a + b)\n",
    "print(a * b)\n",
    "print(b ** a)\n",
    "print()\n",
    "print(a / 4)\n",
    "print(b * 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "# Скалярное произведение\n",
    "print(a @ b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Индексация"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c:\n",
      " [['a' 'b']\n",
      " ['c' 'd']]\n",
      "d: [ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "c = np.array([['a', 'b'], \n",
    "              ['c', 'd']])\n",
    "d = np.arange(1, 6) ** 2\n",
    "print('c:\\n', c)\n",
    "print('d:', d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 4 16]\n",
      "[ 4 16]\n"
     ]
    }
   ],
   "source": [
    "# Массив индексов\n",
    "print(d[[1, 3]])\n",
    "# Массив логических значений\n",
    "print(d[[False, True, False, True, False]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 0): c\n",
      "(:, 0): ['a' 'c']\n",
      "(1, :): ['c' 'd']\n"
     ]
    }
   ],
   "source": [
    "# Индексация по нескольким измерениям\n",
    "print('(1, 0):', c[1, 0])\n",
    "print('(:, 0):', c[:, 0])\n",
    "print('(1, :):', c[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Максимум, минимум: 0 4\n",
      "Среднее, среднеквадратичное отклонение: 2.0 1.4142135623730951\n",
      "Сумма элементов: 10\n",
      "Медиана: 2.0\n"
     ]
    }
   ],
   "source": [
    "### Вычисление статистических параметров\n",
    "# Максимум, минимум\n",
    "print('Максимум, минимум:', a.max(), a.min())\n",
    "# Среднее, среднеквадратичное отклонение\n",
    "print('Среднее, среднеквадратичное отклонение:', a.mean(), a.std())\n",
    "# Сумма элементов\n",
    "print('Сумма элементов:', a.sum())\n",
    "# Медиана\n",
    "print('Медиана:', np.median(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Длина: 3\n",
      "Подмассив: ['a' 'b']\n",
      "Подмассив: ['c' 'd']\n",
      "Подмассив: ['e' 'f']\n"
     ]
    }
   ],
   "source": [
    "# Итерирование\n",
    "e = np.array([['a', 'b'], ['c', 'd'], ['e', 'f']])\n",
    "print('Длина:', len(e))\n",
    "for row in e:\n",
    "    print('Подмассив:', row)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[       inf 1.         0.5        0.33333333 0.25      ]\n",
      "\n",
      "[nan  0.  0.  0.  0.]\n",
      "[ True False False False False]\n",
      "\n",
      "[1.57079633 0.                nan        nan        nan]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-17-c17408eda72d>:2: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  c = 1 / a # Возникает Warning (предупреждение) о делении на 0 (первый символ массива)\n",
      "<ipython-input-17-c17408eda72d>:6: RuntimeWarning: invalid value encountered in subtract\n",
      "  print(c - c)\n",
      "<ipython-input-17-c17408eda72d>:7: RuntimeWarning: invalid value encountered in subtract\n",
      "  print(np.isnan(c - c))  # Проверка на неопределённость\n",
      "<ipython-input-17-c17408eda72d>:10: RuntimeWarning: invalid value encountered in arccos\n",
      "  print(np.arccos(a))\n"
     ]
    }
   ],
   "source": [
    "# В numpy для вещественных чисел добавлены значения nan, inf для обозначения неопределённостей и бесконечностей\n",
    "c = 1 / a # Возникает Warning (предупреждение) о делении на 0 (первый символ массива)\n",
    "print(c)\n",
    "print()\n",
    "# Добавим неопределённость бесконечность - бесконечность\n",
    "print(c - c)\n",
    "print(np.isnan(c - c))  # Проверка на неопределённость\n",
    "print()\n",
    "# Или найдём arccos отчисла больше 1\n",
    "print(np.arccos(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Операции с формой"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n",
      "\n",
      "[[[ 0  1  2  3]\n",
      "  [ 4  5  6  7]\n",
      "  [ 8  9 10 11]]\n",
      "\n",
      " [[12 13 14 15]\n",
      "  [16 17 18 19]\n",
      "  [20 21 22 23]]]\n",
      "(2, 3, 4)\n",
      "\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(24)\n",
    "print(a)\n",
    "print()\n",
    "# Метод reshape() позволяет изменить форму массива, не меняя содержимого\n",
    "# Значение -1 означает, что заполняется по остаточному принципу\n",
    "b = a.reshape(-1, 3, 4)\n",
    "print(b)\n",
    "print(b.shape)\n",
    "print()\n",
    "# Метод ravel() приводит массив в одномерный вектор \n",
    "print(b.ravel())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  4  8]\n",
      "  [12 16 20]]\n",
      "\n",
      " [[ 1  5  9]\n",
      "  [13 17 21]]\n",
      "\n",
      " [[ 2  6 10]\n",
      "  [14 18 22]]\n",
      "\n",
      " [[ 3  7 11]\n",
      "  [15 19 23]]]\n",
      "(4, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Метод transpose() позволяет транспонировать массив (в указанную последовательность осей)\n",
    "c = b.transpose((2, 0, 1))\n",
    "print(c)\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a: [[0 1 2]\n",
      " [3 4 5]]\n",
      "b: [[10 11 12]\n",
      " [13 14 15]]\n",
      "\n",
      "[[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [10 11 12]\n",
      " [13 14 15]]\n",
      "\n",
      "Shape: (4, 3)\n",
      "\n",
      "[[ 0  1  2 10 11 12]\n",
      " [ 3  4  5 13 14 15]]\n",
      "\n",
      "Shape: (2, 6)\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(6).reshape((2, 3))\n",
    "b = np.arange(10, 16).reshape((2, 3))\n",
    "print('a:', a)\n",
    "print('b:', b)\n",
    "print()\n",
    "# concatenate() объединяет массивы вдоль существующей оси\n",
    "c = np.concatenate((a, b))\n",
    "print(c)\n",
    "print()\n",
    "print('Shape:', c.shape)\n",
    "print()\n",
    "\n",
    "c = np.concatenate((a, b), axis=-1)\n",
    "print(c)\n",
    "print()\n",
    "print('Shape:', c.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 0  1  2]\n",
      "  [ 3  4  5]]\n",
      "\n",
      " [[10 11 12]\n",
      "  [13 14 15]]]\n",
      "\n",
      "Shape: (2, 2, 3)\n",
      "[ 0 10]\n",
      "\n",
      "[[[ 0 10]\n",
      "  [ 1 11]\n",
      "  [ 2 12]]\n",
      "\n",
      " [[ 3 13]\n",
      "  [ 4 14]\n",
      "  [ 5 15]]]\n",
      "\n",
      "Shape: (2, 3, 2)\n",
      "[ 0 10]\n"
     ]
    }
   ],
   "source": [
    "# stack() объединяет массивы вдоль новой оси\n",
    "c = np.stack((a, b))\n",
    "print(c)\n",
    "print()\n",
    "print('Shape:', c.shape)\n",
    "print(c[:, 0, 0])\n",
    "print()\n",
    "\n",
    "c = np.stack((a, b), axis=-1)\n",
    "print(c)\n",
    "print()\n",
    "print('Shape:', c.shape)\n",
    "print(c[0, 0, :])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Математические операции\n",
    "В numpy существует множество функций, работающих по аналогии с функциями модулей math и random, но со всеми элементами массива"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin: [ 0.          0.84147098  0.90929743  0.14112001 -0.7568025 ]\n",
      "cos: [ 1. -1.  1. -1.  1.]\n",
      "корень: [0.         1.         1.41421356 1.73205081 2.        ]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "# Математические функции\n",
    "print('sin:', np.sin(a))\n",
    "print('cos:', np.cos(a * np.pi))\n",
    "print('корень:', np.sqrt(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 1 1 1 5]\n",
      " [3 4 7 0 0]]\n",
      "\n",
      "[[0.95143723 0.22385087 0.4292714  0.98347564 0.18905183]\n",
      " [0.85687288 0.72104609 0.08594073 0.72326151 0.36961344]]\n",
      "\n",
      "[ 0.27469785 -0.99027368 -1.27177667 -0.74613516 -0.66046949]\n"
     ]
    }
   ],
   "source": [
    "## Функции для работы со случайными числами\n",
    "# Инициализация генератора случайных чисел. Задание seed из модуля random не влияет на seed numpy\n",
    "np.random.seed(18182)\n",
    "# Случайные целые числа\n",
    "print(np.random.randint(10, size=(2, 5)))\n",
    "print()\n",
    "# Случайные числа от 0 до 1\n",
    "print(np.random.rand(2, 5))\n",
    "print()\n",
    "# Случайные числа с нормальным (гауссовым) распределением (среднее 0, среднеквадратичное отклонение 1).\n",
    "print(np.random.normal(size=5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/LessonsI/7_1_Gaussian distribution.jpg\" alt=\"Gaussian distribution\" height=40% width=40%> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 3 4 1 1 1 3 4 2]\n",
      "\n",
      "[3 2 1 4 0]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(18182)\n",
    "# Получение случайных чисел из массива\n",
    "a = np.arange(5)\n",
    "print(np.random.choice(a, 10))\n",
    "print()\n",
    "# Перемешивание массива (перемешивает исходный массив, возвращает None!)\n",
    "np.random.shuffle(a)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Операции с логическими переменными"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2 -4 -4 -4  0] [-2 -1  2 -5 -5]\n",
      "[ True False False False  True]\n",
      "[ True  True  True False False]\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(18182)\n",
    "a = np.random.randint(-5, 5, size=5)\n",
    "b = np.random.randint(-5, 5, size=5)\n",
    "print(a, b)\n",
    "a_bool = a > -3\n",
    "b_bool = b >= a\n",
    "print(a_bool)\n",
    "print(b_bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Логическое И: [ True False False False False]\n",
      "Логическое ИЛИ: [ True  True  True False  True]\n",
      "Логическое НЕ: [False  True  True  True False]\n",
      "Исключающее ИЛИ: [False  True  True False  True]\n",
      "\n",
      "Логическое И: [ True False False False False]\n",
      "Логическое ИЛИ: [ True  True  True False  True]\n",
      "Логическое НЕ: [False  True  True  True False]\n",
      "Логическое И: [False  True  True False  True]\n"
     ]
    }
   ],
   "source": [
    "# Логическое И\n",
    "print('Логическое И:', np.logical_and(a_bool, b_bool))\n",
    "# Логическое ИЛИ\n",
    "print('Логическое ИЛИ:', np.logical_or(a_bool, b_bool))\n",
    "# Логическое НЕ\n",
    "print('Логическое НЕ:', np.logical_not(a_bool))\n",
    "# Исключающее ИЛИ\n",
    "print('Исключающее ИЛИ:', np.logical_xor(a_bool, b_bool))\n",
    "print()\n",
    "# Другой вариант, с помощью битовых операций\n",
    "print('Логическое И:', a_bool & b_bool)\n",
    "print('Логическое ИЛИ:', a_bool | b_bool)\n",
    "print('Логическое НЕ:', ~a_bool)\n",
    "print('Логическое И:', a_bool ^ b_bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Операции со строками"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Раз' 'два' 'три' 'четые']\n",
      "['One' 'two' 'three' 'four']\n"
     ]
    }
   ],
   "source": [
    "a = np.array('Раз два три четые'.split(' '))\n",
    "b = np.array('One two three four'.split(' '))\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['РазOne' 'дваtwo' 'триthree' 'четыеfour']\n",
      "['Раз_' 'два_' 'три_' 'четые_']\n"
     ]
    }
   ],
   "source": [
    "# Конкатенация\n",
    "print(np.char.add(a, b))\n",
    "print(np.char.add(a, '_'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Раз' 'Два' 'Три' 'Четые']\n",
      "['РАЗ' 'ДВА' 'ТРИ' 'ЧЕТЫЕ']\n",
      "['раз' 'два' 'три' 'четые']\n"
     ]
    }
   ],
   "source": [
    "# Каждая строка с заглавной буквы\n",
    "print(np.char.capitalize(a))\n",
    "# Перевод в верхний регистр\n",
    "print(np.char.upper(a))\n",
    "# Перевод в нижний регистр\n",
    "print(np.char.lower(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Информация о строках"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[False  True  True False False False]\n",
      "[ True False  True False False False]\n"
     ]
    }
   ],
   "source": [
    "st = np.array(['One', 'two', 'three', 'four', '12', '-14'])\n",
    "# Проверка начала строки\n",
    "print(np.char.startswith(st, 't'))\n",
    "# Проверка окончания строки\n",
    "print(np.char.endswith(st, 'e'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 2 0 0 0]\n",
      "[False False False False  True False]\n"
     ]
    }
   ],
   "source": [
    "# Подсчет подстрок\n",
    "print(np.char.count(st, 'e'))\n",
    "# Строки, состоящие только из чисел\n",
    "print(np.char.isdigit(st))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Операции с матрицами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "# Функция dot возвращает скалярное произведение векторов:\n",
    "a = np.array([1, 2, 3])\n",
    "b = np.array([0, 1, 1])\n",
    "print(np.dot(a, b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3 13]\n",
      "\n",
      "[[ 4  0]\n",
      " [14  2]]\n"
     ]
    }
   ],
   "source": [
    "# Функция dot также может умножать матрицы:\n",
    "a = np.array([[0, 1], \n",
    "              [2, 3]])\n",
    "b = np.array([2, 3])\n",
    "c = np.array([[1, 1], \n",
    "              [4, 0]])\n",
    "print(np.dot(a, b))\n",
    "print()\n",
    "print(np.dot(a, c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 2 1]\n",
      " [8 8 4]\n",
      " [0 0 0]]\n",
      "\n",
      "10\n",
      "\n",
      "[ 4 -1 -6]\n"
     ]
    }
   ],
   "source": [
    "# Также можно получить скалярное, тензорное и внешнее произведение матриц и векторов.\n",
    "a = np.array([1, 4, 0])\n",
    "b = np.array([2, 2, 1])\n",
    "print(np.outer(a, b))\n",
    "print()\n",
    "print(np.inner(a, b))\n",
    "print()\n",
    "print(np.cross(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/LessonsI/7_4_R_mat.jpg\" alt=\"Rotation matrix\" height=50% width=50%> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Линейная алгебра"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Линейный оператор :\n",
    "# Пусть нам дано двумерное векторное пространство и линейный оператор, действующий в нем.\n",
    "# Матрица линейного оператора имеет вид:\n",
    "# A = | 1  2 |\n",
    "#     | 0  1 |\n",
    "# Найти координаты вектора, в который будет переведен с помощью оператора A вектор\n",
    "# x = [1, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Решение\n",
    "f = lambda x: np.dot(np.array([[1, 2], [0, 1]]), x.T)\n",
    "x = np.array([1, 2])\n",
    "x_ = f(x)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Что будет, если\n",
    "# A = | 1  0 |\n",
    "#     | 0  1 | ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Масштабирование\n",
    "# A = | s  0 |\n",
    "#     | 0  s |\n",
    "#Построить оператор, который по оси абсцисс уменьшает вектор в два раза, а по оси ординат увеличим в три раза:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 0. ],\n",
       "       [0. , 3. ]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Решение\n",
    "A = np.array([[0.5, 0], [0, 3]])\n",
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/LessonsI/scale_v.png\" alt=\"Scale vector\" height=40% width=40%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Отражение (поворот)\n",
    "# Оператор, выполняющий горизонтальное отражение, имеет следующую матрицу:\n",
    "# A = | -1  0 |\n",
    "#     |  0  1 |\n",
    "# Вертикальное отражение:\n",
    "# A = | 1   0 |\n",
    "#     | 0  -1 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/LessonsI/reflect1.png\" alt=\"Reflection vector\" height=40% width=40%>\n",
    "<img src=\"images/LessonsI/reflect2.png\" alt=\"Reflection vector\" height=40% width=40%> "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.5      , -0.8660254],\n",
       "       [ 0.8660254,  0.5      ]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_rot = np.array([[math.cos(math.pi/3), (-1)*math.sin(math.pi/3)],\n",
    "                  [math.sin(math.pi/3), math.cos(math.pi/3)]])\n",
    "A_rot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Сдвиг\n",
    "#   | 1  0  dx | | x |\n",
    "#   | 0  1  dy | | y |\n",
    "#   | 0  0  1  | | 1 |\n",
    "#\n",
    "# Матрица, перемещающая вектор на единицу по оси абсцисс и на двойку по оси ординат, будет иметь следующий вид:\n",
    "# A = | 1  0  1 |\n",
    "#     | 0  1  2 |\n",
    "#     | 0  0  1 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/LessonsI/transl_v.png\" alt=\"Translation vector\" height=40% width=40%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 1],\n",
       "       [0, 1, 2],\n",
       "       [0, 0, 1]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A_mov = np.array([[1, 0, 1], [0, 1, 2], [0, 0, 1]])\n",
    "A_mov"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Собственные векторы\n",
    "# Если из матрицы A вычесть единичную матрицу E, умноженную на некоторую переменную lambda,\n",
    "# то получим матрицу, которая называется характеристической матрицей матрицы A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"images/LessonsI/characteristic_matrix.png\" alt=\"Сharacteristic matrix\" height=40% width=40%>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Характеристическое уравнение для матрицы\n",
    "# f(lamb) = | A - lamb*E |\n",
    "# det(A - lamb*E )\n",
    "# f(lamb) = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Постройте характеристическое уравнение для следующей матрицы:\n",
    "# A = | 1  4  1 |\n",
    "#     | 0  2  2 |\n",
    "#     | 0  0  3 |\n",
    "# | A - lamb*E| - ?\n",
    "# Решите полученное уравнение\n",
    "# (lamb1 = 1, lamb2 = 2, lamb1 = 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Решение\n",
    "A = np.matrix(\"1 4 1; 0 2 2 ; 0 0 3\")\n",
    "L, v = np.linalg.eig(A) # L- Собственные числа, v -собственные векторы\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если линейный оператор переводит некоторый вектор X в вектор lamb*X, то такой вектор называется\n",
    "# собственным вектором оператора f:\n",
    "# f(X) = lamb*X\n",
    "# При этом lamb называется собственным значением линейного оператора f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# f(X) = lamb*X\n",
    "# A * x = lamb*x - масштабирование\n",
    "# Матрица A действует на собственный вектор как матрица масштабирования, или как поворот с theta = 0\n",
    "# |A| = |S| * | R |\n",
    "# A -> S или R -> I\n",
    "# Это значит, что собственный вектор x записан в той же системе координат, что и наша матрица. (x коллинеарен a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(matrix([[1.        , 0.9701425 , 0.89553347],\n",
       "         [0.        , 0.24253563, 0.39801488],\n",
       "         [0.        , 0.        , 0.19900744]]),\n",
       " matrix([[1.        , 1.940285  , 2.68660041],\n",
       "         [0.        , 0.48507125, 1.19404463],\n",
       "         [0.        , 0.        , 0.59702231]]))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v, A.dot(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Собственные числа это дисперсия, а собственные векторы - это ортонормированный базис системы координат"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  3]\n",
      " [ 6 11]]\n",
      "\n",
      "q: [[ 0. -1.]\n",
      " [-1.  0.]]\n",
      "r: [[-2. -3.]\n",
      " [ 0. -1.]]\n",
      "\n",
      "-2.0\n",
      "[[-1.5  0.5]\n",
      " [ 1.   0. ]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[0, 1], \n",
    "              [2, 3]])\n",
    "# Возведение в степень\n",
    "print(np.linalg.matrix_power(a, 2))\n",
    "print()\n",
    "# QR разложение\n",
    "q, r = np.linalg.qr(a)\n",
    "print('q:', q)\n",
    "print('r:', r)\n",
    "print()\n",
    "# Определитель\n",
    "print(np.linalg.det(a))\n",
    "# Обратная матрица\n",
    "print(np.linalg.inv(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-2.  3.]\n"
     ]
    }
   ],
   "source": [
    "# Решение системы линейных уравнений Ax = b\n",
    "a = np.array([[0, 1], \n",
    "              [2, 3]])\n",
    "b = np.array([3, 5])\n",
    "print(np.linalg.solve(a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Другие функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Исходный:\n",
      " [[2 3 3]\n",
      " [4 1 1]]\n",
      "\n",
      "Axis 0\n",
      " [[2 3 3]\n",
      " [6 4 4]]\n",
      "Axis 1\n",
      " [[2 5 8]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "# Использование функции вдоль заданной оси\n",
    "def fun(arr):\n",
    "    return arr.cumsum()\n",
    "\n",
    "np.random.seed(18182)\n",
    "a = np.random.randint(5, size=(2, 3))\n",
    "\n",
    "print('Исходный:\\n', a)\n",
    "print()\n",
    "print('Axis 0\\n', np.apply_along_axis(fun, 0, a))\n",
    "print('Axis 1\\n', np.apply_along_axis(fun, 1, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Исходный: [2 3 3 4 1 1 1 3 4 2]\n",
      "Уникальные значения [1 2 3 4]\n",
      "Уникальные значения и их частота (array([1, 2, 3, 4]), array([3, 2, 3, 2]))\n"
     ]
    }
   ],
   "source": [
    "# Поиск уникальных значений\n",
    "np.random.seed(18182)\n",
    "a = np.random.randint(5, size=10)\n",
    "print('Исходный:', a)\n",
    "print('Уникальные значения', np.unique(a))\n",
    "print('Уникальные значения и их частота', np.unique(a, return_counts=True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 3\n",
      "[4 5 6 0 9 1 2 7 3 8]\n"
     ]
    }
   ],
   "source": [
    "# Получение индексов массива\n",
    "print(a.max(), a.argmax())\n",
    "print(a.argsort())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Исходный:\n",
      " [[2 3 3]\n",
      " [4 1 1]]\n",
      "(array([0, 0, 1]), array([1, 2, 0]))\n"
     ]
    }
   ],
   "source": [
    "# Поиск индексов по условию\n",
    "np.random.seed(18182)\n",
    "b = np.random.randint(5, size=(2, 3))\n",
    "print('Исходный:\\n', b)\n",
    "print(np.where(b > 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Сравнение скорости"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def get_a_b(w, h, wh):\n",
    "    np.random.seed(42)\n",
    "    \n",
    "    a = np.random.rand(w, wh)\n",
    "    b = np.random.rand(wh, h)\n",
    "    return a, b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "w, h, wh = 10, 5, 3\n",
    "a, b = get_a_b(w, h, wh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 91 µs, sys: 14 µs, total: 105 µs\n",
      "Wall time: 109 µs\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "c = a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10, 5)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 114 µs, sys: 17 µs, total: 131 µs\n",
      "Wall time: 134 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "c_lst = []\n",
    "for i in range(w):\n",
    "    c_row = []\n",
    "    for j in range(h):\n",
    "        s = 0\n",
    "        for k in range(wh):\n",
    "            s += a[i, k] * b[k, j]\n",
    "        c_row.append(s)\n",
    "    c_lst.append(c_row)\n",
    "            \n",
    "c_lst = a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_lst = np.array(c_lst)\n",
    "(c_lst == c).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 117 µs, sys: 17 µs, total: 134 µs\n",
      "Wall time: 137 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "c_lst = [[sum([a[i, k] * b[k, j] for k in range(wh)]) for j in range(h)] for i in range(w)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c_lst = np.array(c_lst)\n",
    "(c_lst == c).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "w, h, wh = 1000, 500, 300\n",
    "a, b = get_a_b(w, h, wh)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 45.8 ms, sys: 19.6 ms, total: 65.3 ms\n",
      "Wall time: 21.8 ms\n"
     ]
    }
   ],
   "source": [
    "%%time \n",
    "c = a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 14s, sys: 191 ms, total: 1min 15s\n",
      "Wall time: 1min 14s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "c_lst = []\n",
    "for i in range(w):\n",
    "    c_row = []\n",
    "    for j in range(h):\n",
    "        s = 0\n",
    "        for k in range(wh):\n",
    "            s += a[i, k] * b[k, j]\n",
    "        c_row.append(s)\n",
    "    c_lst.append(c_row)\n",
    "            \n",
    "c_lst = a.dot(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1min 4s, sys: 120 ms, total: 1min 4s\n",
      "Wall time: 1min 4s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "c_lst = [[sum([a[i, k] * b[k, j] for k in range(wh)]) for j in range(h)] for i in range(w)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Задачи\n",
    "*Стараться избегать циклы*\n",
    "1. Отсортировать значения массива по частоте встречания. (длина массива при этом должна остаться прежней)\n",
    "2. Дана картинка высоты - h, ширины - w, количество каналов - 3, тип данных np.uint8 (от 0 до 255). Найти количество уникальных цветов (один цвет это три числа [122, 0, 255]).\n",
    "3. Написать функцию, вычисляющую плавающее среднее вектора\n",
    "4. Дана матрица (n, 3). Вывести те тройки чисел, которые являются длинами сторон треугольника.\n",
    "5. Решить следующую систему линейных уравнений (не используя np.linalg.solve):\n",
    "\\begin{equation}\n",
    "    \\begin{matrix}\n",
    "     \\left\\{\n",
    "    \\begin{matrix}\n",
    "    3x + 4y + 2z = 17  \\\\\n",
    "    5x + 2y + 3z = 23  \\\\\n",
    "    4x + 3y + 2z = 19  \\\\ \n",
    "    \\end{matrix} \\right.\n",
    "    \\end{matrix}\n",
    "\\end{equation}\n",
    "\n",
    "6.  Выполнить сингулярное разложение матрицы: \\\n",
    "A = np.matrix(\"1 0 1; 0 1 0; 1 0 1\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Лабораторные работы\n",
    "\n",
    "**Категорически нельзя использовать циклы ни в каком виде!!! Только функционал Numpy.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "### Лабораторная работа 4.1. Выбор случайных элементов массива\n",
    "\n",
    "Есть два набора данных: реальные и синтетические. Допустим, мы хотим обучить некоторую ML модель на смеси реальных и синтетических данных. При этом синтетические данные должны браться с вероятностью P. Важно сохранять порядок входных чисел.\n",
    "Например: Для массивов: [1,2,3,4,5,7,8,9,10] и [-1,-2,-3,-4,-5,-6,-7,-8,-9,-10] и P=0.2  \n",
    "Один из вариантов возвращаемого значения: [1,-2,3,4,-5,6,7,8,9,10]\n",
    "  \n",
    "Массивы реальных и синтетических данных одинаковой длины.\n",
    "  \n",
    "Реализовать скрипт random_select.py  \n",
    "Входные параметры скрипта: пути к двум файлам со списком целых чисел в каждом и вероятность P от 0 до 1. Например python2 random_select.py file_1.txt file_2.txt 0.3\n",
    "    file_1.txt содержит:  \n",
    "    1 2 3 4 5 6 7  \n",
    "    а file_2.txt  \n",
    "    -1 -2 -3 -4 -5 -6 -7  \n",
    "Результат перемешивания массивов вывести на экран.\n",
    "Перемешивание масивов должно происходить тремя РАЗЛИЧНЫМИ способами."
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}