Python_seminar_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Сохранение функций в отдельный файл для повторного использования\n",
    "\n",
    "Часто функции, написанные для одной задачи, используются в других(к примеру, прероцессинг текстовых файлов). Для их повторного использования, чтобы не копировать их из проекта в проект, удобно создать файл со всеми функциями и импортировать его как библиотеку. (import my_file)\n",
    "\n",
    "При этом хочется оставить проверки, что функции работают нормально, оставить возможность отлаживать функции, запуская файл с ними, а не импортируя. То есть плюс к функциям, хочется иметь внутри этого файла некоторый код, запускающий их.\n",
    "\n",
    "Немного об импорте - при импорте файла исполняется весь код внутри него. То есть импортируя файл мы запустим код для отладки, если он написан внутри файла, а не внутри отдельной функции. Выполнение отлаживающих строк может занимать лишнее время. Чтобы этого избежать, их помещают в функцию main(), а внутри файла с функциями пишут следющие строки:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "\n",
    "if \\__name\\__ == \"\\__main\\__\":\n",
    "    \n",
    "    main()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вы импортируете файл \\_\\_name\\_\\_ будет равно имени файла. Написанное выше условие не исполнено, функция main не отработала и отлаживающий код не выполнен. Если вы запускаете файл (к примеру python name_of_file.py в консоли) \\__name\\__ будет равно \"\\__main\\__\" и отлаживающий скрипт будет запущен."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Jupyter notebook\n",
    "\n",
    "Полезные функции, существующие в среде разработки:\n",
    "\n",
    "https://habrahabr.ru/company/wunderfund/blog/316826/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вся возможная магия:\n",
    "\n",
    "# % - для строки\n",
    "\n",
    "# %% - для ячейки\n",
    "\n",
    "%lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# посмотреть документацию о функции\n",
    "\n",
    "\n",
    "?open # open?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ! - выполнить команду командной строки\n",
    "\n",
    "! ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "замерить время выполнения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%timeit [1,2,3,4,5][2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%%timeit\n",
    "[1,2,3,4,5][2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "можно писать функции, используя latex:\n",
    "\n",
    "\\$\\$c = \\sqrt{a^2 + b^2}\\$\\$\n",
    "\n",
    "$$c = \\sqrt{a^2 + b^2}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# False and True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "False в Питоне являются следующие объекты:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. None\n",
    "\n",
    "2. False\n",
    "\n",
    "3. zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)\n",
    "\n",
    "4. empty sequences and collections: '', (), [], {}, set(), range(0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if []:\n",
    "    print ('[] is True')\n",
    "else:\n",
    "    print ('[] is False')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# List\n",
    "\n",
    "будьте осторожны с копирование списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = a\n",
    "print (b)\n",
    "a.append(5)\n",
    "print (b)\n",
    "print (a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создавать новый список со значениями как у текущего лучше так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3,4]\n",
    "b = a[:]\n",
    "print (b)\n",
    "print (a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И еще пример"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3, 'hello', False, 'we', ['qw', 1]]\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = [a]*2\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c[0][0] = 100\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "! изменился не только первый элемент"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если хотите скопировать значения в списке, а не ссылку на существующий список, можно сделать так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3, 'hello', False, 'we', ['qw', 1]]\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = []\n",
    "[c.append(a[:]) for _ in range(2)]\n",
    "print (c)\n",
    "c[0][0] = 100\n",
    "print (c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Loops vs. list comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Используйте генерацию списков вместо циклов - она быстрее и занимает меньше строк кода"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 1 -r 5\n",
    "a = []    \n",
    "for i in range(10000000):\n",
    "    a.append(i*2)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%timeit -n 1 -r 5\n",
    "\n",
    "a = [i*2 for i in range(10000000)]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "в Питоне < 3.6 ключи в словаре храняться не в том порядке, в котором вы их туда складывали ( output ячеек - результаты на Питоне 3.6, в коментариях результаты работы на младшем Питоне)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = dict() # {}\n",
    "a = {1:'a', 2:'b', 4:'c', 3:'d'}\n",
    "print (a) # {1: 'a', 2: 'b', 3: 'd', 4: 'c'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print ('items:', a.items()) # [(1, 'a'), (2, 'b'), (3, 'd'), (4, 'c')]\n",
    "print ('keys:', a.keys()) # [1, 2, 3, 4]\n",
    "#  !! заметьте, ключи не в том порядке, в каком они добавлялись\n",
    "print ('values:', a.values()) # ['a', 'b', 'd', 'c']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%python2 \n",
    "\n",
    "# for Python 2\n",
    "\n",
    "a = dict() # {}\n",
    "a = {1:'a', 2:'b', 4:'c', 3:'d'}\n",
    "print ('dict', a) # {1: 'a', 2: 'b', 3: 'd', 4: 'c'}\n",
    "\n",
    "print ('items:', a.items()) # [(1, 'a'), (2, 'b'), (3, 'd'), (4, 'c')]\n",
    "print ('keys:', a.keys()) # [1, 2, 3, 4]\n",
    "print ('values:', a.values()) # ['a', 'b', 'd', 'c']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Существуют специальные версии словарей\n",
    "\n",
    "OrderedDict() - ключи находят в том порядке, в каком добавлялись.\n",
    "\n",
    "defaultdict() - при обращении к несуществующему элементу создает его с указанным значение."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " # Dict comprehensions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для словарей можно использовать генерацию, как для списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{i:i*2 for i in range(10)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "char2number = {char_: char_i for char_i, char_ in enumerate('abcdefj') if char_ not in 'qweasd'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "char2number # {'b': 1, 'c': 2, 'f': 5, 'j': 6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "{value:key for key, value in char2number.items()} # {1: 'b', 2: 'c', 5: 'f', 6: 'j'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вы хотите сложный ключ - используйте кортежи. Они неизменяемы и могут быть ключами в словаре. Листы изменяемы, и не могут быть ключами словаря."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "dict_ = {(1,2):1}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict_ = {[1,2]:1} # TypeError: unhashable type: 'list'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# генераторы\n",
    "\n",
    "Для итерации по объектам в Питоне существуют генераторы\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Их можно создать, используя синтаксис с круглыми скобками или ключевое слово yield вместо return у функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(i for i in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gen(a):\n",
    "    for i in a:\n",
    "        yield i\n",
    "        \n",
    "print (gen([1,2,3]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Они запоминают, где остановился процесс итерации.\n",
    "\n",
    "Они проходят по итерируемому объекто только один раз"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = list(range(10))\n",
    "a = gen(b)\n",
    "for i in a:\n",
    "    print (i)\n",
    "    if i == 4:\n",
    "        break\n",
    "\n",
    "print ('-'*20)\n",
    "\n",
    "for i in a:\n",
    "    print (i)\n",
    "    \n",
    "print ('-'*20)\n",
    "    \n",
    "for i in a:\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Они не копируют объект, по которому итерируются. Если вы его измените - они выдадут вам новые значения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = list(range(10))\n",
    "a = gen(b)\n",
    "for i in a:\n",
    "    print (i)\n",
    "    if i == 4:\n",
    "        break\n",
    "        \n",
    "print ('-'*20)\n",
    "        \n",
    "b[5] = 10\n",
    "b[7] = 20\n",
    "\n",
    "for i in a:\n",
    "    print (i)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У функций можно задавать аргументы по умолчанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(name, surname=''):\n",
    "    \"\"\"return name\"\"\"\n",
    "    print ('Hi %s %s' % (name, surname))\n",
    "    \n",
    "fun('Alice')\n",
    "fun('Alice', 'Morozova')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Текст, написанный внутри \"\"\"text\"\"\"  - считается документацией и будет показан и запросе информации о вашей фенкции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "?fun\n",
    "\n",
    "# Signature: fun(name, surname='')\n",
    "# Docstring: return name\n",
    "# File:      /mnt/raid/o.malyugina/keyboard/skripts/<ipython-input-17-33bf7d893645>\n",
    "# Type:      function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если мы задаем значение по умолчанию как список - он будет создан только один раз. Все последующиеся - мы будем использовать уже созданный список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(a = []):\n",
    "    a.append(1)\n",
    "    return a\n",
    "    \n",
    "print (fun())\n",
    "print (fun())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Интересное об областях видимости:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_variable = 1\n",
    "\n",
    "def increment():\n",
    "    print (first_variable * 2)\n",
    "\n",
    "print (first_variable)\n",
    "increment()\n",
    "print (first_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_variable = 1\n",
    "\n",
    "def increment():\n",
    "    first_variable = 2\n",
    "\n",
    "print (first_variable)\n",
    "increment()\n",
    "print (first_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_variable = 1\n",
    "\n",
    "def increment():\n",
    "    global first_variable\n",
    "    first_variable = 2\n",
    "\n",
    "print (first_variable)\n",
    "increment()\n",
    "print (first_variable)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "first_variable = 1\n",
    "\n",
    "def increment_0():\n",
    "    print(first_variable)\n",
    "    first_variable = 2\n",
    "\n",
    "print (first_variable)\n",
    "increment_0()\n",
    "print (first_variable)\n",
    "\n",
    "#UnboundLocalError: local variable 'first_variable' referenced before assignment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В питоне передается ссылка на объект, а не сам объект. Поэтому список, переданный в функцию будет изменяться внутри функции.\n",
    "\n",
    "Не стоит менять дефолтные значения внутри функции. Вы можете об это забыть."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def upgrade (a):\n",
    "    a.append('1')\n",
    "    \n",
    "a = [2]\n",
    "print (a)\n",
    "upgrade(a)\n",
    "print (a)\n",
    "upgrade(a)\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Представление строк.\n",
    "в 3. только юникод строки\n",
    "\n",
    "Используйте codecs для загрузки из файлов, кодировка которых не utf-8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import codecs\n",
    "\n",
    "with codecs.open('tmp.py', 'r', encoding='cp1251') as f:  #r, w, a, wb, rb\n",
    "    data = f.read()  # f.readline() f.readlines(), f.write(text), f.writelines(list)\n",
    "\n",
    "print (data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также можно считывать и записывать байты - 'wb', 'rb'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как понять в какой кодировке у вас текст?\n",
    "https://habrahabr.ru/post/147843/\n",
    "    \n",
    "или изменение кодировки в блокноте, пока не получите читаемый текст"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Экранированные последовательности\n",
    "S = \"s\\np\\ta\\nbbb\"\n",
    "print (S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Неформатированные строки (подавляют экранирование) raw строки\n",
    "S = r\"C:\\temp\\new\"\n",
    "print (S)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#полезная библиотека\n",
    "import string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print (string.digits)\n",
    "print (string.punctuation)\n",
    "print (string.ascii_letters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "http://zwmiller.com/blogs/python_data_structure_speed.html - сравнение скоростей"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Используйте numpy когда имеете дело с числовыми матрицами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = list(range(100000))\n",
    "print (sys.getsizeof(a))\n",
    "b = np.array(a)\n",
    "print (sys.getsizeof(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit [i**2 for i in a]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit b**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получение значений, удовлетворяющих условию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print (a)\n",
    "\n",
    "bool_idx = (a > 2) \n",
    "print(bool_idx)     \n",
    "\n",
    "print(a[bool_idx])  \n",
    "print(a[a > 2]) \n",
    "print (bool_idx.any(axis = 0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print (a)\n",
    "a[a>2]=0\n",
    "print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тип данных в массиве можно задавать. Менять тип значений нужно руками - если вы решите заполнить массив интов флоатами - они автоматически приведутся к нужному типу"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1, 2])\n",
    "print(x.dtype)\n",
    "\n",
    "x.fill(0.5)\n",
    "print (x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# SciPy\n",
    "\n",
    "Используется при работе с разрежеными матрицами - очень сильно экономит место"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from scipy import sparse\n",
    "row = np.array([0, 0, 1, 2, 2, 2])\n",
    "col = np.array([0, 2, 2, 0, 1, 2])\n",
    "data = np.array([1, 2, 3, 4, 5, 6])\n",
    "mtx = sparse.csr_matrix((data, (row, col)), shape=(3, 3))\n",
    "     "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtx.todense()   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "indptr[i],indptr[i+1] задает диапазон индексов в массивах indices и data, которые описывают в каких столбцах хранятся ненулевые значения в i-ой строке и чему они равны"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtx.data        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtx.indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mtx.indptr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для разреженных матриц реализованно множество функций\n",
    "\n",
    "https://docs.scipy.org/doc/scipy/reference/generated/scipy.sparse.csr_matrix.html#scipy.sparse.csr_matrix"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Raw Cell Format",
  "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}