05-List_Operations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p style=\"text-align:center\">\n",
    "    <a href=\"https://nbviewer.jupyter.org/github/twMr7/Python-Machine-Learning/blob/master/05-List_Operations.ipynb\">\n",
    "        Open In Jupyter nbviewer\n",
    "        <img style=\"float: center;\" src=\"https://nbviewer.jupyter.org/static/img/nav_logo.svg\" width=\"120\" />\n",
    "    </a>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/twMr7/Python-Machine-Learning/blob/master/05-List_Operations.ipynb)\n",
    "\n",
    "# 5. `list` 序列容器操作\n",
    "\n",
    "`list` 是存放序列性資料的結構。語法使用逗號 `,` 分隔資料元素，用中括號（square brackets）`[` `]` 成對包住所有元素。 `list` 可以是巢狀多維度的，同一個 `list` 中也可以存放異質類型資料，不過一般使用情境還是以同類型的資料較適合。\n",
    "\n",
    "元素內容是按照儲存順序的 index 存取，語法為 **`[ index ]`**。 如果按照由前往後的順序，**第一個元素 index 是0**，依次往後遞增； 如果反過來由後往前存取，**最後一個元素 index 可以用-1**，依次向前遞減。 \n",
    "\n",
    "| List 範例                          | 說明                                          |\n",
    "|------------------------------------|-----------------------------------------------|\n",
    "| `[]`                               | 空的 list                                     |\n",
    "| `[5, 6, 7, 8]`                     | 四個數字元素的 list                           |\n",
    "| `['code', [42, 3.1415], 1.23, {}]` | 巢狀、異質的 list                             |\n",
    "\n",
    "- 內建函式 `list()` 可以用來建構一個新的`list`物件。\n",
    "- 內建函式 `len()` 可以用來回傳容器裡的元素個數。\n",
    "- 內建函式 `min()` 可以用來回傳容器中最小的元素。\n",
    "- 內建函式 `max()` 可以用來回傳容器中最大的元素。\n",
    "\n",
    "`list` 是序列容器，可以使用序列容器的共通方法（參閱官方文件 [Common Sequence Operations](https://docs.python.org/3/library/stdtypes.html#common-sequence-operations)）。 此外，`list` 在建立後，元素內容**可以**就地變更（mutable），標準函式庫另外還有提供可以就地變更的方法，請參閱官方文件 [Mutable Sequence Types](https://docs.python.org/3/library/stdtypes.html#typesseq-mutable)，以下是幾個常用的方法：\n",
    "- `append()` 追加一個元素在容器後面。\n",
    "- `extend()` 追加一系列的元素在容器後面。\n",
    "- `del L[m:n]` 刪除範圍內的元素，與 `L[m:n] = []` 相同。\n",
    "- `copy()` 產生一份複製，與 `L[:]` 相同。\n",
    "- `clear()` 移除所有的元素，與 `del L[:]` 相同。\n",
    "- `insert()` 插入元素到某個位置。\n",
    "- `remove()` 移除第一個出現的指定元素值。\n",
    "- `pop()` 回傳某個位置的元素值，並從容器中移除。\n",
    "- `sort()` 對元素就地排序。\n",
    "- `reverse()` 就地反轉元素順序。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### § `list` 是可以 In-Place 就地變更的序列容器\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [123, [4, 56], 'One-Two-Three', 7.89].\n"
     ]
    }
   ],
   "source": [
    "L = [123, [4, 56], 'One-Two-Three', 7.89]\n",
    "print('L = {}.'.format(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [135, [4, 56], 'One-Two-Three', 7.89], 1st element is changed.\n"
     ]
    }
   ],
   "source": [
    "# a += b 等同於 a = a + b\n",
    "L[0] += 12\n",
    "print('L = {}, 1st element is changed.'.format(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [135, [4, 22], 'One-Two-Three', 7.89], 2nd element is changed.\n"
     ]
    }
   ],
   "source": [
    "# a -= b 等同於 a = a - b\n",
    "L[1][1] -= 34\n",
    "print('L = {}, 2nd element is changed.'.format(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [135, [4, 22], 'One-Two-ThreeOne-Two-Three', 7.89], 3rd element is changed.\n"
     ]
    }
   ],
   "source": [
    "# a *= b 等同於 a = a * b\n",
    "L[2] *= 2\n",
    "print('L = {}, 3rd element is changed.'.format(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [135, [4, 22], 'One-Two-ThreeOne-Two-Three', 14.089285714285712], 4th element is changed.\n"
     ]
    }
   ],
   "source": [
    "# a /= b 等同於 a = a / b\n",
    "L[3] /= 0.56\n",
    "print('L = {}, 4th element is changed.'.format(L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### § Slices 片段也可以就地變更"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g'], 7 elements.\n"
     ]
    }
   ],
   "source": [
    "letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']\n",
    "print('letters = {}, {} elements.'.format(letters, len(letters)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letters = ['a', 'b', 99, 100, 101, 'f', 'g'], 7 elements.\n"
     ]
    }
   ],
   "source": [
    "# 將序號 2 到 4 的元素分別用新的數值取代\n",
    "letters[2:5] = [ord('c'), ord('d'), ord('e')]\n",
    "print('letters = {}, {} elements.'.format(letters, len(letters)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letters = ['a', 'b', 'X', 'f', 'g'], 5 elements.\n"
     ]
    }
   ],
   "source": [
    "# 將序號 2 到 4 的元素全部用一個新的值取代\n",
    "letters[2:5] = 'X'\n",
    "print('letters = {}, {} elements.'.format(letters, len(letters)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letters = ['a', 'b'], 2 elements.\n"
     ]
    }
   ],
   "source": [
    "# 將序號 2 到 4 的元素刪除\n",
    "letters[2:5] = []\n",
    "print('letters = {}, {} elements.'.format(letters, len(letters)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "letters = [], 0 elements.\n"
     ]
    }
   ],
   "source": [
    "# 可以用空的 [] 來清空 list\n",
    "letters[:] = []\n",
    "print('letters = {}, {} elements.'.format(letters, len(letters)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### § 讀取的索引值還是不能超過範圍，但寫入和 Slice 的索引範圍可以。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-11-27568a3683fb>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# 讀取超過範圍的索引會出現 IndexError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mL\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "# 讀取超過範圍的索引會出現 IndexError\n",
    "print(L[4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [135, [4, 22], 'One-Two-ThreeOne-Two-Three', 14.089285714285712].\n",
      "L reversed = [14.089285714285712, 'One-Two-ThreeOne-Two-Three', [4, 22], 135].\n"
     ]
    }
   ],
   "source": [
    "# 但是 Slice 範圍超過只會被默默忽略\n",
    "print('L = {}.'.format(L[:10]))\n",
    "print('L reversed = {}.'.format(L[-1:-9:-1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L extended = [135, [4, 22], 'One-Two-ThreeOne-Two-Three', 14.089285714285712, 0, 1], now length = 6.\n"
     ]
    }
   ],
   "source": [
    "# 寫入新的 list 物件到索引結束的後面，可以直接追加元素進去\n",
    "L[len(L):] = list(range(2))\n",
    "print('L extended = {}, now length = {}.'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L extended = [135, [4, 22], 'One-Two-ThreeOne-Two-Three', 14.089285714285712, 0, 1, 3, 4], now length = 8.\n"
     ]
    }
   ],
   "source": [
    "# 寫入的 slice 索引超過結束的後面，一樣被忽略\n",
    "L[len(L) + 2:] = [3, 4]\n",
    "print('L extended = {}, now length = {}.'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L extended = [135, [4, 22], 'One-Two-ThreeOne-Two-Three', 14.089285714285712, 0, 1, 2, 3, 4, 5], now length = 10.\n"
     ]
    }
   ],
   "source": [
    "# 寫入的 slice 索引橫跨原本有和沒有的範圍，則原本有的會被覆蓋，原本沒有的範圍會新增\n",
    "L[-2:] = [2, 3, 4, 5]\n",
    "print('L extended = {}, now length = {}.'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### § 使用 `list` 物件的方法 (Methods) 來操作\n",
    "針對新增、刪除、插入等 in-place 變更的操作，原則上會建議使用 `list` 物件提供的方法，這樣會使得程式碼可讀性比較高。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [], length = 0\n"
     ]
    }
   ],
   "source": [
    "# 刪除所有元素\n",
    "L.clear()\n",
    "print('L = {}, length = {}'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [0, 1, 2], length = 3\n"
     ]
    }
   ],
   "source": [
    "# 新增一系列元素\n",
    "L.extend(range(3))\n",
    "print('L = {}, length = {}'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [0, 1, 2, [0, 1, 2]], length = 4\n"
     ]
    }
   ],
   "source": [
    "# 新增一個元素，注意和 extend() 方法有甚麼差異\n",
    "L.append(list(range(3)))\n",
    "print('L = {}, length = {}'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L = [0, 1, 2], length = 3\n"
     ]
    }
   ],
   "source": [
    "# 刪除最後一個元素\n",
    "del L[-1:]\n",
    "print('L = {}, length = {}'.format(L, len(L)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "L2 = [[0, 1, 2], [0, 1, 2], [0, 1, 2]],\n",
      "(L2[0], L2[1], L2[2]) 和 L 是同一份參考嗎？ (True, True, True)\n"
     ]
    }
   ],
   "source": [
    "# 複製三份 L 串成新的 list 物件，注意三份都是同一個物件的參考\n",
    "L2 = [L] * 3\n",
    "print('\\nL2 = {},\\n(L2[0], L2[1], L2[2]) 和 L 是同一份參考嗎？ ({}, {}, {})'\n",
    "      .format(L2, L2[0] is L, L2[1] is L, L2[2] is L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "L2copy = [[0, 1, 2], [0, 1, 2], [0, 1, 2]],\n",
      "L2copy 和 L2 是同一份參考嗎？ (False),\n",
      "L2copy[0] 和 L 是同一份參考嗎？ (True)\n"
     ]
    }
   ],
   "source": [
    "# copy() 是所謂的 shallow copy\n",
    "L2copy = L2.copy()\n",
    "print('\\nL2copy = {},\\nL2copy 和 L2 是同一份參考嗎？ ({}),\\nL2copy[0] 和 L 是同一份參考嗎？ ({})'\n",
    "      .format(L2copy, L2copy is L2, L2copy[0] is L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "L = [0, 1, 0.5, 2, 1.5]\n",
      "L2 = [[0, 1, 0.5, 2, 1.5], [0, 1, 0.5, 2, 1.5], [0, 1, 0.5, 2, 1.5]]\n",
      "L2copy = [[0, 1, 0.5, 2, 1.5], [0, 1, 0.5, 2, 1.5], [0, 1, 0.5, 2, 1.5]]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# 既然都參考到同一個物件，有一個內容改變了，其他也會跟著變\n",
    "L.insert(2, 0.5)\n",
    "L.append(1.5)\n",
    "print('\\nL = {}\\nL2 = {}\\nL2copy = {}\\n'.format(L, L2, L2copy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "List 有提供 in-place 排序的方法 `sort()`。另外 Python 也有一個內建函式 `sorted()` 可以用來排序，這個內建函式不是 in-place 排序，但通用於所有支援迭代（iterator）的物件。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "由小到大排序 L = [0, 0.5, 1, 1.5, 2]\n"
     ]
    }
   ],
   "source": [
    "# 將元素內容排序\n",
    "L.sort()\n",
    "print('由小到大排序 L = {}'.format(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "由大到小排序 L = [2, 1.5, 1, 0.5, 0]\n"
     ]
    }
   ],
   "source": [
    "L.sort(reverse=True)\n",
    "print('由大到小排序 L = {}'.format(L))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "L 的內容由小到大排序，新的 list = [0, 0.5, 1, 1.5, 2]，原本的 L = [2, 1.5, 1, 0.5, 0] 沒變\n"
     ]
    }
   ],
   "source": [
    "# Python 內建函式 sorted 是回傳一個新的 list 物件，不是 in-place 排序。\n",
    "print('L 的內容由小到大排序，新的 list = {}，原本的 L = {} 沒變'.format(sorted(L), L))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5.1 List Comprehension\n",
    "\n",
    "對於序列容器或可迭代物件 S 進行操作，並生成一個新的 `list` 物件。\n",
    "\n",
    "| 成員的操作                        | 說明                                                              |\n",
    "|-----------------------------------|-------------------------------------------------------------------|\n",
    "| `[運算表示句 for x in S]`         | 針對每個 S 的成員 x 做運算，運算結果生成新的 list 物件            |\n",
    "| `[運算表示句 for x in S if 條件]` | 針對每個***符合條件***的成員 x 做運算，運算結果生成新的 list 物件 |\n",
    "\n",
    "List comprehension 語法結構可組成相當豐富的條件式迭代運算\n",
    "```\n",
    "[運算表示句 for x1 in S1 if 條件1\n",
    "            for x2 in S2 if 條件2 ...\n",
    "            for xN in SN if 條件N]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 12, 13, 14, 15]\n",
      "[21, 22, 23, 24, 25]\n"
     ]
    }
   ],
   "source": [
    "# 使用 for 迴圈操作 List 容器裡的成員\n",
    "L = [1, 2, 3, 4, 5]\n",
    "for i in range(len(L)):\n",
    "    L[i] += 10\n",
    "print(L)\n",
    "\n",
    "# 使用 List Comprehension 生成新的 List 物件\n",
    "L = [x + 10 for x in L]\n",
    "print(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 8, 12, 16]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 條件式挑選部份成員作處理\n",
    "L = list(range(10))\n",
    "Lnew = [n*2 for n in L if n % 2 == 0]\n",
    "Lnew"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5)]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 巢狀迴圈 + 條件式\n",
    "L1 = list(range(1, 4))\n",
    "L2 = list(range(3, 6))\n",
    "\n",
    "# 一般的巢狀迴圈寫法落落長\n",
    "#Lnew = []\n",
    "#for x in L1:\n",
    "#    for y in L2:\n",
    "#        if x != y:\n",
    "#            Lnew.append((x, y))\n",
    "\n",
    "# List comprehension 的巢狀迴圈\n",
    "Lnew = [(x, y) for x in L1 for y in L2 if x != y]\n",
    "Lnew"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### § 與其他方法比較\n",
    "\n",
    "+ List comprehension 與生成運算表示的語法，除了括號的不同以外其他幾乎都一樣。 但生成運算表示只返回迭代子，不需要在記憶體中生成所有成員再來迭代運算，在大量運算時會比較節省記憶體空間。\n",
    "+ 內建函式 `map(function, iterable)` 是一個生成函式，返回一個尋訪參數2的可迭代物件，每次的迭代都返回指定函式（參數1）循序套用到尋訪參數2成員的結果。\n",
    "+ 內建函式 `filter(function, iterable)` 是一個生成函式，返回一個尋訪參數2的可迭代物件，每次迭代只會返回符合函式（參數1）測試結果的參數2的成員。\n",
    "+ `functools` 模組裡的 `reduce(function, iterable[, initializer])` 累進式套用兩個參數的函式（或二元運算子）到序列的每個成員，一直到序列化簡成單一值為止。\n",
    "\n",
    "由於 `map`, `filter`, 以及 `reduce` 都需要套用函式呼叫，時常需要另外定義額外的 `lambda` 函式來輔助。\n",
    "\n",
    "一般而言，使用 `map`, `filter` 的程式效能通常比 `for` 迴圈快；而使用 list comprehension 通常又比 `map`, `filter` 還快。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[31.0, 0.3, 52.0, 46.5, 12.0, 94.7]\n",
      "[31.0, 0.3, 52.0, 46.5, 12.0, 94.7]\n",
      "[31.0, 0.3, 52.0, 46.5, 12.0, 94.7]\n"
     ]
    }
   ],
   "source": [
    "L = ['31', '0.3', '52', '46.5', '12', '94.7']\n",
    "\n",
    "# 使用 List comprehension 將字串清單轉成數值清單\n",
    "print([float(s) for s in L])\n",
    "\n",
    "# 使用生成運算表示將字串清單轉成數值清單\n",
    "print(list(float(s) for s in L))\n",
    "\n",
    "# 使用 map() 將字串清單轉成數值清單\n",
    "print(list(map(float, L)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[31, 52, 12]\n",
      "[31, 52, 12]\n",
      "[31, 52, 12]\n"
     ]
    }
   ],
   "source": [
    "# 使用 List comprehension 僅將清單裡的十進位整數字串轉成數值\n",
    "print([int(s) for s in L if s.isdecimal()])\n",
    "\n",
    "# 使用生成運算表示將清單裡的十進位整數字串轉成數值\n",
    "print(list(int(s) for s in L if s.isdecimal()))\n",
    "\n",
    "# 使用 map() + filter() 將清單裡的十進位整數字串轉成數值\n",
    "print(list(map(int, filter(str.isdecimal, L))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "236.5\n",
      "236.5\n",
      "236.5\n",
      "236.5\n"
     ]
    }
   ],
   "source": [
    "# List comprehension 要另外靠函式來達到 reduce 相同的效果\n",
    "print(sum([float(s) for s in L]))\n",
    "\n",
    "# 生成運算表示也要另外靠函式來達到 reduce 相同的效果\n",
    "print(sum(float(s) for s in L))\n",
    "\n",
    "# 使用 functools.reduce() 將清單裡的字串數值加總\n",
    "import operator, functools\n",
    "print(functools.reduce(operator.add, [float(s) for s in L]))\n",
    "\n",
    "# operator.add 改用自定義 lambda\n",
    "print(functools.reduce((lambda x, y: x + y), (float(s) for s in L)))"
   ]
  }
 ],
 "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}