Sample Code/Day_05_SampleCode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vd-aKpWkFHG5"
   },
   "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-05 NumPy 統計函式 Universal Functions (ufunc)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VicirlzcFJky"
   },
   "source": [
    "範例目標:<br>\n",
    "實做\n",
    "1. 順序統計量 (Order Statistics)\n",
    "2. 平均數與變異數\n",
    "3. 相關性\n",
    "4. 直方圖 (Histogram)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "61cRFpHxFQwf"
   },
   "source": [
    "範例重點:<br>\n",
    "1. 統計函式也須注意針對計算的軸 (axis) 與維度 (dimension) \n",
    "2. 直方圖 (Histogram) 需要配合套件 matplotlib.pyplot 使用"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vd0BSC1nFHG_"
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qYR2Rw4GFHHA"
   },
   "source": [
    "## 1. 順序統計量 (Order Statistics)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9cLdZpmAFHHA"
   },
   "source": [
    "### 1.1 最大值和最小值\n",
    "\n",
    "在先前的單元中曾介紹過找出陣列中的最大值 (`ndarray.max()`, `np.amax()`) 和最小值 (`ndarray.min()`, `np.amin()`)，針對單一陣列中取得最大值或最小值。\n",
    "\n",
    "在 NumPy 順序統計量的相關函式中，最大值與最小值相關的函式還有：\n",
    "- `numpy.maximum()`, `numpy.minimum()`\n",
    "- `numpy.fmax()`, `numpy.fmin()`\n",
    "- `numpy.nanmax()`, `numpy.nanmin()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8l05HAmRFHHB"
   },
   "outputs": [],
   "source": [
    "np.random.seed(1)\n",
    "a = np.random.randint(1, 10, 6).reshape(2, 3)\n",
    "b = np.random.randint(1, 5, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "qwUZBQXaFHHB",
    "outputId": "dc7c3a48-8001-43a2-ef07-a8440775ed2a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 9, 6],\n",
       "       [1, 1, 2]])"
      ]
     },
     "execution_count": 3,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SjrEgslSFHHC",
    "outputId": "7e57a946-455c-4b64-8fdc-df114a5c035d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 2])"
      ]
     },
     "execution_count": 4,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "P3WmcumxFHHC"
   },
   "source": [
    "#### 1.1.1 `numpy.maximum()`, `numpy.minimum()`\n",
    "\n",
    "以 element-wise 比較 2 個陣列並回傳各元素的最大值或最小值。如果比較的元素中的 nan 的話，則會回傳 nan。\n",
    "\n",
    "`maximum()` 與 `minimum()` 在進行比較時，若有需要會利用到廣播 (bradcasting)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "moAZP1SNFHHD",
    "outputId": "6fb88f2a-dbc2-442d-eb5b-3e391ea9f929"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 9, 6],\n",
       "       [1, 4, 2]])"
      ]
     },
     "execution_count": 5,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "t9GZd9IwFHHD",
    "outputId": "276b5aa6-69d2-4f5f-f36f-22f347249afa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 2],\n",
       "       [1, 1, 2]])"
      ]
     },
     "execution_count": 6,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.minimum(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lAyn3Ms1FHHD",
    "outputId": "9d60785b-efc7-4550-b1da-ce36863089a3"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[nan,  9., nan],\n",
       "       [nan,  1., nan]])"
      ]
     },
     "execution_count": 7,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.maximum(a, [np.nan, 0, np.nan])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3lckNNCpFHHE"
   },
   "source": [
    "#### 1.1.2 `numpy.fmax()`, `numpy.fmin()`\n",
    "\n",
    "以 element-wise 比較 2 個陣列並回傳各元素的最大值或最小值。與 `maximum()` / `minimum()` 不同的是，如果比較的元素中只有一個是 nan 的話，回傳非 nan 的值，如果兩個元素都是 nan 則回傳 nan。\n",
    "\n",
    "同樣在進行比較時，若有需要會利用到廣播 (bradcasting)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ERa9-rQEFHHE",
    "outputId": "41cb640b-76fd-4974-f38c-185a856d049d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 9, 6],\n",
       "       [1, 4, 2]])"
      ]
     },
     "execution_count": 8,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fmax(a, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "7MrxgkqwFHHE",
    "outputId": "c794eaff-d526-477f-970e-858dfbd66167"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([nan,  3., nan])"
      ]
     },
     "execution_count": 9,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fmin([np.nan, 3, np.nan], [np.nan, np.nan, np.nan])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "0S7Zap3EFHHF"
   },
   "source": [
    "#### 1.1.3 `numpy.nanmax()`, `numpy.nanmin()`\n",
    "\n",
    "回傳陣列中有非 nan 元素值的最大值或最小值。\n",
    "\n",
    "可以指定要比較的軸，以及回傳值是否要保留維度。常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.nanmax(a, axis=None, keepdims=<no value>)\n",
    "numpy.nanmin(a, axis=None, keepdims=<no value>)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "tyYRsydNFHHF",
    "outputId": "1a705f30-257d-49d8-cf8d-473913da598f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 10,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nanmax([1, 2, np.nan, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ztAlgLY9FHHF"
   },
   "source": [
    "如果元素中都是 nan 值則會產生 RuntimeWarning。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5Y24THsMFHHG",
    "outputId": "4e5795e6-5e4b-4111-ce34-b29f47467219"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: All-NaN axis encountered\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 11,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nanmax([np.nan, np.nan])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5lXo4g9sFHHG"
   },
   "source": [
    "### 1.2 百分位數：`percentile()`, `nanpercentile()`\n",
    "\n",
    "計算百分位數，`percentile()` 與 `nanpercentile()` 不同的地方在於後者會忽略 nan。\n",
    "\n",
    "欲取得的百分位數引數，可以傳入純量或是陣列的值 (介於0 - 100 之間)，也可以指定要比較的軸，以及回傳值是否要保留維度。常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.percentile(a, q, axis=None, keepdims=<no value>)\n",
    "numpy.nanpercentile(a, q, axis=None, keepdims=<no value>)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "urmnF7sNFHHG",
    "outputId": "100dabb9-c34a-424c-e293-3fe5ba658a47"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10., 11., 12., 13.,\n",
       "       14., 15., 16., 17., 18., 19.], dtype=float32)"
      ]
     },
     "execution_count": 12,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = np.arange(1, 20).astype('float32')\n",
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3hieE4K2FHHH",
    "outputId": "d1836e78-9fda-445d-af44-a845b1c3d731"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.4, 11.8])"
      ]
     },
     "execution_count": 13,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.percentile(p, [30, 60])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "EUIDA3emFHHH"
   },
   "outputs": [],
   "source": [
    "p[5] = np.nan\n",
    "p[9] = np.nan\n",
    "p[15] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HYytIefFFHHI",
    "outputId": "ce4313f8-a8c8-4c7d-f3c6-bec7702d36de"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.,  5., nan,  7.,  8.,  9., nan, 11., 12., 13.,\n",
       "       14., 15., nan, 17., 18., 19.], dtype=float32)"
      ]
     },
     "execution_count": 15,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "b7HXZHkNFHHI",
    "outputId": "3bdc10c8-4328-41d3-a331-4283735a058d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 16,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nanpercentile(p, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "qG6ZphPWFHHJ"
   },
   "source": [
    "如果元素中包含 nan 的話，則 `percentile()` 會回傳 nan。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JS6HIkR5FHHJ",
    "outputId": "87b3efa0-86da-40d6-b438-1d473d5763ac"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 17,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.percentile(p, 50)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "IrmSehItFHHJ"
   },
   "source": [
    "### 1.3 分位數：`quantile()`, `nanquantile()`\n",
    "\n",
    "計算分位數，`quantile()` 與 `nanquantile()` 不同的地方在於後者會忽略 nan。如果元素中包含 nan 的話，則 `quantile()` 會回傳 nan。\n",
    "\n",
    "欲取得的分位數引數，可以傳入純量或是陣列的值 (介於0 - 1 之間)，也可以指定要比較的軸，以及回傳值是否要保留維度。常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.quantile(a, q, axis=None, keepdims=<no value>)\n",
    "numpy.nanquantile(a, q, axis=None, keepdims=<no value>)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VNMjm9TKFHHK",
    "outputId": "e6080828-7ffc-4cbb-b559-feffb244c07a"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([23,  2,  1, 18,  9, 25, 14, 48, 43,  9, 31,  8,  4,  7, 22,  4,  5,\n",
       "       25, 44, 13])"
      ]
     },
     "execution_count": 18,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = np.array([23,  2,  1, 18,  9, 25, 14, 48, 43,  9, 31,  8,  4,  7, 22,  4,  5, 25, 44, 13])\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8c7Rfuw_FHHK",
    "outputId": "c6807f6b-e776-4322-e670-35a4aca71d49"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.5"
      ]
     },
     "execution_count": 19,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.quantile(q, 0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "SyiW8xCsFHHK",
    "outputId": "a17cf8b7-491c-4955-c2a7-3180c4f7eb5f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[23.,  2.,  1., nan],\n",
       "       [ 9., 25., nan, 48.],\n",
       "       [43.,  9., 31., nan],\n",
       "       [ 4.,  7., nan,  4.],\n",
       "       [ 5., 25., 44., 13.]])"
      ]
     },
     "execution_count": 20,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "q = np.array([23,  2,  1, np.nan,  9, 25, np.nan, 48, 43,  9, 31,  np.nan,  4,  7, np.nan,  4,  5, 25, 44, 13]).reshape(5, 4)\n",
    "q"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Ln3EQ4YQFHHL"
   },
   "source": [
    "下例是沿 axis 0 計算分位數，並且保留二維的維度。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "aIAW62qpFHHL",
    "outputId": "a4586060-86e9-4e53-c8d6-790da18b60e2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5. ,  7. , 16. ,  8.5]])"
      ]
     },
     "execution_count": 21,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nanquantile(q, 0.25, axis=0, keepdims=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Oes_tDxGFHHM"
   },
   "source": [
    "## 2. 平均數與變異數"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PKaAHnYuFHHM"
   },
   "source": [
    "### 2.1 平均值：`mean()`, `nanmean()`\n",
    "\n",
    "`mean()` 和 `nanmean()` 不同的地方在於後者會忽略 nan。如果元素中包含 nan 的話，則 `mean()` 會回傳 nan。下面的例子使用 `np.isnan()` 判斷陣列中是否包含 nan，如果無 nan 的話就呼叫 `mean()` 計算平均值，反之則呼叫 `nanmean()` 進行計算。\n",
    "\n",
    "可以指定要計算平均數的軸，以及回傳值是否要保留維度。`dtype` 引數是計算使用的型別，若輸入陣列是整數的話，則會用 `float64` 型別計算，若輸入的是浮點數的話，則是依輸入陣列的型別做為 `dtype`。\n",
    "\n",
    "常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.mean(a, axis=None, dtype=None, keepdims=<no value>)\n",
    "numpy.nanmean(a, axis=None, dtype=None, keepdims=<no value>)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "AZ2SAgsFFHHM"
   },
   "outputs": [],
   "source": [
    "a = np.array([23,  2,  1, np.nan,  9, 25, np.nan, \n",
    "              48, 43,  9, 31,  np.nan]).reshape(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "8NQpMWu4FHHM",
    "outputId": "14ad135e-a8a2-4751-c791-4cf91bfa6d37"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 54,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Xg_P2E2BFHHN",
    "outputId": "e368199a-aa19-4702-fe38-8f86e2d92651"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "陣列中有 nan，忽略 nan 後的平均值為： 21.22222222222222\n"
     ]
    }
   ],
   "source": [
    "if not np.isnan(np.sum(a)):\n",
    "    print(\"陣列中無 nan，忽略 nan 後的平均值為：\", np.mean(a))\n",
    "else:\n",
    "    print(\"陣列中有 nan，忽略 nan 後的平均值為：\", np.nanmean(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wg9d8-iKFHHN"
   },
   "source": [
    "### 2.2 平均值：`average()`\n",
    "\n",
    "使用 `average()` 計算平均值的話，可以輸入權重值做為引數。\n",
    "\n",
    "常用語法：\n",
    "```python\n",
    "numpy.average(a, axis=None, weights=None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "E6QeGmPAFHHQ",
    "outputId": "9978587a-d7ee-4858-c49f-cb36ad0487a2"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 24,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(6).reshape((3,2))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "xI4HlbxbFHHQ"
   },
   "source": [
    "權重平均值的計算公式為：\n",
    "\n",
    "> avg = sum(a * weights) / sum(weights)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9qYjq5mSFHHQ",
    "outputId": "d654bf22-ef6d-47d2-da44-003e052712fc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.75, 2.75, 4.75])"
      ]
     },
     "execution_count": 25,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.average(a, axis=1, weights=[0.25, 0.75])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vYudGvPSFHHQ"
   },
   "source": [
    "須注意權重的總和不能為 0，否則會產生錯誤。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "oDm-uKhuFHHQ",
    "outputId": "d7ccbf98-782c-4add-97b2-dd44ea3dedd4"
   },
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "Weights sum to zero, can't be normalized",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-26-f756f92594e8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maverage\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mweights\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\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;32m<__array_function__ internals>\u001b[0m in \u001b[0;36maverage\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;32m/usr/local/lib/python3.7/site-packages/numpy/lib/function_base.py\u001b[0m in \u001b[0;36maverage\u001b[0;34m(a, axis, weights, returned)\u001b[0m\n\u001b[1;32m    408\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0many\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscl\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0.0\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[1;32m    409\u001b[0m             raise ZeroDivisionError(\n\u001b[0;32m--> 410\u001b[0;31m                 \"Weights sum to zero, can't be normalized\")\n\u001b[0m\u001b[1;32m    411\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    412\u001b[0m         \u001b[0mavg\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmultiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mwgt\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdtype\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mresult_dtype\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mscl\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: Weights sum to zero, can't be normalized"
     ]
    }
   ],
   "source": [
    "np.average(a, axis=1, weights=[0, 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "trQRF20PFHHR"
   },
   "source": [
    "### 2.3 計算中位數：`median()`, `nanmedian()`\n",
    "\n",
    "`median()` 和 `nanmedian()` 不同的地方在於後者會忽略 nan。如果元素中包含 nan 的話，則 `median()` 會回傳 nan。\n",
    "\n",
    "可以指定要計算中位數的軸，以及回傳值是否要保留維度。要留意的是，如果軸或是陣列總數不是單數的話，中位數的值會是中間 2 個元素值相加除以 2。\n",
    "\n",
    "常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.median(a, axis=None, keepdims=False)\n",
    "numpy.nanmedian(a, axis=None, keepdims=False)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XUqkffpkFHHR",
    "outputId": "c8f46c46-b8bd-4ff5-88cc-ea931a93ca77"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[36, 15, 48, 39, 17],\n",
       "       [10,  9, 37, 40, 28],\n",
       "       [49, 31, 17,  8, 13]])"
      ]
     },
     "execution_count": 27,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(5)\n",
    "m = np.random.randint(1, 50, 15).reshape(3, 5)\n",
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5MBZYmjcFHHR",
    "outputId": "e0b5ef71-96a7-4825-aad7-7eb63cd732bb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([36., 28., 17.])"
      ]
     },
     "execution_count": 28,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(m, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "_FcfhGoiFHHR",
    "outputId": "31891fe9-0930-4e78-843d-7cad21656f80"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([26.5, 28. , 15. ])"
      ]
     },
     "execution_count": 29,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.nanmedian(np.array([[36, 15, np.nan, 39, 17],\n",
    "                       [np.nan,  9, 37, np.nan, 28],\n",
    "                       [49, np.nan, 17,  8, 13]]), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AsX3lGOOFHHS"
   },
   "source": [
    "### 2.4 計算標準差：`std()`, `nanstd()`\n",
    "\n",
    "`std()` 和 `nanstd()` 不同的地方在於後者會忽略 nan。如果元素中包含 nan 的話，則 `std()` 會回傳 nan。\n",
    "\n",
    "可以指定要計算標準差的軸，以及回傳值是否要保留維度。若是對於精度可能造成的誤差影響，可以改變 `dtype` 提高精度。\n",
    "\n",
    "如果要計算樣本標準差的話，可將 `ddof` (自由度) 引數傳入 1，在計算平均方差 (mean squared deviation) 時分母就會以 N - ddof 做計算。\n",
    "\n",
    "常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.std(a, axis=None, dtype=None, ddof=0, keepdims=<no value>)\n",
    "numpy.nanstd(a, axis=None, dtype=None, ddof=0, keepdims=<no value>)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "APRrSJY8FHHS",
    "outputId": "794a856a-4104-45ae-85a9-fa7ff722ae76"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.118033988749895"
      ]
     },
     "execution_count": 30,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.array([[1, 2], [3, 4]])\n",
    "np.std(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AstsZQ-vFHHS"
   },
   "source": [
    "### 2.5 計算變異數：`var()`, `nanvar()`\n",
    "\n",
    "`var()` 和 `nanvar()` 不同的地方在於後者會忽略 nan。如果元素中包含 nan 的話，則 `var()` 會回傳 nan。\n",
    "\n",
    "可以指定要計算變異數的軸，以及回傳值是否要保留維度。若是對於精度可能造成的誤差影響，可以改變 `dtype` 提高精度。\n",
    "\n",
    "如果要計算樣本變異數的話，可將 `ddof` (自由度) 引數傳入 1，在計算平均方差 (mean squared deviation) 時分母就會以 N - ddof 做計算。\n",
    "\n",
    "常用語法如下：\n",
    "\n",
    "```python\n",
    "numpy.var(a, axis=None, dtype=None, ddof=0, keepdims=<no value>)\n",
    "numpy.nanvar(a, axis=None, dtype=None, ddof=0, keepdims=<no value>\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "5kzvlmLAFHHS",
    "outputId": "5fe0e0ce-b6b5-4dda-c53f-678fe9cf8409"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.9166666666666665"
      ]
     },
     "execution_count": 31,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = np.array([[1, 2], [3, 4]])\n",
    "np.var(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "V0ORxLZbFHHT",
    "outputId": "2b9466a3-215a-473e-f25f-1a554fab2fe6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2.66666667, 2.66666667])"
      ]
     },
     "execution_count": 32,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(a, axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DoDtouiSFHHT",
    "outputId": "d28b47f1-8fc5-4f7f-bc94-2985f0cba6d7"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.25, 0.25, 0.25])"
      ]
     },
     "execution_count": 33,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "w0-ItW0KFHHT"
   },
   "source": [
    "## 3. 相關性"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "t66RDPmrFHHT"
   },
   "source": [
    "### 3.1 相關係數：`corrcoef()`\n",
    "\n",
    "`corrcoef()` 計算 Pearson 積差相關係數。引數 `rowvar` 預設值為 `True`，代表將每一個 row 當做是一筆變數。\n",
    "\n",
    "語法如下：\n",
    "\n",
    "```python\n",
    "numpy.corrcoef(x, y=None, rowvar=True)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "3Q-qdXxpFHHT"
   },
   "outputs": [],
   "source": [
    "x = np.random.randint(1, 20, 10).reshape(2, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-xckdQ9MFHHU",
    "outputId": "32047eb4-81d5-42f4-d3d1-bb3a0cdb2184"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.64936333],\n",
       "       [0.64936333, 1.        ]])"
      ]
     },
     "execution_count": 35,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.corrcoef(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fF7xMfAKFHHU"
   },
   "source": [
    "### 3.2 互相關 (Cross-correlation)：`correlate()`\n",
    "\n",
    "計算 2 個一維序列的互相關。`mode` 引數及回傳序列形狀如下表：\n",
    "\n",
    "|mode|回傳序列形狀|\n",
    "|---|---|\n",
    "|valid|max(M, N)|\n",
    "|full|(N+M-1,)|\n",
    "|same|max(M, N) - min(M, N) + 1|\n",
    "\n",
    "_N 為第1個序列的元素數，M為第2個序列的元素數。_\n",
    "\n",
    "`correlate()` 語法如下：\n",
    "```python\n",
    "numpy.correlate(a, v, mode='valid')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9Tm2T_tFFHHU",
    "outputId": "82362e90-224e-4784-9e89-1555a87d83bb"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 3])"
      ]
     },
     "execution_count": 36,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.correlate([1, 2, 3], [0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Yc8s0tFoFHHU"
   },
   "source": [
    "### 3.3 共變異數：`cov()`\n",
    "\n",
    "引數說明如下：\n",
    "\n",
    "|引數|說明|\n",
    "|---|---|\n",
    "|m|一維或二維陣列|\n",
    "|y|額外資料，形狀須與m相同|\n",
    "|rowvar|每一個 row 當做是一筆變數，預設值為 True|\n",
    "|bias|樣本共變異數的話設為 False (預設值)，母體設為 True|\n",
    "|ddof|自由度，預設值為 None|\n",
    "|fweights|頻率加權，預設值為 None|\n",
    "|aweights|觀測向量加權，預設值為 None|\n",
    "\n",
    "語法如下：\n",
    "```python\n",
    "numpy.cov(m, y=None, rowvar=True, bias=False, ddof=None, fweights=None, aweights=None)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lRL1afTBFHHU",
    "outputId": "9ace0a10-a6d6-4b53-9c7f-6aece0994106"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1., -1.],\n",
       "       [-1.,  1.]])"
      ]
     },
     "execution_count": 37,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([[0, 1, 2],\n",
    "              [2, 1, 0]])\n",
    "\n",
    "np.cov(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "rUEEZsPIFHHV"
   },
   "source": [
    "## 4. Histogram\n",
    "\n",
    "NumPy 提供 `np.histogram()` 函式來計算 histogram，基本語法如下：\n",
    "\n",
    "```python\n",
    "numpy.histogram(a, bins=10, range=None, normed=None, weights=None, density=None)\n",
    "```\n",
    "\n",
    "|引數|說明|\n",
    "|---|---|\n",
    "|a|輸入陣列|\n",
    "|bins|bins的定義，可傳入純量、序列、或是不同的方法 (例如：auto)|\n",
    "|range|bins的範圍，預設是 a.min() 與 a.max() 之間，或是依照傳入的範圍|\n",
    "|weights|權重值，陣列形狀須與a相同|\n",
    "|density|False：回傳各bin的count<br />True：回傳各bins的probability density|\n",
    "\n",
    "下面的例子是隨機產生包含 100 個 0 - 9 數字的二維陣列，計算 histogram。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "VRnskQuwFHHV",
    "outputId": "a1f9623f-3d04-448d-834e-174c75458fdc"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 9, 9, 9, 1, 2, 7, 0, 5, 0],\n",
       "       [0, 4, 4, 9, 3, 2, 4, 6, 9, 3],\n",
       "       [3, 2, 1, 5, 7, 4, 3, 1, 7, 3],\n",
       "       [1, 9, 5, 7, 0, 9, 6, 0, 5, 2],\n",
       "       [8, 6, 8, 0, 5, 2, 0, 7, 7, 6],\n",
       "       [0, 0, 8, 5, 5, 9, 6, 4, 5, 2],\n",
       "       [8, 8, 1, 6, 3, 4, 1, 8, 0, 2],\n",
       "       [2, 4, 1, 6, 3, 4, 3, 1, 4, 2],\n",
       "       [3, 4, 9, 4, 0, 6, 6, 9, 2, 9],\n",
       "       [3, 0, 8, 8, 9, 7, 4, 8, 6, 8]])"
      ]
     },
     "execution_count": 38,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.randint(0, 10, 100).reshape(10, 10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "Du3zAmesFHHV",
    "outputId": "5420b118-262d-40a3-8278-d073fbddb2e6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([12,  8, 10, 10, 12,  8, 10,  7, 23]),\n",
       " array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]))"
      ]
     },
     "execution_count": 39,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "hist, bin_edges = np.histogram(a, bins=9)\n",
    "hist, bin_edges"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1Su2O8UoFHHV"
   },
   "source": [
    "比較 `histogram()` 的結果與實際元素值的 count，下面的範例使用 `np.unique()` 來得到所有出現過的值與其 count (出現的次數)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "zAyOmrFPFHHV"
   },
   "outputs": [],
   "source": [
    "unique, counts = np.unique(a, return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "wBDNAsjvFHHW",
    "outputId": "5c863fc1-971b-4945-910f-7c8fcd4b1c62"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),\n",
       " array([12,  8, 10, 10, 12,  8, 10,  7, 10, 13]))"
      ]
     },
     "execution_count": 41,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "unique, counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D6uATaV7FHHW"
   },
   "source": [
    "若使用資料視覺化進行比較並觀察其分佈，可以產出下面的圖表，其結果與上面使用 `np.histogram()` 產生的數值是完全相同的。\n",
    "\n",
    "有關於 Matplotlib 的功能，會在後續資料視覺化的單元進行詳細介紹。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "i11Da5nVFHHW",
    "outputId": "ea0a5379-68c4-4a1b-c825-bc4d032a9e06"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([12.,  8., 10., 10., 12.,  8., 10.,  7., 23.]),\n",
       " array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.]),\n",
       " <a list of 9 Patch objects>)"
      ]
     },
     "execution_count": 42,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAD4CAYAAAD1jb0+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAKeklEQVR4nO3db4hlh1nH8d9jtqJNRVMyhJg/bpBSCUKTssRopFRTJTVi2jfSgCVIYX2RaioFiX2jLyNo1RdSWJvYgDEiaUqDLbUlFoogwU0abP5YUmLaJm6yG4o2+qamfXyxd83udDczO3Nn7jy7nw8Mc++55855OMx8OXPmnrnV3QFgnh9Y9QAAbI2AAwwl4ABDCTjAUAIOMNS+3dzYxRdf3Pv379/NTQKM9+ijj77c3Wvrl+9qwPfv35/Dhw/v5iYBxquqr59uuVMoAEMJOMBQAg4wlIADDCXgAEMJOMBQAg4wlIADDCXgAEPt6pWYALtt/52fWfUISZLn7rp56V/TETjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwy1YcCr6oqq+mJVPVVVT1bVHYvlb66qL1TVM4vPF+38uACcsJkj8FeTfLi7r05yfZLbq+rqJHcmebi735Lk4cV9AHbJhgHv7iPd/dji9itJnk5yWZJbkty7WO3eJO/ZqSEB+H5ndQ68qvYnuTbJI0ku6e4ji4deTHLJGZ5zsKoOV9XhY8eObWNUAE626YBX1ZuSfDLJh7r72yc/1t2dpE/3vO4+1N0HuvvA2tratoYF4DWbCnhVvSHH431fdz+4WPxSVV26ePzSJEd3ZkQATmczr0KpJHcnebq7P3rSQw8luW1x+7Ykn17+eACcyb5NrHNDkvcn+UpVPb5Y9pEkdyX5u6r6QJKvJ/n1nRkRgNPZMODd/U9J6gwP37jccQDYLFdiAgwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMJSAAwwl4ABDCTjAUAIOMNSGAa+qe6rqaFU9cdKyP6yqF6rq8cXHr+zsmACst5kj8E8kuek0y/+0u69ZfHx2uWMBsJENA97dX0ryrV2YBYCzsJ1z4B+sqn9dnGK56EwrVdXBqjpcVYePHTu2jc0BcLKtBvxjSX4yyTVJjiT5kzOt2N2HuvtAdx9YW1vb4uYAWG9LAe/ul7r7u939vSR/meS65Y4FwEa2FPCquvSku+9N8sSZ1gVgZ+zbaIWquj/JO5NcXFXPJ/mDJO+sqmuSdJLnkvzWDs4IwGlsGPDuvvU0i+/egVkAOAuuxAQYSsABhhJwgKEEHGAoAQcYSsABhhJwgKEEHGAoAQcYSsABhhJwgKEEHGAoAQcYSsABhhJwgKEEHGAoAQcYSsABhhJwgKEEHGAoAQcYasN3pd8r9t/5mVWPkCR57q6bVz0C6/je4HzlCBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGGrDgFfVPVV1tKqeOGnZm6vqC1X1zOLzRTs7JgDrbeYI/BNJblq37M4kD3f3W5I8vLgPwC7aMODd/aUk31q3+JYk9y5u35vkPUueC4ANbPUdeS7p7iOL2y8mueRMK1bVwSQHk+TKK6/c4uZYb6+8Cw17z1753vAORTtv23/E7O5O0q/z+KHuPtDdB9bW1ra7OQAWthrwl6rq0iRZfD66vJEA2IytBvyhJLctbt+W5NPLGQeAzdrMywjvT/LPSd5aVc9X1QeS3JXkl6rqmSTvWtwHYBdt+EfM7r71DA/duORZADgLrsQEGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYYScIChBBxgqK2+I895a6+82wl7j+8NdpsjcIChBBxgKAEHGErAAYYScIChBBxgKAEHGErAAYZyIQ+wI1zYtPMcgQMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQ23r38lW1XNJXkny3SSvdveBZQwFwMaW8f/Af6G7X17C1wHgLDiFAjDUdgPeST5fVY9W1cHTrVBVB6vqcFUdPnbs2DY3B8AJ2w34z3f325O8O8ntVfWO9St096HuPtDdB9bW1ra5OQBO2FbAu/uFxeejST6V5LplDAXAxrYc8Kq6sKp+5MTtJL+c5IllDQbA69vOq1AuSfKpqjrxdf6muz+3lKkA2NCWA97dzyZ52xJnAeAseBkhwFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQwk4wFACDjCUgAMMJeAAQ20r4FV1U1V9taq+VlV3LmsoADa25YBX1QVJ/iLJu5NcneTWqrp6WYMB8Pq2cwR+XZKvdfez3f2dJH+b5JbljAXARvZt47mXJfnmSfefT/Iz61eqqoNJDi7u/ndVfXWL27s4yctbfO65yP54jX1xKvvjVHtif9QfbevpP3G6hdsJ+KZ096Ekh7b7darqcHcfWMJI5wT74zX2xansj1Ody/tjO6dQXkhyxUn3L18sA2AXbCfg/5LkLVV1VVX9YJL3JXloOWMBsJEtn0Lp7ler6oNJ/iHJBUnu6e4nlzbZ99v2aZhzjP3xGvviVPbHqc7Z/VHdveoZANgCV2ICDCXgAEONCLhL9o+rqiuq6otV9VRVPVlVd6x6pr2gqi6oqi9X1d+vepZVq6ofq6oHqurfqurpqvrZVc+0KlX1u4ufkyeq6v6q+qFVz7Rsez7gLtk/xatJPtzdVye5Psnt5/G+ONkdSZ5e9RB7xJ8n+Vx3/1SSt+U83S9VdVmS30lyoLt/OsdfaPG+1U61fHs+4HHJ/v/r7iPd/dji9is5/sN52WqnWq2qujzJzUk+vupZVq2qfjTJO5LcnSTd/Z3u/s/VTrVS+5L8cFXtS/LGJP+x4nmWbkLAT3fJ/nkdrSSpqv1Jrk3yyGonWbk/S/J7Sb636kH2gKuSHEvyV4tTSh+vqgtXPdQqdPcLSf44yTeSHEnyX939+dVOtXwTAs46VfWmJJ9M8qHu/vaq51mVqvrVJEe7+9FVz7JH7Evy9iQf6+5rk/xPkvPyb0ZVdVGO/6Z+VZIfT3JhVf3GaqdavgkBd8n+SarqDTke7/u6+8FVz7NiNyT5tap6LsdPrf1iVf31akdaqeeTPN/dJ34reyDHg34+eleSf+/uY939v0keTPJzK55p6SYE3CX7C1VVOX5+8+nu/uiq51m17v797r68u/fn+PfFP3b3OXeUtVnd/WKSb1bVWxeLbkzy1ApHWqVvJLm+qt64+Lm5MefgH3R3/L8RbtcKLtnfy25I8v4kX6mqxxfLPtLdn13hTOwtv53kvsXBzrNJfnPF86xEdz9SVQ8keSzHX7315ZyDl9S7lB5gqAmnUAA4DQEHGErAAYYScIChBBxgKAEHGErAAYb6PwqGHfD2k2b2AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light",
      "tags": []
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.hist(a.reshape(-1), bins=9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "NKpgBYaoFHHW"
   },
   "source": [
    "## 5. `digitize()`\n",
    "\n",
    "`digitize()` 是用來將連續數值離散化的函式，傳入陣列及 bins (必須為一維陣列)，得到輸入陣的各元素值是屬於哪一個 bins，並回傳對應的 bin 索引。\n",
    "\n",
    "語法如下：\n",
    "```python\n",
    "numpy.digitize(x, bins, right=False)\n",
    "```\n",
    "\n",
    "其中引數 `right` 的傳入值影響到是否包含 bin 的左或右邊界，符合下列條件則 x 屬於 $i^{th}$ bin：\n",
    "\n",
    "|bins元素排序|引數值|說明|\n",
    "|---|---|---|\n",
    "|漸增|right=False|包含左邊界但不包含右邊界<br />bins[i-1] <= x < bins[i]|\n",
    "|漸增|right=True|不包含左邊界但包含右邊界<br />bins[i-1] < x <= bins[i]|\n",
    "|漸減|right=False|包含左邊界但不包含右邊界<br />bins[i-1] > x >= bins[i]|\n",
    "|漸減|right=True|不包含左邊界但包含右邊界<br />bins[i-1] >= x > bins[i]|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "R9owRjRsFHHX"
   },
   "outputs": [],
   "source": [
    "x = np.array([0.5, 6.2, 3.0, 1.7])\n",
    "bins = np.array([0.0, 1.0, 2.5, 4.0, 10.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "HcutHTlkFHHX",
    "outputId": "9fb98763-1550-46e2-a836-a8b61c88473d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 3, 2])"
      ]
     },
     "execution_count": 44,
     "metadata": {
      "tags": []
     },
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inds = np.digitize(x, bins)\n",
    "inds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "93lqkCE0FHHX"
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "@webio": {
   "lastCommId": null,
   "lastKernelId": null
  },
  "colab": {
   "collapsed_sections": [
    "5lXo4g9sFHHG",
    "IrmSehItFHHJ",
    "PKaAHnYuFHHM",
    "wg9d8-iKFHHN",
    "trQRF20PFHHR",
    "AsX3lGOOFHHS",
    "AstsZQ-vFHHS",
    "t66RDPmrFHHT",
    "fF7xMfAKFHHU",
    "Yc8s0tFoFHHU"
   ],
   "name": "範例程式.ipynb",
   "provenance": []
  },
  "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": 1
}