99 [補充] map filter 和 list comprehension.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![APCS 2](images/T_apcs02.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `map` 的複習\n",
    "\n",
    "要把一個函式用到一個 list 上每一個元素時, 我們可以用 `map` 指令。\n",
    "\n",
    "比如說, 下面的 list, 我們想要都變成整數型態。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = list('94871234')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['9', '4', '8', '7', '1', '2', '3', '4']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "就把 `int` 用到整個 list。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<map at 0x7fbc58531908>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "map(int, mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但這樣是抽象的 `map`, 想具體看到是用 `list` 換成具體的 list。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[9, 4, 8, 7, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(int, mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 複習: 救急函數 `lambda`\n",
    "\n",
    "`map` 可以用任何可作用到一個 list 上每個元素的函數。我們當然可以定義自己的函數。\n",
    "\n",
    "比方說我們想把一個 list 中的數字都平方..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist = [9, 4, 8, 7, 3, 5, 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我們要先訂一個平方函式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def square(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "squared = map(square, mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "用 list 看一下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[81, 16, 64, 49, 9, 25, 100]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(squared)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但這也太麻煩了!\n",
    "\n",
    "這種臨時要用的, 可以用 `lambda` 來定義這個函數。語法是:\n",
    "\n",
    "    lambda 輸入:輸出\n",
    "    \n",
    "比方說剛剛的平方動作..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[81, 16, 64, 49, 9, 25, 100]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x:x**2, mylist))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python 超炫的 list comprehension\n",
    "\n",
    "Python 有個很炫的快速 list 產成方式, 叫 list comprehension。\n",
    "\n",
    "簡單的說, 很像我們數學集合表示法。比方說, 有個集合是:\n",
    "\n",
    "$$\\{ 2k+1 \\mid k \\in \\{0, 1, 2, 3, 4, 5\\} \\}$$\n",
    "\n",
    "就是前 6 個奇數:\n",
    "\n",
    "$$\\{1, 3, 5, 7, 9, 11 \\}$$\n",
    "\n",
    "在 Python 可以這麼做..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[2*k+1 for k in range(5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "是不是超級酷!\n",
    "\n",
    "我們也可做相當複雜的事情。比如說現在我們想把一個字串:\n",
    "\n",
    "    st = 'abxCDefGHLmk'\n",
    "\n",
    "轉成\n",
    "\n",
    "    binary_str = '000110011100'\n",
    "    \n",
    "也就是小寫就記為 0, 大寫記為 1。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "st = 'abxCDefGHLmk'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[False, False, False, True, True, False, False, True, True, True, False, False]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x.isupper() for x in st]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有... 一點... 酷, 那就是... 出現一個 list, 小寫是 Flase, 大寫是 True...\n",
    "\n",
    "我們是要 0 和 1...\n",
    "\n",
    "但我們看一下兩個判斷式。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True == 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "False == 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "這其實就是 0, 1 耶, 這時只要把這 True, False 用 `int` 轉換就可以!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[int(x.isupper()) for x in st]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "是不是很炫? 但我們要的是字串, 不要緊、再來..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '0', '0', '1', '1', '0', '0', '1', '1', '1', '0', '0']"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(int(x.isupper())) for x in st]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "把這個 list 再合成字串可以嗎? 可以哦, 用 `join`..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'000110011100'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "''.join([str(int(x.isupper())) for x in st])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "是不是很炫?\n",
    "\n",
    "不過說實在這不太易讀, 我們也不一定非要這樣耍寶。只是說 Python 可以這麼做。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `enumerate`\n",
    "\n",
    "我們要把一個 list 的元素, 一一列出來的時候...\n",
    "\n",
    "就是用 `for` 迴圈。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = ['python', 'matplotlib', 'pandas', 'scikit-learn']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "python\n",
      "matplotlib\n",
      "pandas\n",
      "scikit-learn\n"
     ]
    }
   ],
   "source": [
    "for i in L:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "有時, 我們需要知道它的 `index`, 也就是第幾個元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 python\n",
      "1 matplotlib\n",
      "2 pandas\n",
      "3 scikit-learn\n"
     ]
    }
   ],
   "source": [
    "for i in range(len(L)):\n",
    "    print(i, L[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "但這好像麻煩了點。可以有更簡單的方式嗎? 有的, 就是用 `enumerate`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 'python')\n",
      "(1, 'matplotlib')\n",
      "(2, 'pandas')\n",
      "(3, 'scikit-learn')\n"
     ]
    }
   ],
   "source": [
    "for x in enumerate(L):\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### unpack 技巧\n",
    "\n",
    "我們其實用了好幾次, 但沒認真說的是, Python 很容易從一個 tuple (或 list) 取出元素。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = (8, 7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "所以, 用在 `enumerate` 上就會是..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 python\n",
      "1 matplotlib\n",
      "2 pandas\n",
      "3 scikit-learn\n"
     ]
    }
   ],
   "source": [
    "for i, x in enumerate(L):\n",
    "    print(i, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "更炫的是, 從 1 (或任何數字) 開始都可以!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 python\n",
      "2 matplotlib\n",
      "3 pandas\n",
      "4 scikit-learn\n"
     ]
    }
   ],
   "source": [
    "for i, x in enumerate(L, 1):\n",
    "    print(i, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 程式技巧\n",
    "\n",
    "先想好自己的策略, 分析需要什麼東西, 再想辦法寫成程式。\n",
    "\n",
    "例如, 我們想確認某字串最長的 $k$-交錯子字串是多長。\n",
    "\n",
    "#### step 1. 字串轉換\n",
    "\n",
    "    st = 'abxCDefGHLmk'\n",
    "    \n",
    "轉成\n",
    "\n",
    "    binary_str = '000110011100'\n",
    "    \n",
    "也就是小寫就記為 0, 大寫記為 1。\n",
    "\n",
    "#### step 2. 檢查交錯字串\n",
    "\n",
    "假設我們要看的是 2-交錯字串。 (k=2)\n",
    "\n",
    "##### 第 1 回合\n",
    "我們至少要看到其中一種模式:\n",
    "\n",
    "    p0 = \"00\"\n",
    "    p1 = \"11\"\n",
    "    \n",
    "也就是\n",
    "\n",
    "    p0 in binary_str\n",
    "    p1 in binary_str\n",
    "    \n",
    "至少一個成立, 那就進到第 2 回合, 否則就停止。\n",
    "\n",
    "##### 第 2 回合\n",
    "我們至少要看到其中一種模式:\n",
    "\n",
    "    p0 = \"0011\"\n",
    "    p1 = \"1100\"\n",
    "    \n",
    "也就是\n",
    "\n",
    "    p0 in binary_str\n",
    "    p1 in binary_str\n",
    "    \n",
    "至少一個成立, 那就進到第 3 回合, 否則就停止。\n",
    "\n",
    "##### 第 3 回合\n",
    "我們至少要看到其中一種模式:\n",
    "\n",
    "    p0 = \"001100\"\n",
    "    p1 = \"110011\"\n",
    "    \n",
    "也就是\n",
    "\n",
    "    p0 in binary_str\n",
    "    p1 in binary_str\n",
    "    \n",
    "至少一個成立, 那就進到第 3 回合, 否則就停止。\n",
    "\n",
    "我們要看最後第幾回合是成功的 (假設是 round 回), 那最後答案就是:\n",
    "\n",
    "    round*k"
   ]
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}