Sample Code/Day_02_SampleCode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img width=150 src=\"https://upload.wikimedia.org/wikipedia/commons/thumb/1/1a/NumPy_logo.svg/200px-NumPy_logo.svg.png\"></img>\n",
    "\n",
    "# Part.2-1-02 NumPy 陣列進階操作"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. NumPy 陣列重塑"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 `flatten()` 與 `ravel()`\n",
    "\n",
    "透過 `flatten()` 與 `ravel()` 均可將多維陣列轉形為一維陣列，`flatten()` 與 `ravel()` 的使用透過下列兩種方法，得到的結果都是完全一樣的。\n",
    "\n",
    "|np.函式|陣列物件.函式|\n",
    "|---|---|\n",
    "|np.flatten(a, order='C')|a.flatten(order='C')|\n",
    "|np.ravel(a, order='C')|a.ravel(order='C')|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[ 0,  1,  2,  3], \n",
    "              [ 4,  5,  6,  7],\n",
    "              [ 8,  9, 10, 11]])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.flatten()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "與 `flatten()` 不同的是，`ravel()` 建立的是原來陣列的 view，所以在 `ravel()` 回傳物件中做的元素值變更，將會影響原陣列的元素值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.ravel()\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果我們改變 b 陣列的元素值，原陣列 a 對應的元素值也會被改變。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "b[3] = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1,   2, 100,   4,   5,   6,   7,   8,   9,  10,  11])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2, 100],\n",
       "       [  4,   5,   6,   7],\n",
       "       [  8,   9,  10,  11]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`flatten()` 與 `ravel()` 引數 order 預設值為 C，常用的引數值有 C 和 F。C 的意義是 C-style，展開時是以 row 為主的順序展開；而 F 是 Fortran-style，展開時是以 column 為主的順序展開。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1,   2, 100,   4,   5,   6,   7,   8,   9,  10,  11])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ravel(order='C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   4,   8,   1,   5,   9,   2,   6,  10, 100,   7,  11])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.ravel(order='F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 `reshape()`\n",
    "\n",
    "`reshape()` 的使用，可以透過 `np.reshape(a, new_shape)` 或 `a.reshape(new_shape, refcheck=True)` 來執行。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape((3, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果新的總數與原先 shape 總數不一致的話，則會產生錯誤。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 15 into shape (3,6)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-14-8901e1d340c0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 15 into shape (3,6)"
     ]
    }
   ],
   "source": [
    "a.reshape((3, 6))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Reshape 時，新的形狀可以採用模糊指定為 -1，讓 NumPy 自動計算。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11],\n",
       "       [12, 13, 14]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape((5, -1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "若 reshape 後的陣列元素值改變，會影響原陣列對應的元素值也跟著改變。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1, 100,   3,   4],\n",
       "       [  5,   6,   7,   8,   9],\n",
       "       [ 10,  11,  12,  13,  14]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.reshape((3, 5))\n",
    "b[0, 2] = 100\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "a[2] 值被改變了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0,   1, 100,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,\n",
       "        13,  14])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 `resize()`\n",
    "\n",
    "`resize()` 的使用，也同樣可以透過 `np.resize(a, new_shape)` 或 `a.resize(new_shape, refcheck=True)` 來執行。\n",
    "\n",
    "要改變被 reference 的陣列時有可能會產生錯誤，這時候可以將 `refcheck` 引數設為 `False` (預設為 `True`)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(15)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果 resize 的大小超過總元素值，則會在後面的元素值的指定為 0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14,  0,  0,  0]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.resize((3, 6), refcheck=False)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果 resize 的大小小於總元素值，則會依照 C-style 的順序，取得 resize 後的陣列元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.resize(3, refcheck=False)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 軸 (axis) 與維度 (dimension)\n",
    "\n",
    "軸 (axis) 在 NumPy 多維陣列中是很重要觀念，但是在應用上容易混淆。軸的數目也就是 NumPy 陣列的維度 (dimension) 數，軸的順序編號從 0 開始，下面例子用圖示來解說。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 一維陣列的軸\n",
    "\n",
    "對一維陣列來說，只有一個軸，所以 axis 為 0。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以圖示來說明一維陣列的軸。\n",
    "\n",
    "![](1D_axis.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 二維陣列的軸\n",
    "\n",
    "二維陣列的 ndim 為 2，也就是會有 2 個軸。二維陣列的軸 0 就是沿著 row 的軸，而軸 1 是沿著 column 的軸。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(6).reshape(3, 2)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以圖示來說明二維陣列的軸。\n",
    "\n",
    "![](2D_axis.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 三維陣列的軸\n",
    "\n",
    "三維陣列有 3 個軸。可以理解軸的順序是\"由外而內\"、\"由row而column\"。\n",
    "\n",
    "以前一天範例程式中三維陣列的例子來看，可以理解為 2 個 4 $\\times$ 3 的二維陣列排在一起。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3],\n",
       "        [ 4,  5,  6],\n",
       "        [ 7,  8,  9],\n",
       "        [10, 11, 12]],\n",
       "\n",
       "       [[ 1,  2,  3],\n",
       "        [ 4,  5,  6],\n",
       "        [ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([[[1, 2, 3], [4, 5, 6],\n",
    "              [7, 8, 9], [10, 11, 12]],\n",
    "              [[1, 2, 3], [4, 5, 6],\n",
    "              [7, 8, 9], [10, 11, 12]]])\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "以圖示來說明三維陣列的軸。\n",
    "\n",
    "![](3D_axis.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "從 `shape` 屬性來看也可以協助理解在多維陣列中的軸。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 4, 3)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "若我們要沿軸對元素做加總，呼叫 `sum()` 函式並指定 axis。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  6],\n",
       "       [ 8, 10, 12],\n",
       "       [14, 16, 18],\n",
       "       [20, 22, 24]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sum(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 `np.newaxis` 增加軸數\n",
    "\n",
    "跟 `reshape()` 類似的應用，如果是要增加軸數的話，可以使用 `np.newaxis` 物件。將 `np.newaxis` 加到要增加的軸的位置即可。\n",
    "\n",
    "與 `reshape()` 不同的地方在於，`np.newaxis` 新增的維度為 1，而 `reshape()` 可以指定要改變的形狀 (不一定為 1)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(12).reshape(2, 6)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 1, 6)"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:,np.newaxis,:].shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. NumPy 陣列的合併與分割"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10).reshape(5, 2)\n",
    "b = np.arange(6).reshape(3, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.1 合併：`concatenate()`, `stack()`, `hstack()`, `vstack()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用 `concatenate()` 進行陣列的合併時，須留意除了指定的軸之外 (預設為 axis 0)，其他軸的形狀必須完全相同，合併才不會發生錯誤。\n",
    "\n",
    "```python\n",
    "numpy.concatenate((a1, a2, ...), axis=0, out=None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9],\n",
       "       [0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`stack()`, `hstack()`, `vstack()` 的觀念及用法類似，不同點在於 `stack()` 回傳的陣列維度會是合併前的維度 +1，而 `hstack()` 與 `vstack()` 回傳的陣列維度則是依合併的陣列而定。\n",
    "\n",
    "至於是否可以合併，`stack()` 必須要所有陣列的形狀都一樣；而 `hstack()` 與 `vstack()` 則跟上述的規則一樣，除了指定的軸之外，其他軸的形狀必須完全相同才可以合併。\n",
    "\n",
    "|函式|說明|\n",
    "|---|---|\n",
    "|numpy.stack(arrays, axis=0, out=None)|根據指定的軸進行合併|\n",
    "|numpy.hstack(tup)|根據水平軸進行合併|\n",
    "|numpy.vstack(tup)|根據垂直軸進行合併|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1],\n",
       "        [0, 1]],\n",
       "\n",
       "       [[2, 3],\n",
       "        [2, 3]],\n",
       "\n",
       "       [[4, 5],\n",
       "        [4, 5]],\n",
       "\n",
       "       [[6, 7],\n",
       "        [6, 7]],\n",
       "\n",
       "       [[8, 9],\n",
       "        [8, 9]]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# stack() 範例\n",
    "c = np.arange(10).reshape(5, 2)\n",
    "np.stack((a, c), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 1],\n",
       "       [2, 3, 2, 3],\n",
       "       [4, 5, 4, 5],\n",
       "       [6, 7, 6, 7],\n",
       "       [8, 9, 8, 9]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# hstack() 範例\n",
    "np.hstack((a, c))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9],\n",
       "       [0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vstack() 範例\n",
    "np.vstack((a, b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.2 分割：`split()`、`hsplit()`、`vsplit()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5],\n",
       "       [6, 7],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10).reshape(5, 2)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`split()` 的語法：\n",
    "\n",
    "```python\n",
    "numpy.split(array, indices_or_sections, axis=0)\n",
    "```\n",
    "\n",
    "indices_or_sections 如果給定單一整數的話，那就會按照軸把陣列等分；如果給定一個 List 的整數值的話，就會按照區段去分割，例如：\n",
    "`indices_or_sections=[2, 3]` 會照下列的方式做分割 (一樣是照按照軸把陣列分割)\n",
    "```\n",
    "ary[:2]\n",
    "ary[2:3]\n",
    "ary[3:]\n",
    "```\n",
    "\n",
    "與 `split` 很類似的是 `hsplit` 與 `vsplit`，分別是依照水平軸和垂直軸去做分割。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0, 1]]),\n",
       " array([[2, 3]]),\n",
       " array([[4, 5]]),\n",
       " array([[6, 7]]),\n",
       " array([[8, 9]])]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 依 axis 0 等分 split\n",
    "np.split(a, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[0, 1],\n",
       "        [2, 3]]), array([[4, 5]]), array([[6, 7],\n",
       "        [8, 9]])]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# split 為 (2,2), (1,2), (2,2) 三個陣列，並回傳含 3 個陣列的 List\n",
    "np.split(a, [2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17],\n",
       "       [18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(30).reshape(5, 6)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 0,  1],\n",
       "        [ 6,  7],\n",
       "        [12, 13],\n",
       "        [18, 19],\n",
       "        [24, 25]]), array([[ 2,  3],\n",
       "        [ 8,  9],\n",
       "        [14, 15],\n",
       "        [20, 21],\n",
       "        [26, 27]]), array([[ 4,  5],\n",
       "        [10, 11],\n",
       "        [16, 17],\n",
       "        [22, 23],\n",
       "        [28, 29]])]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 依水平軸去做等分分割\n",
    "np.hsplit(b, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 0,  1],\n",
       "        [ 6,  7],\n",
       "        [12, 13],\n",
       "        [18, 19],\n",
       "        [24, 25]]), array([[ 2],\n",
       "        [ 8],\n",
       "        [14],\n",
       "        [20],\n",
       "        [26]]), array([[ 3,  4],\n",
       "        [ 9, 10],\n",
       "        [15, 16],\n",
       "        [21, 22],\n",
       "        [27, 28]]), array([[ 5],\n",
       "        [11],\n",
       "        [17],\n",
       "        [23],\n",
       "        [29]])]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 依水平軸照區段去分割\n",
    "np.hsplit(b, [2, 3, 5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([[ 0,  1,  2,  3,  4,  5],\n",
       "        [ 6,  7,  8,  9, 10, 11]]), array([[12, 13, 14, 15, 16, 17],\n",
       "        [18, 19, 20, 21, 22, 23]]), array([[24, 25, 26, 27, 28, 29]]), array([], shape=(0, 6), dtype=int64)]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 依垂直軸按照區段去分割，超出的區段則傳回空陣列\n",
    "np.vsplit(b, [2, 4, 6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 迭代\n",
    "\n",
    "一維陣列的迭代，跟 Python 集合型別 (例如 List) 的迭代相同。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in a:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多維陣列的迭代則以 axis 0 為準。下面以二維陣列為例，列出各 row 的元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(6).reshape(2, 3)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2]\n",
      "[3 4 5]\n"
     ]
    }
   ],
   "source": [
    "for row in b:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果要列出多維陣列所有元素的話，可以配合 `flat` 屬性。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in b.flat:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 搜尋與排序"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.1 顯示最大值和最小值：`amax()`、`amin()`、`max()`、`min()`\n",
    "\n",
    "要顯示陣列元素最大值和最小值，可以透過 `amax()`、`amin()`、`max()`、`min()`，也可以依照軸列出各軸的最大/最小元素值。\n",
    "\n",
    "基本語法：\n",
    "\n",
    "|np.函式|陣列物件.函式|\n",
    "|---|---|\n",
    "|numpy.amax(array, axis=None, keepdims=<no value>)|ndarray.max(axis=None, keepdims=False)|\n",
    "|numpy.amin(array, axis=None, keepdims=<no value>)|ndarray.min(axis=None, keepdims=False)|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 12, 11,  9,  6, 14,  5, 10,  3, 15])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.randint(1, 20, 10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 陣列中最大的元素值\n",
    "np.amax(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 陣列中最小的元素值\n",
    "np.amin(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果是多維陣列的話，用法也是相同，也可以依照軸列出最大或最小值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[12, 12, 11,  9,  6],\n",
       "       [14,  5, 10,  3, 15]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = a.reshape(2, 5)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 若設定 keepdims=True，結果會保留原陣列的維度來顯示。\n",
    "np.amax(b, keepdims=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 15])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 列出各 row 最大值\n",
    "b.max(axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 15])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 同樣的 amax 也可以依軸列出各 row 最大值\n",
    "np.amax(b, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12,  5, 10,  3,  6])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 列出各 column 最小值\n",
    "b.min(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.2 顯示最大值和最小值的索引：`argmax()` 與 `argmin()`\n",
    "\n",
    "`argmax` / `argmin` 和上述不同的地方在於，`argmax` / `argmin` 回傳的是最大值和最小值的索引，也可以依照軸找出各軸最大值和最小值的索引。\n",
    "\n",
    "基本語法：\n",
    "\n",
    "|np.函式|陣列物件.函式|\n",
    "|---|---|\n",
    "|numpy.argmax(array, axis=None)|ndarray.argmax(axis=None)|\n",
    "|numpy.argmin(array, axis=None)|ndarray.argmin(axis=None)|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[13, 16,  1,  4],\n",
       "       [ 4,  8, 10, 19],\n",
       "       [ 5,  7, 13,  2]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(0)\n",
    "a = np.random.randint(1, 20, size=(3, 4))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "若沒有指定軸的話，`argmax()` 與 `argmin()` 會回傳多維陣列展平後的索引。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argmax(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 2, 1])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 列出各 column 的最大值索引, 分別為 [0, 0, 2, 1]\n",
    "np.argmax(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 元素值 1 為最小值，展平後的索引值為 2。\n",
    "a.argmin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.3 找出符合條件的元素：`where`\n",
    "\n",
    "語法：\n",
    "```python\n",
    "numpy.where(condition[, x, y])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[13, 16,  1,  4],\n",
       "       [ 4,  8, 10, 19],\n",
       "       [ 5,  7, 13,  2]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "傳入條件式，回傳值為符合條件的元素索引，不過這邊留意的是，以下面二維陣列為例，回傳的索引陣列要合併一起看，也就是說\n",
    "```\n",
    "(array([0, 0, 1, 2]), \n",
    " array([0, 1, 3, 2]))\n",
    "```\n",
    "\n",
    "a[0, 0] 值為 13<br />\n",
    "a[0, 1] 值為 16<br />\n",
    "a[1, 3] 值為 19<br />\n",
    "a[2, 2] 值為 13\n",
    "\n",
    "以上索引值對應的元素，其值都符合 \"大於 10\" 的條件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 0, 1, 2]), array([0, 1, 3, 2]))"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(a > 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "若是設定 x, y 引數的話，可將各元素取代掉。以下面的例子來解釋，如果元素值大於 10 的話就用 \"Y\" 來替代，反之則是 \"N\"。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['Y', 'Y', 'N', 'N'],\n",
       "       ['N', 'N', 'N', 'Y'],\n",
       "       ['N', 'N', 'Y', 'N']], dtype='<U1')"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(a > 10, \"Y\", \"N\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.4 `nonzero`\n",
    "\n",
    "`nonzero` 等同於 `np.where(array != 0)` 的語法，同樣的也是回傳符合非 0 條件的元素索引值。\n",
    "\n",
    "語法：\n",
    "\n",
    "|np.函式|陣列物件.函式|\n",
    "|---|---|\n",
    "|numpy.nonzero(array)|ndarray.nonzero()|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 3, 2, 3, 0, 2, 1, 3, 2])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(2)\n",
    "a = np.random.randint(0, 5, 10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([2, 3, 4, 6, 7, 8, 9]),)"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nonzero(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([2, 3, 4, 6, 7, 8, 9]),)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.nonzero()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.5 排序：`sort()` 與 `argsort()`\n",
    "\n",
    "要對陣列進行排序可以使用 `sort()` 與 `argsort()`，兩者的差異是在 `sort()` 回傳的是排序後的陣列，而 `argsort()` 回傳的是排序後的陣列索引值。\n",
    "\n",
    "語法：\n",
    "\n",
    "|np.函式|陣列物件.函式|\n",
    "|---|---|\n",
    "|numpy.sort(a, axis=-1, kind=None, order=None)|ndarray.sort()|\n",
    "|numpy.argsort(a, axis=-1, kind=None, order=None)|ndarray.argsort()|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10,  3,  8,  0, 19, 10, 11,  9, 10,  6])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(3)\n",
    "a = np.random.randint(0, 20, 10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  3,  6,  8,  9, 10, 10, 10, 11, 19])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 1, 9, 2, 7, 0, 5, 8, 6, 4])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.argsort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "與 `np.sort()` 不同的是，`陣列物件.sort()` 的語法會進行 in-place 排序，也就是原本的陣列內容會跟著改變。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  3,  6,  8,  9, 10, 10, 10, 11, 19])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.sort()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "多維陣列在排序時可以指定要依據的軸。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 12,  7, 14],\n",
       "       [17,  2,  2,  1],\n",
       "       [19,  5,  8, 14],\n",
       "       [ 1, 10,  7, 11],\n",
       "       [ 1, 15, 16,  5]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.random.randint(0, 20, size=(5, 4))\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  2,  1],\n",
       "       [ 1,  5,  7,  5],\n",
       "       [ 1, 10,  7, 11],\n",
       "       [17, 12,  8, 14],\n",
       "       [19, 15, 16, 14]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(b, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "排序支援多種不同的排序算法，包括 quicksort (預設)、heapsort、mergesort、timesort，在 `kind` 引數指定即可。依照官網文件指出排序速度是以 quicksort 最快，mergesort / timesort 其次，之後是 heapsort。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([      64,       96,      310, ..., 99999479, 99999561, 99999830])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.random.randint(0, 100000000, 1000000)\n",
    "np.sort(c, kind='heapsort')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "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.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}