N11 Numpy arrays.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# N11 Массивы модуля NumPy\n",
    "\n",
    "Автор: Шабанов Павел Александрович\n",
    "\n",
    "Email: pa.shabanov@gmail.com\n",
    "\n",
    "URL: [Заметки по программированию в науках о Земле](http://progeoru.blogspot.ru/)\n",
    "\n",
    "Дата последнего обновления: 08.03.2017\n",
    "\n",
    "### План\n",
    "\n",
    "1. Модуль Numpy\n",
    "    + обзор возможностей;\n",
    "    + массива numpy.ndarrays;\n",
    "    + изменения формы массива reshape;\n",
    "    + функции numpy для создания массивов;\n",
    "    \n",
    "2. Операции с массивами\n",
    "    + чтение данных из текстовых файлов;\n",
    "    + запись данных массивов в текстовые файлы.\n",
    "    \n",
    "### Цель: \n",
    "\n",
    "+ изучить массивы - особые типы данных в python из модуля numpy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Модуль numpy\n",
    "\n",
    "### Обзор возможностей\n",
    "\n",
    "[NumPy](http://www.scipy.org/scipylib/download.html) — это расширение языка Python, добавляющее поддержку больших многомерных массивов и матриц, вместе с [большой библиотекой высокоуровневых математических функций](http://pythonworld.ru/numpy) для операций с этими массивами.\n",
    "\n",
    "Краткий список возможностей numpy по категориям:\n",
    "\n",
    "+ Array creation routines\n",
    "+ Array manipulation routines\n",
    "+ Discrete Fourier Transform\n",
    "+ Indexing routines\n",
    "+ Input and output\n",
    "+ Linear algebra\n",
    "+ Masked array operations\n",
    "+ Mathematical functions\n",
    "+ Polynomials\n",
    "+ Random sampling (numpy.random)\n",
    "+ Sorting, searching, and counting\n",
    "+ Statistics\n",
    "\n",
    "Стандартным способом импортирования модуля numpy является:\n",
    "\n",
    "> **import numpy as np**\n",
    "\n",
    "Здесь использован импорт с сокращением вместо полного имени модуля numpy до короткого np. После этого доступ к функциям осуществляется через аббревиатуру."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Массивы типа numpy.ndarrays\n",
    "\n",
    "Центральным объектом, вокруг которого строится большинство функций библиотеки - это массивы.\n",
    "\n",
    "**Массивы - упорядоченные последовательности ОДНОТИПНЫХ данных.**\n",
    "\n",
    "Массивы, помимо типа хранящихся в них данных, характеризиуются:\n",
    "\n",
    "+ **формой (shape)**;\n",
    "\n",
    "+ **числом измерения (axis or dimensions, ndim)**. \n",
    "\n",
    "**Форма** - это кортеж, состоящий из целых чисел, где каждое значение определяет число элементов по выбранной оси или измерению в массиве. Форму массива можно узнать через **метод shape** или через функцию **np.shape(arr)**. \n",
    "\n",
    "**Число измерений** - это число осей, ранг, размерность массива. Длина кортежа и число осей должны совпадать.\n",
    "\n",
    "Форма может состоять из одного числа. Тогда число осей для такого массива будет равно единице. Такие массивы часто называются **одномерными массивами** или **векторами**.\n",
    "\n",
    "В случае, когда число осей **ndim**(метод массива) равно двум, тогда он называется двумерным или матрицей (для чисел). В случае более высоких порядков (3 и более) говорят о многомерных массивах. Т.о. число осей определяет N-мерность массива.\n",
    "\n",
    "![caption](files/pics/L11/anatomyarrayrus.png \"Рисунок 1 Шпаргалка по массивам в numpy\")\n",
    "\n",
    "### Изменения формы массива. Reshape\n",
    "\n",
    "Изменить форму массива позволяет метод массивов **reshape()** или функция reshape модуля **numpy(np.reshape())**. Правило именения формы: существующую ось можно разбить на несколько новых только нацело. То есть ось длиной 12 можно разбить на\n",
    "\n",
    "1. (1,12) - тривиальное преобразование\n",
    "2. (2,6)\n",
    "3. (3,4)\n",
    "4. (4,3)\n",
    "5. (6,2)\n",
    "6. (12,1) - аналогичное тривиальное преобразование"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A <type 'numpy.ndarray'> (30L,) [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24\n",
      " 25 26 27 28 29]\n",
      "B <type 'list'>\n",
      "Arr <type 'numpy.ndarray'> Shape (30L,) Ndim 1\n"
     ]
    }
   ],
   "source": [
    "# Numpy\n",
    "\n",
    "import random\n",
    "import numpy as np\n",
    "\n",
    "shape1 = 30\n",
    "a = np.arange(shape1)   # аналог стандартному range\n",
    "print 'A', type(a), np.shape(a),\n",
    "print a\n",
    "\n",
    "b = range(shape1)\n",
    "random.shuffle(b)\n",
    "print 'B', type(b)\n",
    "arr = np.array(b)   # прямое преобразование типа к массиву\n",
    "print 'Arr', type(arr), 'Shape', arr.shape, 'Ndim', arr.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B <type 'numpy.ndarray'> (3L, 10L) [[ 0  1  2  3  4  5  6  7  8  9]\n",
      " [10 11 12 13 14 15 16 17 18 19]\n",
      " [20 21 22 23 24 25 26 27 28 29]]\n",
      "C <type 'numpy.ndarray'> (10L, 3L) [[ 0  1  2]\n",
      " [ 3  4  5]\n",
      " [ 6  7  8]\n",
      " [ 9 10 11]\n",
      " [12 13 14]\n",
      " [15 16 17]\n",
      " [18 19 20]\n",
      " [21 22 23]\n",
      " [24 25 26]\n",
      " [27 28 29]]\n",
      "Array A -> axis 0: 30\n",
      "Array B -> axis 0: 3\n",
      "Array B -> axis 1: 10\n"
     ]
    }
   ],
   "source": [
    "# Изменение формы\n",
    "\n",
    "shape1 = 30\n",
    "a = np.arange(shape1)\n",
    "\n",
    "shape2 = (3, 10)\n",
    "b = a.reshape(shape2)   # reshape - метод массива \n",
    "print 'B', type(b), np.shape(b), b\n",
    "\n",
    "c = np.reshape(a, shape2[::-1])   # reshape - функция модуля numpy\n",
    "print 'C', type(c), np.shape(c), c\n",
    "# Анализ формы - рассмотрим оси или измерения\n",
    "\n",
    "# Одномерный массив или вектор A\n",
    "for i, v in enumerate(a.shape):\n",
    "    print 'Array A -> axis %d: %d' % (i, v)\n",
    "    \n",
    "# Двумерный массив или матрица B\n",
    "for i, v in enumerate(b.shape):\n",
    "    print 'Array B -> axis %d: %d' % (i, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Очевидно, что (2, 6) и (6, 2) - это разные формы. \n",
    "\n",
    "Т.о. каждую ось можно разбить на несколько других. При этом следует помнить, что преобразуя одномерный ряд в двумерный массив (или вектор в матрицу), указывайте число \"столбцов\" вторым элементом, а количество \"строк\" - первым.\n",
    "\n",
    "Для \"выпрямления\" N-мерного массива в вектор есть метод **flatten()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A (4L, 3L, 2L)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "(4L, 3L, 2L) - (3L, 2L) - (2L,)\n",
      "A [[[ 0  1]\n",
      "  [ 2  3]\n",
      "  [ 4  5]]\n",
      "\n",
      " [[ 6  7]\n",
      "  [ 8  9]\n",
      "  [10 11]]\n",
      "\n",
      " [[12 13]\n",
      "  [14 15]\n",
      "  [16 17]]\n",
      "\n",
      " [[18 19]\n",
      "  [20 21]\n",
      "  [22 23]]]\n",
      "B [[ 0  1  2  3  4  5  6  7  8  9 10 11]\n",
      " [12 13 14 15 16 17 18 19 20 21 22 23]]\n",
      "C [ 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": [
    "# Более сложные примеры reshape\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "N = 24\n",
    "shape1 = (4, 3, 2)   # кортеж\n",
    "a = np.arange(N).reshape(shape1)   # сразу меняем форму массиву длины N\n",
    "\n",
    "print 'A', a.shape\n",
    "\n",
    "for i in a:\n",
    "    for j in i:\n",
    "        print '%s - %s - %s' % (a.shape, i.shape, j.shape,)\n",
    "\n",
    "print 'A', a\n",
    "        \n",
    "shape2 = (2, 12)\n",
    "b = a.reshape(shape2)\n",
    "print 'B', b\n",
    "\n",
    "# \"Выравнивание\" N-мерного массива в одномерный\n",
    "c = a.flatten()\n",
    "print 'C', c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Функции numpy для создания массивов\n",
    "\n",
    "В **numpy** есть функции, похожие на функции стандартной библиотеки, для создания массивов заданного наполнения и формы.\n",
    "\n",
    "+ **numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)** - позволяет получить массив, состоящий из равномерно распределённых в заданом интервале значений. Опционально верхняя граница интервала может быть исключена из рассмотрения (параметр endpoint=False);\n",
    "\n",
    "+ **numpy.arange([start,] stop[, step,], dtype = None)** - функция, похожая на range(). Позволяет получать последовательность как целых, так и действительных чисел, используя конструктор \"начальное значение, конечное значение, шаг\" ;\n",
    "\n",
    "+ **numpy.random.random(shape)** - возвращает массив заданной формы, состоящий из псевдослучайных чисел в интервале [0, 1) не включая единицу;\n",
    "\n",
    "+ **numpy.zeros(shape)** - возвращает массив заданной формы, состоящий из нулей (0);\n",
    "\n",
    "+ **numpy.ones(shape)** - возвращает массив заданной формы, состоящий из единиц (1)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "linspace()\n",
      "X1:  [ 0.          0.20408163  0.40816327  0.6122449   0.81632653]\n",
      "X2:  [ 1.   1.2  1.4  1.6  1.8  2.   2.2  2.4  2.6  2.8]\n",
      "arange()\n",
      "X1:  [ 0.  1.  2.  3.  4.]\n",
      "X2:  [  3.    5.7   8.4  11.1  13.8  16.5  19.2  21.9  24.6  27.3]\n",
      "random.random()\n",
      "X1:  [ 0.74562835  0.43104436  0.15795813  0.29372803  0.36142541]\n",
      "X2:  [ 0.84017811  0.41170563  0.47829593  0.82228425  0.50665441]\n",
      "zeros()\n",
      "X1:  [0 0 0 0 0]\n",
      "X2:  [ 0.  0.  0.  0.  0.]\n",
      "ones()\n",
      "X1:  [ 1.  1.  1.  1.  1.]\n",
      "X2:  [1 1 1 1 1]\n"
     ]
    }
   ],
   "source": [
    "# Некоторые функции numpy для создания массивов\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "# linspace()\n",
    "print 'linspace()'\n",
    "x1 = np.linspace(0, 10, 50)\n",
    "x2 = np.linspace(0, 10, 50, endpoint=False)\n",
    "\n",
    "print 'X1: ', x1[0:5]\n",
    "print 'X2: ', x2[5:15]\n",
    "\n",
    "# arange()\n",
    "print 'arange()'\n",
    "x1 = np.arange(50, dtype='float')\n",
    "x2 = np.arange(-10.5, 30.75, 2.7)\n",
    "\n",
    "print 'X1: ', x1[0:5]\n",
    "print 'X2: ', x2[5:15]\n",
    "\n",
    "# random.random()\n",
    "print 'random.random()'\n",
    "x1 = np.random.random(50)\n",
    "x2 = np.random.random((10, 24))  # можно сразу задать форму массива\n",
    "\n",
    "print 'X1: ', x1[0:5]\n",
    "print 'X2: ', x2[5:15, 5]\n",
    "\n",
    "# zeros()\n",
    "print 'zeros()'\n",
    "x1 = np.zeros(50, dtype=int)\n",
    "x2 = np.zeros((10, 24))   # можно сразу задать форму массива\n",
    "\n",
    "print 'X1: ', x1[0:5]\n",
    "print 'X2: ', x2[5:15, 5]\n",
    "\n",
    "# ones()\n",
    "print 'ones()'\n",
    "x1 = np.ones(50)\n",
    "x2 = np.ones((10, 24), dtype=int)\n",
    "\n",
    "print 'X1: ', x1[0:5]\n",
    "print 'X2: ', x2[5:15, 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Всопомогательные функции и методы для работы с массивами\n",
    "\n",
    "В модуле numpy есть огромное количество функций, которые облегчают работу с массивами и элементами внутри них. Вот некоторые из них\n",
    "\n",
    "+ **np.size(arr)** - число элементов в массиве;\n",
    "\n",
    "+ **np.where(условие Y)** - возвращает кортеж индексов массива, для элементов которых удовлетворяется условие Y;\n",
    "\n",
    "+ **np.max()/np.min()/np.mean()/np.std()/np.var()** - простые статистики;\n",
    "\n",
    "+ **np.argmin()/np.argmax()** - возвращают индексы экстремумов массива;\n",
    "\n",
    "+ **np.sort()** - сортируют массив;\n",
    "\n",
    "+ **np.argsort()** - возвращает первоначальные индексы отсортированных элементов;\n",
    "\n",
    "+ **np.gradient()** - возвращает массив градиента; \n",
    "\n",
    "+ **np.in1d(arr1, arr2)** - сравнивает два массива и возвращает логический массив размера arr1, где True, если есть совпадение, и False - если элементы отличаются.\n",
    "\n",
    "И многие другие. Их очень много. Например, np.abs(). Более подробно о массивах из модуля numpy можно [узнать из документации](https://docs.scipy.org/doc/numpy/reference/arrays.ndarray.html)\n",
    "\n",
    "**N.B.** Для составления логических цепочек в **np.where()** необходимо использовать символ **&** вместо **and** и символ **|** вместо **or**. Например, так:\n",
    "\n",
    "> **(x > 10) & (x < 20)** вместо **(x > 10) and (x < 20)**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Операции с массивами\n",
    "\n",
    "В отличие от списков, массивы по-другому ведут себя даже в самых базовых операциях (сложение, умножение).\n",
    "\n",
    "Так умножение массива на число приведёт к тому, что каждый элемент массива будет умножен на это число. При этом исходный массив не изменяется.\n",
    "\n",
    "Также от массива можно брать не только **срезы**, но и **векторные срезы**, т.е. непоследовательные наборы индексов по соответствующим осям. Такие наборы должны быть оформлены как списки или кортежи."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X: [0 1 2 3 4]\n",
      "Y: [-13.6  -9.1  -4.6  -0.1   4.4]\n",
      "ii: [0, 2, 4, 6, 8]\n",
      "Y[ii] [-13.6  -4.6   4.4  13.4  22.4]\n",
      "Z[ii] От списка Z[ii] вектор-индекс взять нельзя!\n",
      "O.K.\n",
      "2 (2L, 5L)\n",
      "XY [[ 0.56399992  0.17188439  0.98868401  0.84760799  0.08672245]\n",
      " [ 0.45640941  0.18429038  0.9232576   0.34424838  0.58967906]]\n"
     ]
    }
   ],
   "source": [
    "# Операции и срезы в массивах\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "n = 15\n",
    "x = np.arange(n)\n",
    "\n",
    "y = 4.5*x - 13.6   # тоже массив\n",
    "z = range(n)   # список\n",
    "\n",
    "print 'X:', x[0:5]\n",
    "print 'Y:', y[0:5]\n",
    "\n",
    "ii = range(0, 10, 2)\n",
    "print 'ii:', ii\n",
    "print 'Y[ii]', y[ii]\n",
    "\n",
    "# ***** ЭТО обработчик исключений *****\n",
    "try:\n",
    "    print 'Z[ii]', z[ii]\n",
    "except:\n",
    "    print u'От списка Z[ii] вектор-индекс взять нельзя!'\n",
    "finally:\n",
    "    print 'O.K.'\n",
    "# ***** КОНЕЦ обработчика исключений *****\n",
    "\n",
    "# Срез и вектор-индекс от двумерного массива\n",
    "shape = (5, 13)\n",
    "xy = np.random.random(shape)\n",
    "print xy[2:4, ii].ndim, xy[2:4, ii].shape\n",
    "print 'XY', xy[2:4, ii]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<type 'numpy.ndarray'> 10\n",
      "-2.5 5 2.5\n",
      "-2.5 6 3.5\n",
      "-2.5 7 4.5\n",
      "-2.5 8 5.5\n",
      "-2.5 9 6.5\n",
      "-2.5 10 7.5\n",
      "-2.5 11 8.5\n",
      "-2.5 12 9.5\n",
      "-2.5 13 10.5\n",
      "-2.5 14 11.5\n"
     ]
    }
   ],
   "source": [
    "# Список и массив\n",
    "\n",
    "N = 10\n",
    "arr = np.zeros(N) - 2.5\n",
    "lst = range(5, N+5)\n",
    "\n",
    "plus = arr + lst\n",
    "print type(plus), len(plus)\n",
    "\n",
    "for i,j,k in zip(arr, lst, plus):\n",
    "    print i,j,k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Чтение числовых данных с помощью Numpy\n",
    "\n",
    "Для чтения данных текстовых файлов в модуле numpy есть функция **numpy.genfromtxt()**. Также есть похожая функция np.loadtxt()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a type <type 'numpy.ndarray'> (793L, 3L) 2\n",
      "[[  1.95000000e+03   1.00000000e+00   9.20000000e-01]\n",
      " [  1.95000000e+03   2.00000000e+00   4.00000000e-01]\n",
      " [  1.95000000e+03   3.00000000e+00  -3.60000000e-01]\n",
      " [  1.95000000e+03   4.00000000e+00   7.30000000e-01]\n",
      " [  1.95000000e+03   5.00000000e+00  -5.90000000e-01]\n",
      " [  1.95000000e+03   6.00000000e+00  -6.00000000e-02]\n",
      " [  1.95000000e+03   7.00000000e+00  -1.26000000e+00]\n",
      " [  1.95000000e+03   8.00000000e+00  -5.00000000e-02]\n",
      " [  1.95000000e+03   9.00000000e+00   2.50000000e-01]\n",
      " [  1.95000000e+03   1.00000000e+01   8.50000000e-01]]\n"
     ]
    }
   ],
   "source": [
    "# Способы работы с числовыми данными с помощью numpy.genfromtxt(),\n",
    "# записанными в текстовые файлы\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "dataPath = './dataset/nao'\n",
    "fileName = 'nao.txt'\n",
    "a = np.genfromtxt('{}/{}'.format(dataPath, fileName))\n",
    "print \"a type\", type(a), a.shape, a.ndim\n",
    "print a[:10,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "NAO type: <type 'numpy.ndarray'> (793L,)\n",
      "Max: 3.04 Min: -3.18\n",
      "Mean: -0.018 Std: 1.0114\n"
     ]
    }
   ],
   "source": [
    "# Расширенные возможности чтения данных\n",
    "\n",
    "dataPath = './dataset/nao'\n",
    "fileName = 'nao.txt'\n",
    "fullPath = '{}/{}'.format(dataPath, fileName)\n",
    "\n",
    "year, mon, nao = np.genfromtxt(fullPath, usecols=[0, 1, 2], unpack=True)\n",
    "print \"NAO type:\", type(nao), nao.shape\n",
    "print 'Max: %.2f Min: %.2f' % (nao.max(), nao.min())\n",
    "print 'Mean: %.3f Std: %.4f' % (nao.mean(), nao.std())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Запись числовых данных с помощью Numpy в текстовые формат\n",
    "\n",
    "Для записи данных массива в текстовый файл есть функция **numpy.savetxt()**.\n",
    "\n",
    "**N.B.** При записи числовых данных рекомендуется использовать разделитель. Например, точка с запятой (;). Разделитель задаётся по умолчанию пробелом в параметрах delimiter или sep (в разных функциях по-разному).  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Запись 2D-массива (> 2D требуются другие способы)\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "dataPath = './dataset/nao'\n",
    "fileName3 = 'test_2D_array.txt'\n",
    "fullPath = '{}/{}'.format(dataPath, fileName3)\n",
    "\n",
    "arr = np.random.random((10,10))*10.\n",
    "\n",
    "np.savetxt(fullPath, arr, fmt='%.2f', delimiter=';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n",
      "(10L, 7L)\n"
     ]
    }
   ],
   "source": [
    "# Способ работы с числовыми данными: запись \"ala\" фортран\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "dataPath = './dataset/nao'\n",
    "fileName2 = 'fortran_style.txt'\n",
    "fullPath = '{}/{}'.format(dataPath, fileName2)\n",
    "\n",
    "x = np.random.random((12, 10, 7))\n",
    "\n",
    "ss = []\n",
    "for i in range(12):\n",
    "    ss.append('%5d%5d\\n' % (2015, i+1))\n",
    "\n",
    "#print x\n",
    "\n",
    "with file(fullPath, 'w') as outfile: \n",
    "    for i, data_slice in enumerate(x): \n",
    "        print data_slice.shape\n",
    "        outfile.write(ss[i])\n",
    "        np.savetxt(outfile, data_slice, fmt='%9.3f')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python [default]",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}