numpy_tasks.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Что будет выведено на экран? a = np.arange(4).reshape(2,2) a += 0.5 print(a). Почему так?   \n",
    "0.5 1.5   \n",
    "2.5 3.5\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Cannot cast ufunc add output from dtype('float64') to dtype('int32') with casting rule 'same_kind'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-59-cdd46b700400>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0ma\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marange\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m \u001b[1;33m+=\u001b[0m \u001b[1;36m0.5\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mTypeError\u001b[0m: Cannot cast ufunc add output from dtype('float64') to dtype('int32') with casting rule 'same_kind'"
     ]
    }
   ],
   "source": [
    "a = np.arange(4).reshape(2,2)\n",
    "a += 0.5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a += b  equal to np.add(a, b, cast ='same_kind')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.5 1.5]\n",
      " [2.5 3.5]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(4).reshape(2,2) \n",
    "a = a + 0.5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.5 1.5]\n",
      " [2.5 3.5]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(4).reshape(2,2).astype('float')\n",
    "a += 0.5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "no False\n",
      "equiv False\n",
      "safe False\n",
      "same_kind False\n",
      "unsafe True\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(4).reshape(2,2)\n",
    "b = 0.5\n",
    "cast_types = ['no','equiv','safe', 'same_kind','unsafe']\n",
    "for cast in cast_types:\n",
    "    print(cast, np.can_cast(b, 'int32', casting=cast))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Создайте масив из четырех элементов: 0, 10, 20, 30 2. Создайте двухмерный массив 4x5, в котором первый столбец - массив с шага 1, а каждый элемент каждой строки, начиная со второго, больше предыдущего элемента этой же строки на 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array((0, 10, 20, 30))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = [a + i for i in range(5)] # from list\n",
    "np.array(res).T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [10, 11, 12, 13, 14],\n",
       "       [20, 21, 22, 23, 24],\n",
       "       [30, 31, 32, 33, 34]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a + np.arange(5).reshape(-1,1)).T # with broadcasting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Какой shape будет у результата операции np.arange(5).reshape(1,-1) + np.arange(5).reshape(-1,1)?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(0, 1, 2, 3, 4) + (0, 1, 2, 3, 4).T\n",
    "\n",
    "0 1 2 3 4   0 0 0 0 0    \n",
    "0 1 2 3 4   1 1 1 1 1\n",
    "0 1 2 3 4   2 2 2 2 2\n",
    "0 1 2 3 4   3 3 3 3 3\n",
    "0 1 2 3 4   4 4 4 4 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [1, 2, 3, 4, 5],\n",
       "       [2, 3, 4, 5, 6],\n",
       "       [3, 4, 5, 6, 7],\n",
       "       [4, 5, 6, 7, 8]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(5).reshape(1,-1) + np.arange(5).reshape(-1,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4. Создайте двумерный массив 8х8, заполненный 0 и 1 в шахматном порядке. done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.24 µs ± 13 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = np.zeros((8,8))\n",
    "a[::2, 1::2] = 1\n",
    "a[1::2, ::2] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 214,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 % 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15 µs ± 114 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "a = np.zeros((8,8))\n",
    "for i in range(8):\n",
    "    for j in range(8):\n",
    "        if (i + j) % 2:\n",
    "            a[i,j] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5. 1. Создайте одномерный массив целых чисел от 1 до 5 2. Вставьте 0 между каждой парой соседних элементов. done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 2. 0. 3. 0. 4. 0. 5.]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(1, 6)\n",
    "b = np.zeros(9)\n",
    "b[::2] = a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 0, 2, 0, 3, 0, 4, 0, 5])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.insert(a , [1, 2, 3, 4], 0) # without creating additional array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6. 1. Создайте двумерный массив 3x3, заполненный случайными числами от 0 до 9 2. Отсортируйте строки массива по возрастанию значения во втором столбце"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.62219562 5.11646737 2.84646967]\n",
      " [2.58353374 0.7632711  5.71742966]\n",
      " [4.46638099 4.46386482 4.08895696]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.uniform(0, 9, (3,3))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2.58353374 0.7632711  5.71742966]\n",
      " [4.46638099 4.46386482 4.08895696]\n",
      " [0.62219562 5.11646737 2.84646967]]\n"
     ]
    }
   ],
   "source": [
    "row_ind = np.argsort(a[:,1])\n",
    "print(a[[row_ind]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7. Поменяйте местами первую и вторую строки двумерного массива"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 6 8 0 4]\n",
      " [0 5 6 3 2]\n",
      " [3 2 5 2 5]\n",
      " [8 4 2 7 7]\n",
      " [0 9 0 8 4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(0, 10, (5,5))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 5 6 3 2]\n",
      " [0 6 8 0 4]\n",
      " [3 2 5 2 5]\n",
      " [8 4 2 7 7]\n",
      " [0 9 0 8 4]]\n"
     ]
    }
   ],
   "source": [
    "a[[1, 0]] = a[[0, 1]]\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8. 1. Создайте массив, заполненный случайными значениями 2. Замените максимальные значения массива средним"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8. 8. 5. 5. 3. 6. 6. 7. 6. 3.]\n",
      "5.7 8.0\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(1, 10, 10).astype('float')\n",
    "print(a)\n",
    "print(a.mean(), a.max())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5.7 5.7 5.  5.  3.  6.  6.  7.  6.  3. ]\n"
     ]
    }
   ],
   "source": [
    "mask = np.where(a==a.max())\n",
    "a[mask] = a.mean()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.  scale to [0,1]. done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9 6 3 6 4 4 3 9 3 5]\n"
     ]
    }
   ],
   "source": [
    "arr = np.random.randint(1, 10, 10)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = arr.min(), arr.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "k, c = 1 / (b - a), 1 - b / (b - a) # ugly and resulted in list instead of np.array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0, 0.5, 0.0, 0.5, 0.16666666666666663, 0.16666666666666663, 0.0, 1.0, 0.0, 0.33333333333333326]\n"
     ]
    }
   ],
   "source": [
    "new_arr = [k * i + c for i in arr]\n",
    "print(new_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.         0.5        0.         0.5        0.16666667 0.16666667\n",
      " 0.         1.         0.         0.33333333]\n"
     ]
    }
   ],
   "source": [
    "arr = (arr - arr.min()) / (arr.max() - arr.min()) # ok\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10. not finished"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[nan  2.  3.]\n",
      " [ 4. nan  6.]\n",
      " [ 7.  8. nan]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[np.nan, 2, 3], [4, np.nan, 6], [7, 8, np.nan]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "ind = np.argwhere(np.isnan(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11. done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [0 3 4]\n",
      " [0 5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array(([0, 1, 2], [0, 3, 4], [0, 5, 6]))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def zeros_col(a): # 1 approach\n",
    "    for col in a.T:\n",
    "        if sum(col) == 0:\n",
    "            return True\n",
    "    return False\n",
    "\n",
    "zeros_col(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 1]\n",
      " [0 0 1]\n",
      " [0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "a = np.random.randint(0, 2, (3,3))\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 207,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 207,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0 in np.sum(a, axis=0) # 2 approach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12. Путь даны два массива одинакового размера. Поэлементно разделите один массив на другой. В случае, если делитель равен нулю, соответствующему элементу результирующего массива присвойте нуль"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 3 1 3 1] [0 0 2 1 4]\n"
     ]
    }
   ],
   "source": [
    "size = 5\n",
    "a, b = np.random.randint(0 , 5 , (2,size))\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.   0.   0.5  3.   0.25]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Nikita\\Anaconda3\\lib\\site-packages\\ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    }
   ],
   "source": [
    "c = np.divide(a, b)\n",
    "c[np.isinf(c)] = 0\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13. Пусть заданы два массива x an i. Прибавьте единицу к тем элементам массива x, индексы которых указаны в массиве i. В случае, если некоторый индекс встретился в массиве i несколько раз, прибавьте к соответствующему элементу массива x число вхождений данного индекса в массиве i."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.ones(10)\n",
    "i = np.array([0, 1, 2, 3, 5, 5, 8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.83 µs ± 114 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "for ind in i:\n",
    "    x[ind] += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.83 µs ± 180 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.add.at(x, i, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5 µs ± 23.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "np.bincount(i, minlength=len(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 14. По двум входным одномерным массивам одинаковой длины составьте массив пар элементов с одинаковыми индексами. Решите задачу на примере массивов x and y. done"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(1, 5), (2, 6), (3, 7), (4, 8)]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3, 4])\n",
    "y = np.array([5, 6 ,7 ,8])\n",
    "def f(x, y):\n",
    "    return list(zip(x,y))\n",
    "print(f(x, y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 6])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([x,y]).T[1] # numpy approach"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15. Для заданного двумерного массива потсройте трехмерный массив, содержащий всевозможные неперекрывающиеся блоки размера 3х3, начиная с левого верхнего угла. Если высота / ширина исходного массива не кратна трем, исключите из рассмотрения последние строки/столбцы. Решите задачу на примере массива x "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5  6]\n",
      " [ 7  8  9 10 11 12 13]\n",
      " [14 15 16 17 18 19 20]\n",
      " [21 22 23 24 25 26 27]\n",
      " [28 29 30 31 32 33 34]\n",
      " [35 36 37 38 39 40 41]\n",
      " [42 43 44 45 46 47 48]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(49).reshape(7,7)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "sub_shape = (3,3)\n",
    "view_shape = tuple(np.subtract(a.shape, sub_shape) + 1) + sub_shape\n",
    "strides = a.strides + a.strides\n",
    "\n",
    "sub_matrices = np.lib.stride_tricks.as_strided(a,view_shape,strides)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5, 5, 3, 3)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.subtract()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(28, 4)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.strides"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x): # ugly\n",
    "    num_windx = x.shape[0] // 3\n",
    "    num_windy = x.shape[1] // 3\n",
    "    res = []\n",
    "    for i in range(num_windx):\n",
    "        for j in range(num_windy):\n",
    "            res.append(x[3*i:3*(i + 1), 3*j:3*(j + 1)])\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2]\n",
      " [ 7  8  9]\n",
      " [14 15 16]]\n",
      "[[ 3  4  5]\n",
      " [10 11 12]\n",
      " [17 18 19]]\n",
      "[[21 22 23]\n",
      " [28 29 30]\n",
      " [35 36 37]]\n",
      "[[24 25 26]\n",
      " [31 32 33]\n",
      " [38 39 40]]\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "res = f(x)\n",
    "print(res)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}