Numpy and plotting basics

numpy-tutorial.ipynb

{
 "metadata": {
  "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
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python_defaultSpec_1596961695556",
   "display_name": "Python 3.8.2 64-bit"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "вектор:\n [1 2 3 4 5]\nматрица:\n [[0 1 2 3 4]\n [0 1 2 3 4]\n [0 1 2 3 4]\n [0 1 2 3 4]\n [0 1 2 3 4]]\nвектор нулей:\n [0. 0. 0. 0.]\nвектор единиц:\n [1. 1. 1.]\nмассив из диапазона:\n [0 1 2]\nмассив из диапазона, более сложный вариант:\n [3 5 7 9]\nlinspace:\n [ 0.   2.5  5.   7.5 10. ]\n"
    }
   ],
   "source": [
    "# создание массивов\n",
    "a = np.array([1,2,3,4,5]) # в скобках может стоять ЛЮБАЯ последовательность\n",
    "print(\"вектор:\\n\", a)\n",
    "a = np.array([list(range(5)) for _ in range(5)]) # создаём массив NumPy из двумерного списка\n",
    "print(\"матрица:\\n\", a)\n",
    "\n",
    "print(\"вектор нулей:\\n\", np.zeros(4))\n",
    "print(\"вектор единиц:\\n\", np.ones(3))\n",
    "print(\"массив из диапазона:\\n\", np.arange(3))\n",
    "print(\"массив из диапазона, более сложный вариант:\\n\", np.arange(3,11,2))\n",
    "print(\"linspace:\\n\", np.linspace(0, 10, num=5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "количество измерений матрицы 2\nразмерность матрицы (5, 5)\nколичество элементов матрицы 25\n"
    }
   ],
   "source": [
    "a = np.array([list(range(5)) for _ in range(5)]) # создаём массив NumPy из двумерного списка\n",
    "print(\"количество измерений матрицы\",a.ndim)\n",
    "print(\"размерность матрицы\", a.shape)\n",
    "print(\"количество элементов матрицы\", a.size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[1 2 3 4 5]\n[78  2  3  4  5] [78  2  3  4  5]\n[1 2 3 4 5]\n[1 2 3 4 5] [78  2  3  4  5]\n"
    }
   ],
   "source": [
    "a[0] # получение по индексу\n",
    "a[2:5] # срезы\n",
    "a[2:5:2]\n",
    "\n",
    "# для массивов NumPy срезы создают ОТОБРАЖЕНИЯ, а НЕ КОПИРУЮТ данные\n",
    "a = np.array([1,2,3,4,5])\n",
    "print(a)\n",
    "b = a\n",
    "b[0] = 78\n",
    "print(a,b) # меняли b, но поменялся также и a\n",
    "\n",
    "# чтобы не портить старые данные, можно использовать copy:\n",
    "a = np.array([1,2,3,4,5])\n",
    "print(a)\n",
    "b = a.copy()\n",
    "b[0] = 78\n",
    "print(a,b) # меняли b, но поменялся также и a\n",
    "\n",
    "# на самом деле это почти никогда не требуется - мы просто генерируем новые данные на основе старых, а не меняем на месте"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "конкатенация векторов:\n [1 2 3 4 5 1 2 3 4 5]\nсложение векторов:\n [ 2  4  6  8 10]\nx:\n [[1 2]\n [3 4]]\ny:\n [[5 6]]\nконкатенация матриц:\n [[1 2]\n [3 4]\n [5 6]]\nсложение матриц:\n [[ 6  8]\n [ 8 10]]\n"
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5])\n",
    "print(\"конкатенация векторов:\\n\", np.concatenate((a, a))) # внимание на скобки !\n",
    "print(\"сложение векторов:\\n\", a+a)\n",
    "\n",
    "\n",
    "x = np.array([[1, 2], [3, 4]])\n",
    "print(\"x:\\n\", x)\n",
    "y = np.array([[5, 6]])\n",
    "print(\"y:\\n\", y)\n",
    "print(\"конкатенация матриц:\\n\", np.concatenate((x, y), axis=0)) # внимание на скобки !\n",
    "print(\"сложение матриц:\\n\", x+y)\n",
    "\n",
    "# Арифметические и др. операции над векторами работают ПОЭЛЕМЕНТНО. Т.е. +, -, *, np.StopIteration\n",
    "# Также можно проводить операции с массивом и число, они тоже поэлементные. Т.е. сложение матрицы и числа сложит каждый элемент матрицы с ним и т.д."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "a:\n [0 1 2 3 4 5]\n3x2:\n [[0 1]\n [2 3]\n [4 5]]\n"
    }
   ],
   "source": [
    "# изменение размерности\n",
    "a = np.arange(6)\n",
    "print(\"a:\\n\", a)\n",
    "print(\"3x2:\\n\", a.reshape(3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "больше 5 ? [False False False False False  True  True  True  True  True]\nчётное ?   [False  True False  True False  True False  True False  True]\nэлементы больше 5 [ 6  7  8  9 10]\nчётные элементы   [ 2  4  6  8 10]\nделятся на 3 и не делятся на 2  [3 9]\n[ 2  4  6  8  9 10]\n"
    }
   ],
   "source": [
    "# продвинутая выборка из массива\n",
    "a = np.array([1,2,3,4,5,6,7,8,9,10])\n",
    "\n",
    "# Применение логических операций к массиву порождает массив булевских значений\n",
    "print(\"больше 5 ?\", a > 5 )\n",
    "print(\"чётное ?  \", a % 2 == 0) # остаток от деления равен нулю, т.е. числа чётные\n",
    "\n",
    "# Такие массивы можно применять к другим массивам для выборки:\n",
    "print(\"элементы больше 5\", a[a>5])\n",
    "print(\"чётные элементы  \", a[a % 2 == 0])\n",
    "\n",
    "# Для составления более сложных условий использовать операторы И (&) и ИЛИ (|) и скобки, питоновские and и or здесь не работают!\n",
    "print(\"делятся на 3 и не делятся на 2 \", a[(a%3==0) & (a%2!=0)])\n",
    "\n",
    "# или так:\n",
    "делятся_на_2_или_больше_8 = (a%2==0) | (a>8)\n",
    "print(a[делятся_на_2_или_больше_8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "[ 1  2  3  4  5  6  7  8  9 10]\n[ 1  2  3  4  5  6  7  8  9 10]\n[ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.] он тут по умолчанию сделал float числа\n[ 1  2  3  4  5  6  7  8  9 10]\n"
    }
   ],
   "source": [
    "# СОХРАНЕНИЕ МАССИВОВ В ФАЙЛ\n",
    "a = np.array([1,2,3,4,5,6,7,8,9,10])\n",
    "print(a)\n",
    "np.save('myarray', a) # записали. Автоматически добавляется расширение .npy\n",
    "b = np.load('myarray.npy') # считали\n",
    "print(b)\n",
    "\n",
    "\n",
    "# как CSV (но лучше использовать Pandas)\n",
    "np.savetxt('new_file.csv', a)\n",
    "b = np.loadtxt('new_file.csv')\n",
    "print(b, \"он тут по умолчанию сделал float числа\")\n",
    "\n",
    "# Пишем в своём формате (%d - целые числа как в Си, в функции printf) и со своим разделителем полей (;;)\n",
    "np.savetxt('new_file.csv', a, fmt=\"%d\", delimiter=\";;\")\n",
    "b = np.loadtxt('new_file.csv', dtype=int, delimiter=\";;\")\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Полезные встроенные функции:\n",
    "# np.min\n",
    "# np.max\n",
    "# np.sum\n",
    "# np.average\n",
    "\n",
    "'''\n",
    "\n",
    "Мораль такова: не надо ничего писать руками, нужно искать функцию из NumPy, SciPy и т.д.\n",
    "И только если такой не существует, делать самому на базе вышеизложенного.\n",
    "\n",
    "Думать нужно о высокоуровневой задаче и искать в Интернете также.\n",
    "Т.е. не разбивать задачу самому и не искать/спрашивать \"как пройтись в цикле по массиву\", а искать \"как в NumPy посчитать векторное произведение\"\n",
    "\n",
    "Кстати, векторное произведение считается так:\n",
    "A @ B или A.dot(B)\n",
    "\n",
    "См. https://numpy.org/doc/stable/reference/arrays.ndarray.html\n",
    "См. https://numpy.org/doc/stable/user/quickstart.html\n",
    "\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": "x:\n [[1 2 3]\n [4 5 6]\n [7 8 9]]\nx:\n [[1 4 7]\n [2 5 8]\n [3 6 9]]\n"
    }
   ],
   "source": [
    "# Транспонирование\n",
    "x = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "print(\"x:\\n\", x)\n",
    "print(\"x:\\n\", x.T) # T это даже не функция, а переменная"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ]
}

plot-format.ipynb

plots.ipynb